environment_spec.rb 16.9 KB
Newer Older
1 2 3
require 'spec_helper'

describe Environment, models: true do
4
  set(:project) { create(:empty_project) }
5
  subject(:environment) { create(:environment, project: project) }
6 7 8 9

  it { is_expected.to belong_to(:project) }
  it { is_expected.to have_many(:deployments) }

Kamil Trzcinski's avatar
Kamil Trzcinski committed
10
  it { is_expected.to delegate_method(:stop_action).to(:last_deployment) }
11
  it { is_expected.to delegate_method(:manual_actions).to(:last_deployment) }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
12

13 14
  it { is_expected.to validate_presence_of(:name) }
  it { is_expected.to validate_uniqueness_of(:name).scoped_to(:project_id) }
15
  it { is_expected.to validate_length_of(:name).is_at_most(255) }
16

Nick Thomas's avatar
Nick Thomas committed
17 18
  it { is_expected.to validate_uniqueness_of(:slug).scoped_to(:project_id) }
  it { is_expected.to validate_length_of(:slug).is_at_most(24) }
19

Nick Thomas's avatar
Nick Thomas committed
20 21
  it { is_expected.to validate_length_of(:external_url).is_at_most(255) }
  it { is_expected.to validate_uniqueness_of(:external_url).scoped_to(:project_id) }
Z.J. van de Weg's avatar
Z.J. van de Weg committed
22

23 24
  describe '.order_by_last_deployed_at' do
    let(:project) { create(:project) }
Douwe Maan's avatar
Douwe Maan committed
25 26 27
    let!(:environment1) { create(:environment, project: project) }
    let!(:environment2) { create(:environment, project: project) }
    let!(:environment3) { create(:environment, project: project) }
28
    let!(:deployment1) { create(:deployment, environment: environment1) }
29 30
    let!(:deployment2) { create(:deployment, environment: environment2) }
    let!(:deployment3) { create(:deployment, environment: environment1) }
Douwe Maan's avatar
Douwe Maan committed
31

32 33
    it 'returns the environments in order of having been last deployed' do
      expect(project.environments.order_by_last_deployed_at.to_a).to eq([environment3, environment2, environment1])
Douwe Maan's avatar
Douwe Maan committed
34 35 36
    end
  end

37 38 39 40 41 42 43 44
  describe 'state machine' do
    it 'invalidates the cache after a change' do
      expect(environment).to receive(:expire_etag_cache)

      environment.stop
    end
  end

45 46 47 48 49 50 51 52 53 54 55 56
  describe '#expire_etag_cache' do
    let(:store) { Gitlab::EtagCaching::Store.new }

    it 'changes the cached value' do
      old_value = store.get(environment.etag_cache_key)

      environment.stop

      expect(store.get(environment.etag_cache_key)).not_to eq(old_value)
    end
  end

Z.J. van de Weg's avatar
Z.J. van de Weg committed
57 58 59 60 61
  describe '#nullify_external_url' do
    it 'replaces a blank url with nil' do
      env = build(:environment, external_url: "")

      expect(env.save).to be true
62
      expect(env.external_url).to be_nil
Z.J. van de Weg's avatar
Z.J. van de Weg committed
63 64
    end
  end
Z.J. van de Weg's avatar
Z.J. van de Weg committed
65

66
  describe '#includes_commit?' do
67
    let(:project) { create(:project, :repository) }
68

Z.J. van de Weg's avatar
Z.J. van de Weg committed
69 70
    context 'without a last deployment' do
      it "returns false" do
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
        expect(environment.includes_commit?('HEAD')).to be false
      end
    end

    context 'with a last deployment' do
      let!(:deployment) do
        create(:deployment, environment: environment, sha: project.commit('master').id)
      end

      context 'in the same branch' do
        it 'returns true' do
          expect(environment.includes_commit?(RepoHelpers.sample_commit)).to be true
        end
      end

      context 'not in the same branch' do
        before do
          deployment.update(sha: project.commit('feature').id)
        end

        it 'returns false' do
          expect(environment.includes_commit?(RepoHelpers.sample_commit)).to be false
        end
Z.J. van de Weg's avatar
Z.J. van de Weg committed
94 95 96
      end
    end
  end
97

98
  describe '#update_merge_request_metrics?' do
99 100
    {
      'production' => true,
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
      'production/eu' => true,
      'production/www.gitlab.com' => true,
      'productioneu' => false,
      'Production' => false,
      'Production/eu' => false,
      'test-production' => false
    }.each do |name, expected_value|
      it "returns #{expected_value} for #{name}" do
        env = create(:environment, name: name)

        expect(env.update_merge_request_metrics?).to eq(expected_value)
      end
    end
  end

