issuables_helper_spec.rb 7.26 KB
Newer Older
Phil Hughes's avatar
Phil Hughes committed
1 2
require 'spec_helper'

3
describe IssuablesHelper do
Phil Hughes's avatar
Phil Hughes committed
4 5 6
  let(:label)  { build_stubbed(:label) }
  let(:label2) { build_stubbed(:label) }

7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
  describe '#users_dropdown_label' do
    let(:user)  { build_stubbed(:user) }
    let(:user2)  { build_stubbed(:user) }

    it 'returns unassigned' do
      expect(users_dropdown_label([])).to eq('Unassigned')
    end

    it 'returns selected user\'s name' do
      expect(users_dropdown_label([user])).to eq(user.name)
    end

    it 'returns selected user\'s name and counter' do
      expect(users_dropdown_label([user, user2])).to eq("#{user.name} + 1 more")
    end
  end

24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
  describe '#group_dropdown_label' do
    let(:group)  { create(:group) }
    let(:default) { 'default label' }

    it 'returns default group label when group_id is nil' do
      expect(group_dropdown_label(nil, default)).to eq('default label')
    end

    it 'returns "any group" when group_id is 0' do
      expect(group_dropdown_label('0', default)).to eq('Any group')
    end

    it 'returns group full path when a group was found for the provided id' do
      expect(group_dropdown_label(group.id, default)).to eq(group.full_name)
    end

    it 'returns default label when a group was not found for the provided id' do
      expect(group_dropdown_label(9999, default)).to eq('default label')
    end
  end

45
  describe '#issuable_labels_tooltip' do
46 47 48 49 50
    it 'returns label text with no labels' do
      expect(issuable_labels_tooltip([])).to eq("Labels")
    end

    it 'returns label text with labels within max limit' do
Phil Hughes's avatar
Phil Hughes committed
51 52 53
      expect(issuable_labels_tooltip([label])).to eq(label.title)
    end

54
    it 'returns label text with labels exceeding max limit' do
Phil Hughes's avatar
Phil Hughes committed
55 56 57
      expect(issuable_labels_tooltip([label, label2], limit: 1)).to eq("#{label.title}, and 1 more")
    end
  end
58 59 60 61 62 63 64 65 66 67

  describe '#issuables_state_counter_text' do
    let(:user) { create(:user) }

    describe 'state text' do
      before do
        allow(helper).to receive(:issuables_count_for_state).and_return(42)
      end

      it 'returns "Open" when state is :opened' do
68
        expect(helper.issuables_state_counter_text(:issues, :opened, true))
Clement Ho's avatar
Clement Ho committed
69
          .to eq('<span>Open</span> <span class="badge badge-pill">42</span>')
70 71 72
      end

      it 'returns "Closed" when state is :closed' do
73
        expect(helper.issuables_state_counter_text(:issues, :closed, true))
Clement Ho's avatar
Clement Ho committed
74
          .to eq('<span>Closed</span> <span class="badge badge-pill">42</span>')
75 76 77
      end

      it 'returns "Merged" when state is :merged' do
78
        expect(helper.issuables_state_counter_text(:merge_requests, :merged, true))
Clement Ho's avatar
Clement Ho committed
79
          .to eq('<span>Merged</span> <span class="badge badge-pill">42</span>')
80 81 82
      end

      it 'returns "All" when state is :all' do
83
        expect(helper.issuables_state_counter_text(:merge_requests, :all, true))
Clement Ho's avatar
Clement Ho committed
84
          .to eq('<span>All</span> <span class="badge badge-pill">42</span>')
85 86 87
      end
    end
  end
88

89 90 91 92 93 94 95 96 97 98 99 100 101
  describe '#issuable_reference' do
    context 'when show_full_reference truthy' do
      it 'display issuable full reference' do
        assign(:show_full_reference, true)
        issue = build_stubbed(:issue)

        expect(helper.issuable_reference(issue)).to eql(issue.to_reference(full: true))
      end
    end

    context 'when show_full_reference falsey' do
      context 'when @group present' do
        it 'display issuable reference to @group' do
102
          project = build_stubbed(:project)
