service_spec.rb 10.7 KB
Newer Older
1 2
require 'spec_helper'

3
describe Service do
4
  describe "Associations" do
5 6
    it { is_expected.to belong_to :project }
    it { is_expected.to have_one :service_hook }
7 8
  end

Tiago Botelho's avatar
Tiago Botelho committed
9
  describe 'Validations' do
10
    it { is_expected.to validate_presence_of(:type) }
Tiago Botelho's avatar
Tiago Botelho committed
11 12
  end

13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
  describe 'Scopes' do
    describe '.confidential_note_hooks' do
      it 'includes services where confidential_note_events is true' do
        create(:service, active: true, confidential_note_events: true)

        expect(described_class.confidential_note_hooks.count).to eq 1
      end

      it 'excludes services where confidential_note_events is false' do
        create(:service, active: true, confidential_note_events: false)

        expect(described_class.confidential_note_hooks.count).to eq 0
      end
    end
  end

29
  describe "Test Button" do
30 31
    describe '#can_test?' do
      let(:service) { create(:service, project: project) }
32

33 34
      context 'when repository is not empty' do
        let(:project) { create(:project, :repository) }
35

36 37 38
        it 'returns true' do
          expect(service.can_test?).to be true
        end
39 40
      end

41
      context 'when repository is empty' do
42
        let(:project) { create(:project) }
43 44 45 46

        it 'returns true' do
          expect(service.can_test?).to be true
        end
47
      end
48
    end
49

50 51 52 53 54 55
    describe '#test' do
      let(:data) { 'test' }
      let(:service) { create(:service, project: project) }

      context 'when repository is not empty' do
        let(:project) { create(:project, :repository) }
56 57

        it 'test runs execute' do
58
          expect(service).to receive(:execute).with(data)
59

60
          service.test(data)
61 62
        end
      end
63

64
      context 'when repository is empty' do
65
        let(:project) { create(:project) }
66

67 68
        it 'test runs execute' do
          expect(service).to receive(:execute).with(data)
69

70 71
          service.test(data)
        end
72 73 74
      end
    end
  end
75 76

  describe "Template" do
77 78 79 80
    describe '.build_from_template' do
      context 'when template is invalid' do
        it 'sets service template to inactive when template is invalid' do
          project = create(:project)
81
          template = KubernetesService.new(template: true, active: true)
82 83 84 85 86 87 88 89 90 91
          template.save(validate: false)

          service = described_class.build_from_template(project.id, template)

          expect(service).to be_valid
          expect(service.active).to be false
        end
      end
    end

92
    describe "for pushover service" do
93
      let!(:service_template) do
94 95 96 97 98 99 100 101 102
        PushoverService.create(
          template: true,
          properties: {
            device: 'MyDevice',
            sound: 'mic',
            priority: 4,
            api_key: '123456789'
          })
      end
103
      let(:project) { create(:project) }
104

105 106
      describe 'is prefilled for projects pushover service' do
        it "has all fields prefilled" do
107 108
          service = project.find_or_initialize_service('pushover')

109 110 111 112 113 114 115 116 117
          expect(service.template).to eq(false)
          expect(service.device).to eq('MyDevice')
          expect(service.sound).to eq('mic')
          expect(service.priority).to eq(4)
          expect(service.api_key).to eq('123456789')
        end
      end
    end
  end
118

119
  describe "{property}_changed?" do
120 121
    let(:service) do
      BambooService.create(
122
        project: create(:project),
123 124 125 126 127 128 129 130
        properties: {
          bamboo_url: 'http://gitlab.com',
          username: 'mic',
          password: "password"
        }
      )
    end

131
    it "returns false when the property has not been assigned a new value" do
132
      service.username = "key_changed"
133
      expect(service.bamboo_url_changed?).to be_falsy
134 135
    end

