environment_spec.rb 21.3 KB
Newer Older
1 2
require 'spec_helper'

3
describe Environment do
4
  let(:project) { create(:project, :stubbed_repository) }
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
  it { is_expected.to validate_length_of(:external_url).is_at_most(255) }
Z.J. van de Weg's avatar
Z.J. van de Weg committed
21

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

31 32
    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
33 34 35
    end
  end

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

      environment.stop
    end
  end

44 45 46 47 48 49 50 51 52 53 54 55
  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

56 57 58 59 60 61
  describe '.with_deployment' do
    subject { described_class.with_deployment(sha) }

    let(:environment) { create(:environment) }
    let(:sha) { RepoHelpers.sample_commit.id }

62 63
    context 'when deployment has the specified sha' do
      let!(:deployment) { create(:deployment, environment: environment, sha: sha) }
64

65
      it { is_expected.to eq([environment]) }
66 67
    end

68 69
    context 'when deployment does not have the specified sha' do
      let!(:deployment) { create(:deployment, environment: environment, sha: 'abc') }
70 71 72 73 74

      it { is_expected.to be_empty }
    end
  end

75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
  describe '#folder_name' do
    context 'when it is inside a folder' do
      subject(:environment) do
        create(:environment, name: 'staging/review-1')
      end

      it 'returns a top-level folder name' do
        expect(environment.folder_name).to eq 'staging'
      end
    end

    context 'when the environment if a top-level item itself' do
      subject(:environment) do
        create(:environment, name: 'production')
      end

      it 'returns an environment name' do
        expect(environment.folder_name).to eq 'production'
      end
    end
  end

Z.J. van de Weg's avatar
Z.J. van de Weg committed
97 98 99 100 101
  describe '#nullify_external_url' do
    it 'replaces a blank url with nil' do
      env = build(:environment, external_url: "")

      expect(env.save).to be true
102
      expect(env.external_url).to be_nil
Z.J. van de Weg's avatar
Z.J. van de Weg committed
103 104
    end
  end
Z.J. van de Weg's avatar
Z.J. van de Weg committed
105

106
  describe '#includes_commit?' do
107
    let(:project) { create(:project, :repository) }
108

Z.J. van de Weg's avatar
Z.J. van de Weg committed
109 110
    context 'without a last deployment' do
      it "returns false" do
111 112 113 114 115 116
        expect(environment.includes_commit?('HEAD')).to be false
      end
    end

    context 'with a last deployment' do
      let!(:deployment) do
117
        create(:deployment, :success, environment: environment, sha: project.commit('master').id)
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
      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
134 135 136
      end
    end
  end
137

138
  describe '#update_merge_request_metrics?' do
139 140
    {
      'production' => true,
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
      '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

Shinya Maeda's avatar
Shinya Maeda committed
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
  describe '#first_deployment_for' do
    let(:project)       { create(:project, :repository) }
    let!(:deployment)   { create(:deployment, :succeed, environment: environment, ref: commit.parent.id) }
    let!(:deployment1)  { create(:deployment, :succeed, environment: environment, ref: commit.id) }
    let(:head_commit)   { project.commit }
    let(:commit)        { project.commit.parent }

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

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

    it 'returns a UTF-8 ref' do
      expect(environment.first_deployment_for(commit.id).ref).to be_utf8
    end
  end

176 177 178 179
  describe '#environment_type' do
    subject { environment.environment_type }

    it 'sets a environment type if name has multiple segments' do
180
      environment.update!(name: 'production/worker.gitlab.com')
181 182 183 184 185

      is_expected.to eq('production')
    end

    it 'nullifies a type if it\'s a simple name' do
186
      environment.update!(name: 'production')
187 188 189 190

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

192 193
  describe '#stop_action_available?' do
    subject { environment.stop_action_available? }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
194 195 196 197 198 199 200

    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) }
201 202

      let!(:deployment) do
203 204
        create(:deployment, :success,
                            environment: environment,
205 206 207 208 209 210 211 212
                            deployable: build,
                            on_stop: 'close_app')
      end

      let!(:close_action) do
        create(:ci_build, :manual, pipeline: build.pipeline,
                                   name: 'close_app')
      end
Kamil Trzcinski's avatar
Kamil Trzcinski committed
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230

      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
231

Kamil Trzcinski's avatar
Kamil Trzcinski committed
232
  describe '#stop_with_action!' do
233
    let(:user) { create(:user) }
234

Kamil Trzcinski's avatar
Kamil Trzcinski committed
235
    subject { environment.stop_with_action!(user) }
236 237

    before do
238
      expect(environment).to receive(:available?).and_call_original
239 240 241
    end

    context 'when no other actions' do
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
      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
265 266 267
    end

    context 'when matching action is defined' do
268 269 270 271
      let(:pipeline) { create(:ci_pipeline, project: project) }
      let(:build) { create(:ci_build, pipeline: pipeline) }

      let!(:deployment) do
272 273
        create(:deployment, :success,
                            environment: environment,
274 275 276
                            deployable: build,
                            on_stop: 'close_app')
      end