Z.J. van de Weg's avatar
Z.J. van de Weg committed
116
  describe '#first_deployment_for' do
117
    let(:project)       { create(:project, :repository) }
118 119 120 121 122
    let!(:deployment)   { create(:deployment, environment: environment, ref: commit.parent.id) }
    let!(:deployment1)  { create(:deployment, environment: environment, ref: commit.id) }
    let(:head_commit)   { project.commit }
    let(:commit)        { project.commit.parent }

123 124 125
    it 'returns deployment id for the environment' do
      expect(environment.first_deployment_for(commit)).to eq deployment1
    end
126

127 128
    it 'return nil when no deployment is found' do
      expect(environment.first_deployment_for(head_commit)).to eq nil
129 130
    end

131 132 133
    it 'returns a UTF-8 ref' do
      expect(environment.first_deployment_for(commit).ref).to be_utf8
    end
134 135
  end

136 137 138 139
  describe '#environment_type' do
    subject { environment.environment_type }

    it 'sets a environment type if name has multiple segments' do
140
      environment.update!(name: 'production/worker.gitlab.com')
141 142 143 144 145

      is_expected.to eq('production')
    end

    it 'nullifies a type if it\'s a simple name' do
146
      environment.update!(name: 'production')
147 148 149 150

      is_expected.to be_nil
    end
  end
Kamil Trzcinski's avatar
Kamil Trzcinski committed
151

Kamil Trzcinski's avatar
Kamil Trzcinski committed
152 153
  describe '#stop_action?' do
    subject { environment.stop_action? }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
154 155 156 157 158 159 160 161

    context 'when no other actions' do
      it { is_expected.to be_falsey }
    end

    context 'when matching action is defined' do
      let(:build) { create(:ci_build) }
      let!(:deployment) { create(:deployment, environment: environment, deployable: build, on_stop: 'close_app') }
162
      let!(:close_action) { create(:ci_build, :manual, pipeline: build.pipeline, name: 'close_app') }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180

      context 'when environment is available' do
        before do
          environment.start
        end

        it { is_expected.to be_truthy }
      end

      context 'when environment is stopped' do
        before do
          environment.stop
        end

        it { is_expected.to be_falsey }
      end
    end
  end
181

Kamil Trzcinski's avatar
Kamil Trzcinski committed
182
  describe '#stop_with_action!' do
183
    let(:user) { create(:admin) }
184

Kamil Trzcinski's avatar
Kamil Trzcinski committed
185
    subject { environment.stop_with_action!(user) }
186 187

    before do
188
      expect(environment).to receive(:available?).and_call_original
189 190 191
    end

    context 'when no other actions' do
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
      context 'environment is available' do
        before do
          environment.update(state: :available)
        end

        it do
          subject

          expect(environment).to be_stopped
        end
      end

      context 'environment is already stopped' do
        before do
          environment.update(state: :stopped)
        end

        it do
          subject

          expect(environment).to be_stopped
        end
      end
215 216 217
    end

    context 'when matching action is defined' do
218 219 220 221 222 223 224 225
      let(:pipeline) { create(:ci_pipeline, project: project) }
      let(:build) { create(:ci_build, pipeline: pipeline) }

      let!(:deployment) do
        create(:deployment, environment: environment,
                            deployable: build,
                            on_stop: 'close_app')
      end
226

227 228 229 230
      context 'when user is not allowed to stop environment' do
        let!(:close_action) do
          create(:ci_build, :manual, pipeline: pipeline, name: 'close_app')
        end
231

232 233
        it 'raises an exception' do
          expect { subject }.to raise_error(Gitlab::Access::AccessDeniedError)
234 235 236
        end
      end

237 238
      context 'when user is allowed to stop environment' do
        before do
239 240 241 242
          project.add_developer(user)

          create(:protected_branch, :developers_can_merge,
                 name: 'master', project: project)
243 244 245 246 247 248 249 250 251 252 253 254
        end

        context 'when action did not yet finish' do
          let!(:close_action) do
            create(:ci_build, :manual, pipeline: pipeline, name: 'close_app')
          end

          it 'returns the same action' do
            expect(subject).to eq(close_action)
            expect(subject.user).to eq(user)
          end
        end
255

256 257 258 259 260 261 262 263 264 265 266
        context 'if action did finish' do
          let!(:close_action) do
            create(:ci_build, :manual, :success,
                   pipeline: pipeline, name: 'close_app')
          end

          it 'returns a new action of the same type' do
            expect(subject).to be_persisted
            expect(subject.name).to eq(close_action.name)
            expect(subject.user).to eq(user)
          end