103 104 105 106 107 108 109 110 111 112 113 114

          assign(:show_full_reference, nil)
          assign(:group, project.namespace)

          issue = build_stubbed(:issue)

          expect(helper.issuable_reference(issue)).to eql(issue.to_reference(project.namespace))
        end
      end

      context 'when @project present' do
        it 'display issuable reference to @project' do
115
          project = build_stubbed(:project)
116 117 118 119 120 121 122 123 124 125 126 127 128

          assign(:show_full_reference, nil)
          assign(:group, nil)
          assign(:project, project)

          issue = build_stubbed(:issue)

          expect(helper.issuable_reference(issue)).to eql(issue.to_reference(project))
        end
      end
    end
  end

129 130 131
  describe '#updated_at_by' do
    let(:user) { create(:user) }
    let(:unedited_issuable) { create(:issue) }
132
    let(:edited_issuable) { create(:issue, last_edited_by: user, created_at: 3.days.ago, updated_at: 1.day.ago, last_edited_at: 2.days.ago) }
133 134
    let(:edited_updated_at_by) do
      {
135
        updatedAt: edited_issuable.last_edited_at.to_time.iso8601,
136
        updatedBy: {
137 138 139 140 141 142 143 144
          name: user.name,
          path: user_path(user)
        }
      }
    end

    it { expect(helper.updated_at_by(unedited_issuable)).to eq({}) }
    it { expect(helper.updated_at_by(edited_issuable)).to eq(edited_updated_at_by) }
145 146 147 148

    context 'when updated by a deleted user' do
      let(:edited_updated_at_by) do
        {
149
          updatedAt: edited_issuable.last_edited_at.to_time.iso8601,
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
          updatedBy: {
            name: User.ghost.name,
            path: user_path(User.ghost)
          }
        }
      end

      before do
        user.destroy
      end

      it 'returns "Ghost user" as edited_by' do
        expect(helper.updated_at_by(edited_issuable.reload)).to eq(edited_updated_at_by)
      end
    end
165
  end
166 167 168 169 170 171 172 173 174 175 176 177 178 179

  describe '#issuable_initial_data' do
    let(:user) { create(:user) }

    before do
      allow(helper).to receive(:current_user).and_return(user)
      allow(helper).to receive(:can?).and_return(true)
    end

    it 'returns the correct json for an issue' do
      issue = create(:issue, author: user, description: 'issue text')
      @project = issue.project

      expected_data = {
180 181 182 183 184 185 186
        endpoint: "/#{@project.full_path}/issues/#{issue.iid}",
        updateEndpoint: "/#{@project.full_path}/issues/#{issue.iid}.json",
        canUpdate: true,
        canDestroy: true,
        issuableRef: "##{issue.iid}",
        markdownPreviewPath: "/#{@project.full_path}/preview_markdown",
        markdownDocsPath: '/help/user/markdown',
187
        markdownVersion: CacheMarkdownField::CACHE_COMMONMARK_VERSION,
188 189 190 191 192 193 194 195
        issuableTemplates: [],
        projectPath: @project.path,
        projectNamespace: @project.namespace.path,
        initialTitleHtml: issue.title,
        initialTitleText: issue.title,
        initialDescriptionHtml: '<p dir="auto">issue text</p>',
        initialDescriptionText: 'issue text',
        initialTaskStatus: '0 of 0 tasks completed'
196
      }
197
      expect(helper.issuable_initial_data(issue)).to eq(expected_data)
198 199
    end
  end
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228

  describe '#selected_labels' do
    context 'if label_name param is a string' do
      it 'returns a new label with title' do
        allow(helper).to receive(:params)
          .and_return(ActionController::Parameters.new(label_name: 'test label'))

        labels = helper.selected_labels

        expect(labels).to be_an(Array)
        expect(labels.size).to eq(1)
        expect(labels.first.title).to eq('test label')
      end
    end

    context 'if label_name param is an array' do
      it 'returns a new label with title for each element' do
        allow(helper).to receive(:params)
          .and_return(ActionController::Parameters.new(label_name: ['test label 1', 'test label 2']))

        labels = helper.selected_labels

        expect(labels).to be_an(Array)
        expect(labels.size).to eq(2)
        expect(labels.first.title).to eq('test label 1')
        expect(labels.second.title).to eq('test label 2')
      end
    end
  end
Phil Hughes's avatar
Phil Hughes committed
229
end