136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
    it "returns true when the property has been assigned a different value" do
      service.bamboo_url = "http://example.com"
      expect(service.bamboo_url_changed?).to be_truthy
    end

    it "returns true when the property has been assigned a different value twice" do
      service.bamboo_url = "http://example.com"
      service.bamboo_url = "http://example.com"
      expect(service.bamboo_url_changed?).to be_truthy
    end

    it "returns false when the property has been re-assigned the same value" do
      service.bamboo_url = 'http://gitlab.com'
      expect(service.bamboo_url_changed?).to be_falsy
    end

    it "returns false when the property has been assigned a new value then saved" do
      service.bamboo_url = 'http://example.com'
      service.save
      expect(service.bamboo_url_changed?).to be_falsy
    end
  end

  describe "{property}_touched?" do
    let(:service) do
      BambooService.create(
162
        project: create(:project),
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
        properties: {
          bamboo_url: 'http://gitlab.com',
          username: 'mic',
          password: "password"
        }
      )
    end

    it "returns false when the property has not been assigned a new value" do
      service.username = "key_changed"
      expect(service.bamboo_url_touched?).to be_falsy
    end

    it "returns true when the property has been assigned a different value" do
      service.bamboo_url = "http://example.com"
      expect(service.bamboo_url_touched?).to be_truthy
    end

    it "returns true when the property has been assigned a different value twice" do
      service.bamboo_url = "http://example.com"
      service.bamboo_url = "http://example.com"
      expect(service.bamboo_url_touched?).to be_truthy
    end

    it "returns true when the property has been re-assigned the same value" do
      service.bamboo_url = 'http://gitlab.com'
      expect(service.bamboo_url_touched?).to be_truthy
    end

    it "returns false when the property has been assigned a new value then saved" do
      service.bamboo_url = 'http://example.com'
      service.save
      expect(service.bamboo_url_changed?).to be_falsy
    end
  end

  describe "{property}_was" do
    let(:service) do
      BambooService.create(
202
        project: create(:project),
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 229 230 231 232 233 234 235
        properties: {
          bamboo_url: 'http://gitlab.com',
          username: 'mic',
          password: "password"
        }
      )
    end

    it "returns nil when the property has not been assigned a new value" do
      service.username = "key_changed"
      expect(service.bamboo_url_was).to be_nil
    end

    it "returns the previous value when the property has been assigned a different value" do
      service.bamboo_url = "http://example.com"
      expect(service.bamboo_url_was).to eq('http://gitlab.com')
    end

    it "returns initial value when the property has been re-assigned the same value" do
      service.bamboo_url = 'http://gitlab.com'
      expect(service.bamboo_url_was).to eq('http://gitlab.com')
    end

    it "returns initial value when the property has been assigned multiple values" do
      service.bamboo_url = "http://example.com"
      service.bamboo_url = "http://example2.com"
      expect(service.bamboo_url_was).to eq('http://gitlab.com')
    end

    it "returns nil when the property has been assigned a new value then saved" do
      service.bamboo_url = 'http://example.com'
      service.save
      expect(service.bamboo_url_was).to be_nil
236 237
    end
  end
238

239 240 241
  describe 'initialize service with no properties' do
    let(:service) do
      GitlabIssueTrackerService.create(
242
        project: create(:project),
243 244 245 246 247 248 249 250 251 252 253 254 255
        title: 'random title'
      )
    end

    it 'does not raise error' do
      expect { service }.not_to raise_error
    end

    it 'creates the properties' do
      expect(service.properties).to eq({ "title" => "random title" })
    end
  end

256
  describe "callbacks" do
257
    let(:project) { create(:project) }
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
    let!(:service) do
      RedmineService.new(
        project: project,
        active: true,
        properties: {
          project_url: 'http://redmine/projects/project_name_in_redmine',
          issues_url: "http://redmine/#{project.id}/project_name_in_redmine/:id",
          new_issue_url: 'http://redmine/projects/project_name_in_redmine/issues/new'
        }
      )
    end

    describe "on create" do
      it "updates the has_external_issue_tracker boolean" do
        expect do
          service.save!
274
        end.to change { service.project.has_external_issue_tracker }.from(false).to(true)
275 276 277 278 279 280 281 282
      end
    end

    describe "on update" do
      it "updates the has_external_issue_tracker boolean" do
        service.save!

        expect do
Lin Jen-Shin's avatar
Lin Jen-Shin committed
283
          service.update(active: false)
284 285 286 287
        end.to change { service.project.has_external_issue_tracker }.from(true).to(false)
      end
    end
  end
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305

  describe "#deprecated?" do
    let(:project) { create(:project, :repository) }

    it 'should return false by default' do
      service = create(:service, project: project)
      expect(service.deprecated?).to be_falsy
    end
  end

  describe "#deprecation_message" do
    let(:project) { create(:project, :repository) }

    it 'should be empty by default' do
      service = create(:service, project: project)
      expect(service.deprecation_message).to be_nil
    end
  end
306 307 308 309 310 311

  describe '.find_by_template' do
    let!(:kubernetes_service) { create(:kubernetes_service, template: true) }

    it 'returns service template' do
      expect(KubernetesService.find_by_template).to eq(kubernetes_service)
312 313 314
    end
  end

Stan Hu's avatar
Stan Hu committed
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
  describe '#api_field_names' do
    let(:fake_service) do
      Class.new(Service) do
        def fields
          [
            { name: 'token' },
            { name: 'api_token' },
            { name: 'key' },
            { name: 'api_key' },
            { name: 'password' },
            { name: 'password_field' },
            { name: 'safe_field' }
          ]
        end
      end
    end

    let(:service) do
      fake_service.new(properties: [
        { token: 'token-value' },
        { api_token: 'api_token-value' },
        { key: 'key-value' },
        { api_key: 'api_key-value' },
        { password: 'password-value' },
        { password_field: 'password_field-value' },
        { safe_field: 'safe_field-value' }
      ])
    end

    it 'filters out sensitive fields' do
      expect(service.api_field_names).to eq(['safe_field'])
346 347
    end
  end
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374

  context 'logging' do
    let(:project) { create(:project) }
    let(:service) { create(:service, project: project) }
    let(:test_message) { "test message" }
    let(:arguments) do
      {
        service_class: service.class.name,
        project_path: project.full_path,
        project_id: project.id,
        message: test_message,
        additional_argument: 'some argument'
      }
    end

    it 'logs info messages using json logger' do
      expect(Gitlab::JsonLogger).to receive(:info).with(arguments)

      service.log_info(test_message, additional_argument: 'some argument')
    end

    it 'logs error messages using json logger' do
      expect(Gitlab::JsonLogger).to receive(:error).with(arguments)

      service.log_error(test_message, additional_argument: 'some argument')
    end
  end
375
end