267 268 269 270
        end
      end
    end
  end
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291

  describe 'recently_updated_on_branch?' do
    subject { environment.recently_updated_on_branch?('feature') }

    context 'when last deployment to environment is the most recent one' do
      before do
        create(:deployment, environment: environment, ref: 'feature')
      end

      it { is_expected.to be true }
    end

    context 'when last deployment to environment is not the most recent' do
      before do
        create(:deployment, environment: environment, ref: 'feature')
        create(:deployment, environment: environment, ref: 'master')
      end

      it { is_expected.to be false }
    end
  end
292 293 294 295

  describe '#actions_for' do
    let(:deployment) { create(:deployment, environment: environment) }
    let(:pipeline) { deployment.deployable.pipeline }
296
    let!(:review_action) { create(:ci_build, :manual, name: 'review-apps', pipeline: pipeline, environment: 'review/$CI_COMMIT_REF_NAME' )}
297 298 299 300 301 302
    let!(:production_action) { create(:ci_build, :manual, name: 'production', pipeline: pipeline, environment: 'production' )}

    it 'returns a list of actions with matching environment' do
      expect(environment.actions_for('review/master')).to contain_exactly(review_action)
    end
  end
Nick Thomas's avatar
Nick Thomas committed
303

304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
  describe '#has_terminals?' do
    subject { environment.has_terminals? }

    context 'when the enviroment is available' do
      context 'with a deployment service' do
        let(:project) { create(:kubernetes_project) }

        context 'and a deployment' do
          let!(:deployment) { create(:deployment, environment: environment) }
          it { is_expected.to be_truthy }
        end

        context 'but no deployments' do
          it { is_expected.to be_falsy }
        end
      end

      context 'without a deployment service' do
        it { is_expected.to be_falsy }
      end
    end

    context 'when the environment is unavailable' do
      let(:project) { create(:kubernetes_project) }
328 329 330 331 332

      before do
        environment.stop
      end

333 334 335 336 337 338 339 340 341
      it { is_expected.to be_falsy }
    end
  end

  describe '#terminals' do
    let(:project) { create(:kubernetes_project) }
    subject { environment.terminals }

    context 'when the environment has terminals' do
342 343 344
      before do
        allow(environment).to receive(:has_terminals?).and_return(true)
      end
345 346

      it 'returns the terminals from the deployment service' do
347 348 349
        expect(project.deployment_service)
          .to receive(:terminals).with(environment)
          .and_return(:fake_terminals)
350 351 352 353 354 355

        is_expected.to eq(:fake_terminals)
      end
    end

    context 'when the environment does not have terminals' do
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
      before do
        allow(environment).to receive(:has_terminals?).and_return(false)
      end

      it { is_expected.to be_nil }
    end
  end

  describe '#has_metrics?' do
    subject { environment.has_metrics? }

    context 'when the enviroment is available' do
      context 'with a deployment service' do
        let(:project) { create(:prometheus_project) }

        context 'and a deployment' do
          let!(:deployment) { create(:deployment, environment: environment) }
          it { is_expected.to be_truthy }
        end

        context 'but no deployments' do
          it { is_expected.to be_falsy }
        end
      end

      context 'without a monitoring service' do
        it { is_expected.to be_falsy }
      end
    end

    context 'when the environment is unavailable' do
      let(:project) { create(:prometheus_project) }

      before do
        environment.stop
      end

      it { is_expected.to be_falsy }
    end
  end

  describe '#metrics' do
    let(:project) { create(:prometheus_project) }
    subject { environment.metrics }

    context 'when the environment has metrics' do
      before do
        allow(environment).to receive(:has_metrics?).and_return(true)
      end

      it 'returns the metrics from the deployment service' do
        expect(project.monitoring_service)
408
          .to receive(:environment_metrics).with(environment)
409 410 411 412 413 414 415 416 417 418 419 420
          .and_return(:fake_metrics)

        is_expected.to eq(:fake_metrics)
      end
    end

    context 'when the environment does not have metrics' do
      before do
        allow(environment).to receive(:has_metrics?).and_return(false)
      end

      it { is_expected.to be_nil }
421 422 423
    end
  end