277

278 279 280 281
      context 'when user is not allowed to stop environment' do
        let!(:close_action) do
          create(:ci_build, :manual, pipeline: pipeline, name: 'close_app')
        end
282

283 284
        it 'raises an exception' do
          expect { subject }.to raise_error(Gitlab::Access::AccessDeniedError)
285 286 287
        end
      end

288 289
      context 'when user is allowed to stop environment' do
        before do
290 291 292 293
          project.add_developer(user)

          create(:protected_branch, :developers_can_merge,
                 name: 'master', project: project)
294 295 296 297 298 299 300 301 302 303 304 305
        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
306

307 308 309 310 311 312 313 314 315 316 317
        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
318 319 320 321
        end
      end
    end
  end
322 323 324 325 326 327

  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
328
        create(:deployment, :success, environment: environment, ref: 'feature')
329 330 331 332 333 334 335
      end

      it { is_expected.to be true }
    end

    context 'when last deployment to environment is not the most recent' do
      before do
336 337
        create(:deployment, :success, environment: environment, ref: 'feature')
        create(:deployment, :success, environment: environment, ref: 'master')
338 339 340 341 342
      end

      it { is_expected.to be false }
    end
  end
343 344

  describe '#actions_for' do
345
    let(:deployment) { create(:deployment, :success, environment: environment) }
346
    let(:pipeline) { deployment.deployable.pipeline }
347
    let!(:review_action) { create(:ci_build, :manual, name: 'review-apps', pipeline: pipeline, environment: 'review/$CI_COMMIT_REF_NAME' )}
348 349 350 351 352 353
    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
354

355 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 408 409 410 411 412 413 414 415 416 417 418
  describe '.deployments' do
    subject { environment.deployments }

    context 'when there is a deployment record with created status' do
      let(:deployment) { create(:deployment, :created, environment: environment) }

      it 'does not return the record' do
        is_expected.to be_empty
      end
    end

    context 'when there is a deployment record with running status' do
      let(:deployment) { create(:deployment, :running, environment: environment) }

      it 'does not return the record' do
        is_expected.to be_empty
      end
    end

    context 'when there is a deployment record with success status' do
      let(:deployment) { create(:deployment, :success, environment: environment) }

      it 'returns the record' do
        is_expected.to eq([deployment])
      end
    end
  end

  describe '.last_deployment' do
    subject { environment.last_deployment }

    before do
      allow_any_instance_of(Deployment).to receive(:create_ref)
    end

    context 'when there is an old deployment record' do
      let!(:previous_deployment) { create(:deployment, :success, environment: environment) }

      context 'when there is a deployment record with created status' do
        let!(:deployment) { create(:deployment, environment: environment) }

        it 'returns the previous deployment' do
          is_expected.to eq(previous_deployment)
        end
      end

      context 'when there is a deployment record with running status' do
        let!(:deployment) { create(:deployment, :running, environment: environment) }

        it 'returns the previous deployment' do
          is_expected.to eq(previous_deployment)
        end
      end

      context 'when there is a deployment record with success status' do
        let!(:deployment) { create(:deployment, :success, environment: environment) }

        it 'returns the latest successful deployment' do
          is_expected.to eq(deployment)
        end
      end
    end
  end

419 420 421
  describe '#has_terminals?' do
    subject { environment.has_terminals? }

422
    context 'when the environment is available' do
423
      context 'with a deployment service' do
424
        shared_examples 'same behavior between KubernetesService and Platform::Kubernetes' do
425
          context 'and a deployment' do
426
            let!(:deployment) { create(:deployment, :success, environment: environment) }
427 428 429 430 431 432 433 434 435 436
            it { is_expected.to be_truthy }
          end

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

        context 'when user configured kubernetes from Integration > Kubernetes' do
          let(:project) { create(:kubernetes_project) }
437

438
          it_behaves_like 'same behavior between KubernetesService and Platform::Kubernetes'
439 440
        end

441 442 443 444
        context 'when user configured kubernetes from CI/CD > Clusters' do
          let!(:cluster) { create(:cluster, :project, :provided_by_gcp) }
          let(:project) { cluster.project }

445
          it_behaves_like 'same behavior between KubernetesService and Platform::Kubernetes'
446 447 448 449 450 451 452 453 454 455
        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) }
456 457 458 459 460

      before do
        environment.stop
      end

461 462 463 464
      it { is_expected.to be_falsy }
    end
  end

465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
  describe '#deployment_platform' do
    context 'when there is a deployment platform for environment' do
      let!(:cluster) do
        create(:cluster, :provided_by_gcp,
               environment_scope: '*', projects: [project])
      end

      it 'finds a deployment platform' do
        expect(environment.deployment_platform).to eq cluster.platform
      end
    end

    context 'when there is no deployment platform for environment' do
      it 'returns nil' do
        expect(environment.deployment_platform).to be_nil
      end
    end

    it 'checks deployment platforms associated with a project' do
      expect(project).to receive(:deployment_platform)
        .with(environment: environment.name)

      environment.deployment_platform
    end
  end