424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
  describe '#has_metrics?' do
    subject { environment.has_metrics? }

    context 'when the enviroment is available' do
      context 'with a deployment service' do
        let(:project) { create(:prometheus_project) }

        context 'and a deployment' do
          let!(:deployment) { create(:deployment, environment: environment) }
          it { is_expected.to be_truthy }
        end

        context 'but no deployments' do
          it { is_expected.to be_falsy }
        end
      end

      context 'without a monitoring service' do
        it { is_expected.to be_falsy }
      end
    end

    context 'when the environment is unavailable' do
      let(:project) { create(:prometheus_project) }

      before do
        environment.stop
      end

      it { is_expected.to be_falsy }
    end
  end

  describe '#additional_metrics' do
    let(:project) { create(:prometheus_project) }
    subject { environment.additional_metrics }

    context 'when the environment has additional metrics' do
      before do
        allow(environment).to receive(:has_additional_metrics?).and_return(true)
      end

      it 'returns the additional metrics from the deployment service' do
467
        expect(project.prometheus_service).to receive(:additional_environment_metrics)
468
                                                .with(environment)
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
                                                .and_return(:fake_metrics)

        is_expected.to eq(:fake_metrics)
      end
    end

    context 'when the environment does not have metrics' do
      before do
        allow(environment).to receive(:has_additional_metrics?).and_return(false)
      end

      it { is_expected.to be_nil }
    end
  end

  describe '#has_additional_metrics??' do
485 486
    subject { environment.has_additional_metrics? }

487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
    context 'when the enviroment is available' do
      context 'with a deployment service' do
        let(:project) { create(:prometheus_project) }

        context 'and a deployment' do
          let!(:deployment) { create(:deployment, environment: environment) }
          it { is_expected.to be_truthy }
        end

        context 'but no deployments' do
          it { is_expected.to be_falsy }
        end
      end

      context 'without a monitoring service' do
        it { is_expected.to be_falsy }
      end
    end

    context 'when the environment is unavailable' do
      let(:project) { create(:prometheus_project) }

      before do
        environment.stop
      end

      it { is_expected.to be_falsy }
    end
  end

Nick Thomas's avatar
Nick Thomas committed
517 518 519 520 521 522 523 524 525 526 527 528 529 530
  describe '#slug' do
    it "is automatically generated" do
      expect(environment.slug).not_to be_nil
    end

    it "is not regenerated if name changes" do
      original_slug = environment.slug
      environment.update_attributes!(name: environment.name.reverse)

      expect(environment.slug).to eq(original_slug)
    end
  end

  describe '#generate_slug' do
Douwe Maan's avatar
Douwe Maan committed
531
    SUFFIX = "-[a-z0-9]{6}".freeze
Nick Thomas's avatar
Nick Thomas committed
532 533 534 535 536 537 538 539 540 541
    {
      "staging-12345678901234567" => "staging-123456789" + SUFFIX,
      "9-staging-123456789012345" => "env-9-staging-123" + SUFFIX,
      "staging-1234567890123456"  => "staging-1234567890123456",
      "production"                => "production",
      "PRODUCTION"                => "production" + SUFFIX,
      "review/1-foo"              => "review-1-foo" + SUFFIX,
      "1-foo"                     => "env-1-foo" + SUFFIX,
      "1/foo"                     => "env-1-foo" + SUFFIX,
      "foo-"                      => "foo" + SUFFIX,
542 543 544 545
      "foo--bar"                  => "foo-bar" + SUFFIX,
      "foo**bar"                  => "foo-bar" + SUFFIX,
      "*-foo"                     => "env-foo" + SUFFIX,
      "staging-12345678-"         => "staging-12345678" + SUFFIX,
546
      "staging-12345678-01234567" => "staging-12345678" + SUFFIX
Nick Thomas's avatar
Nick Thomas committed
547 548
    }.each do |name, matcher|
      it "returns a slug matching #{matcher}, given #{name}" do
549
        slug = described_class.new(name: name).generate_slug
Nick Thomas's avatar
Nick Thomas committed
550 551 552 553 554

        expect(slug).to match(/\A#{matcher}\z/)
      end
    end
  end
Douwe Maan's avatar
Douwe Maan committed
555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583

  describe '#external_url_for' do
    let(:source_path) { 'source/file.html' }
    let(:sha) { RepoHelpers.sample_commit.id }

    before do
      environment.external_url = 'http://example.com'
    end

    context 'when the public path is not known' do
      before do
        allow(project).to receive(:public_path_for_source_path).with(source_path, sha).and_return(nil)
      end

      it 'returns nil' do
        expect(environment.external_url_for(source_path, sha)).to be_nil
      end
    end

    context 'when the public path is known' do
      before do
        allow(project).to receive(:public_path_for_source_path).with(source_path, sha).and_return('file.html')
      end

      it 'returns the full external URL' do
        expect(environment.external_url_for(source_path, sha)).to eq('http://example.com/file.html')
      end
    end
  end
584
end