491 492 493 494
  describe '#terminals' do
    subject { environment.terminals }

    context 'when the environment has terminals' do
495 496 497
      before do
        allow(environment).to receive(:has_terminals?).and_return(true)
      end
498

499
      shared_examples 'same behavior between KubernetesService and Platform::Kubernetes' do
500 501 502 503
        it 'returns the terminals from the deployment service' do
          expect(project.deployment_platform)
            .to receive(:terminals).with(environment)
            .and_return(:fake_terminals)
504

505 506 507 508 509 510 511
          is_expected.to eq(:fake_terminals)
        end
      end

      context 'when user configured kubernetes from Integration > Kubernetes' do
        let(:project) { create(:kubernetes_project) }

512
        it_behaves_like 'same behavior between KubernetesService and Platform::Kubernetes'
513 514 515 516 517 518
      end

      context 'when user configured kubernetes from CI/CD > Clusters' do
        let!(:cluster) { create(:cluster, :project, :provided_by_gcp) }
        let(:project) { cluster.project }

519
        it_behaves_like 'same behavior between KubernetesService and Platform::Kubernetes'
520 521 522 523
      end
    end

    context 'when the environment does not have terminals' do
524 525 526 527 528 529 530 531 532 533 534
      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? }

535
    context 'when the environment is available' do
536 537 538 539 540 541 542 543
      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

544 545
        context 'and no deployments' do
          it { is_expected.to be_truthy }
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
        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
575 576
        expect(environment.prometheus_adapter)
          .to receive(:query).with(:environment, environment)
577 578 579 580 581 582 583 584 585 586 587 588
          .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 }
589 590 591
    end
  end

592 593 594 595 596 597
  describe '#additional_metrics' do
    let(:project) { create(:prometheus_project) }
    subject { environment.additional_metrics }

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

      it 'returns the additional metrics from the deployment service' do
602 603
        expect(environment.prometheus_adapter).to receive(:query)
                                                .with(:additional_metrics_environment, environment)
604 605 606 607 608 609 610 611
                                                .and_return(:fake_metrics)

        is_expected.to eq(:fake_metrics)
      end
    end

    context 'when the environment does not have metrics' do
      before do
612
        allow(environment).to receive(:has_metrics?).and_return(false)
613 614 615 616 617 618
      end

      it { is_expected.to be_nil }
    end
  end

Nick Thomas's avatar
Nick Thomas committed
619 620 621 622 623 624 625
  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
Lin Jen-Shin's avatar
Lin Jen-Shin committed
626
      environment.update!(name: environment.name.reverse)
Nick Thomas's avatar
Nick Thomas committed
627 628 629

      expect(environment.slug).to eq(original_slug)
    end
630 631 632 633 634 635 636 637 638

    it "regenerates the slug if nil" do
      environment = build(:environment, slug: nil)

      new_slug = environment.slug

      expect(new_slug).not_to be_nil
      expect(environment.slug).to eq(new_slug)
    end
Nick Thomas's avatar
Nick Thomas committed
639 640 641
  end

  describe '#generate_slug' do
Douwe Maan's avatar
Douwe Maan committed
642
    SUFFIX = "-[a-z0-9]{6}".freeze
Nick Thomas's avatar
Nick Thomas committed
643 644 645 646 647 648 649 650 651 652
    {
      "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,
653 654 655 656
      "foo--bar"                  => "foo-bar" + SUFFIX,
      "foo**bar"                  => "foo-bar" + SUFFIX,
      "*-foo"                     => "env-foo" + SUFFIX,
      "staging-12345678-"         => "staging-12345678" + SUFFIX,
657
      "staging-12345678-01234567" => "staging-12345678" + SUFFIX
Nick Thomas's avatar
Nick Thomas committed
658 659
    }.each do |name, matcher|
      it "returns a slug matching #{matcher}, given #{name}" do
660
        slug = described_class.new(name: name).generate_slug
Nick Thomas's avatar
Nick Thomas committed
661 662 663 664 665

        expect(slug).to match(/\A#{matcher}\z/)
      end
    end
  end
Douwe Maan's avatar
Douwe Maan committed
666

667 668 669 670 671 672 673 674
  describe '#ref_path' do
    subject(:environment) do
      create(:environment, name: 'staging / review-1')
    end

    it 'returns a path that uses the slug and does not have spaces' do
      expect(environment.ref_path).to start_with('refs/environments/staging-review-1-')
    end
675 676 677 678 679 680

    it "doesn't change when the slug is nil initially" do
      environment.slug = nil

      expect(environment.ref_path).to eq(environment.ref_path)
    end
681 682
  end

Douwe Maan's avatar
Douwe Maan committed
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
  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
711 712

  describe '#prometheus_adapter' do
713 714
    it 'calls prometheus adapter service' do
      expect_any_instance_of(Prometheus::AdapterService).to receive(:prometheus_adapter)
715

716
      subject.prometheus_adapter
717 718
    end
  end
719
end