build_spec.rb 72.3 KB
Newer Older
1 2
require 'spec_helper'

3
describe Ci::Build do
4
  set(:user) { create(:user) }
5 6
  set(:group) { create(:group, :access_requestable) }
  set(:project) { create(:project, :repository, group: group) }
7

8
  set(:pipeline) do
9 10 11 12 13 14
    create(:ci_pipeline, project: project,
                         sha: project.commit.id,
                         ref: project.default_branch,
                         status: 'success')
  end

15 16
  let(:build) { create(:ci_build, pipeline: pipeline) }

17 18 19
  it { is_expected.to belong_to(:runner) }
  it { is_expected.to belong_to(:trigger_request) }
  it { is_expected.to belong_to(:erased_by) }
20
  it { is_expected.to have_many(:deployments) }
21
  it { is_expected.to have_many(:sourced_pipelines) }
22
  it { is_expected.to have_many(:trace_sections)}
23 24 25
  it { is_expected.to validate_presence_of(:ref) }
  it { is_expected.to respond_to(:has_trace?) }
  it { is_expected.to respond_to(:trace) }
26

27 28
  it { is_expected.to be_a(ArtifactMigratable) }

29 30 31 32 33 34 35
  describe 'associations' do
    it 'has a bidirectional relationship with projects' do
      expect(described_class.reflect_on_association(:project).has_inverse?).to eq(:builds)
      expect(Project.reflect_on_association(:builds).has_inverse?).to eq(:project)
    end
  end

36 37 38 39 40 41 42 43 44 45
  describe 'callbacks' do
    context 'when running after_create callback' do
      it 'triggers asynchronous build hooks worker' do
        expect(BuildHooksWorker).to receive(:perform_async)

        create(:ci_build)
      end
    end
  end

46 47 48 49 50 51 52 53 54 55 56 57
  describe '.manual_actions' do
    let!(:manual_but_created) { create(:ci_build, :manual, status: :created, pipeline: pipeline) }
    let!(:manual_but_succeeded) { create(:ci_build, :manual, status: :success, pipeline: pipeline) }
    let!(:manual_action) { create(:ci_build, :manual, pipeline: pipeline) }

    subject { described_class.manual_actions }

    it { is_expected.to include(manual_action) }
    it { is_expected.to include(manual_but_succeeded) }
    it { is_expected.not_to include(manual_but_created) }
  end

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
  describe '.ref_protected' do
    subject { described_class.ref_protected }

    context 'when protected is true' do
      let!(:job) { create(:ci_build, :protected) }

      it { is_expected.to include(job) }
    end

    context 'when protected is false' do
      let!(:job) { create(:ci_build) }

      it { is_expected.not_to include(job) }
    end

    context 'when protected is nil' do
      let!(:job) { create(:ci_build) }

      before do
        job.update_attribute(:protected, nil)
      end

      it { is_expected.not_to include(job) }
    end
  end

84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
  describe '.with_artifacts_archive' do
    subject { described_class.with_artifacts_archive }

    context 'when job does not have an archive' do
      let!(:job) { create(:ci_build) }

      it 'does not return the job' do
        is_expected.not_to include(job)
      end
    end

    context 'when job has a legacy archive' do
      let!(:job) { create(:ci_build, :legacy_artifacts) }

      it 'returns the job' do
        is_expected.to include(job)
      end
    end

    context 'when job has a job artifact archive' do
      let!(:job) { create(:ci_build, :artifacts) }

      it 'returns the job' do
        is_expected.to include(job)
      end
    end

    context 'when job has a job artifact trace' do
      let!(:job) { create(:ci_build, :trace_artifact) }

      it 'does not return the job' do
        is_expected.not_to include(job)
      end
    end
  end

120 121 122 123 124 125 126 127 128 129 130 131 132 133
  describe '.with_live_trace' do
    subject { described_class.with_live_trace }

    context 'when build has live trace' do
      let!(:build) { create(:ci_build, :success, :trace_live) }

      it 'selects the build' do
        is_expected.to eq([build])
      end
    end

    context 'when build does not have live trace' do
      let!(:build) { create(:ci_build, :success, :trace_artifact) }

134
      it 'does not select the build' do
135 136 137 138 139
        is_expected.to be_empty
      end
    end
  end

140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
  describe '#actionize' do
    context 'when build is a created' do
      before do
        build.update_column(:status, :created)
      end

      it 'makes build a manual action' do
        expect(build.actionize).to be true
        expect(build.reload).to be_manual
      end
    end

    context 'when build is not created' do
      before do
        build.update_column(:status, :pending)
      end

      it 'does not change build status' do
        expect(build.actionize).to be false
        expect(build.reload).to be_pending
      end
    end
  end

164 165 166 167 168 169 170 171
  describe '#any_runners_online?' do
    subject { build.any_runners_online? }

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

    context 'when there are runners' do
172
      let(:runner) { create(:ci_runner, :project, projects: [build.project]) }
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

      before do
        runner.update_attributes(contacted_at: 1.second.ago)
      end

      it { is_expected.to be_truthy }

      it 'that is inactive' do
        runner.update_attributes(active: false)
        is_expected.to be_falsey
      end

      it 'that is not online' do
        runner.update_attributes(contacted_at: nil)
        is_expected.to be_falsey
      end

      it 'that cannot handle build' do
        expect_any_instance_of(Ci::Runner).to receive(:can_pick?).and_return(false)
        is_expected.to be_falsey
      end
    end
  end

  describe '#artifacts?' do
198
    subject { build.artifacts? }
199

200
    context 'when new artifacts are used' do
201 202
      context 'artifacts archive does not exist' do
        let(:build) { create(:ci_build) }
203

204 205 206 207
        it { is_expected.to be_falsy }
      end

      context 'artifacts archive exists' do
208 209
        let(:build) { create(:ci_build, :artifacts) }

210 211 212
        it { is_expected.to be_truthy }

        context 'is expired' do
213
          let(:build) { create(:ci_build, :artifacts, :expired) }
214 215 216 217

          it { is_expected.to be_falsy }
        end
      end
218 219
    end

220
    context 'when legacy artifacts are used' do
221 222 223
      let(:build) { create(:ci_build, :legacy_artifacts) }

      subject { build.artifacts? }
224

Micaël Bergeron's avatar
Micaël Bergeron committed
225 226 227 228 229 230
      context 'is expired' do
        let(:build) { create(:ci_build, :legacy_artifacts, :expired) }

        it { is_expected.to be_falsy }
      end

231 232
      context 'artifacts archive does not exist' do
        let(:build) { create(:ci_build) }
233

234 235 236
        it { is_expected.to be_falsy }
      end

237
      context 'artifacts archive exists' do
238 239
        let(:build) { create(:ci_build, :legacy_artifacts) }

240 241 242 243
        it { is_expected.to be_truthy }
      end
    end
  end
244

245 246
  describe '#browsable_artifacts?' do
    subject { build.browsable_artifacts? }
247

248 249
    context 'artifacts metadata does not exist' do
      before do
250
        build.update_attributes(legacy_artifacts_metadata: nil)
251
      end
252 253 254 255 256 257 258 259

      it { is_expected.to be_falsy }
    end

    context 'artifacts metadata does exists' do
      let(:build) { create(:ci_build, :artifacts) }

      it { is_expected.to be_truthy }
260 261 262
    end
  end

Kamil Trzcinski's avatar
Kamil Trzcinski committed
263 264
  describe '#browsable_artifacts?' do
    subject { build.browsable_artifacts? }
265

Kamil Trzcinski's avatar
Kamil Trzcinski committed
266 267
    context 'artifacts metadata does not exist' do
      before do
268
        build.update_attributes(legacy_artifacts_metadata: nil)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
269 270 271 272 273 274 275 276 277 278 279 280
      end

      it { is_expected.to be_falsy }
    end

    context 'artifacts metadata does exists' do
      let(:build) { create(:ci_build, :artifacts) }

      it { is_expected.to be_truthy }
    end
  end

281 282 283 284
  describe '#artifacts_expired?' do
    subject { build.artifacts_expired? }

    context 'is expired' do
285 286 287
      before do
        build.update(artifacts_expire_at: Time.now - 7.days)
      end
288 289 290 291 292

      it { is_expected.to be_truthy }
    end

    context 'is not expired' do
293 294 295
      before do
        build.update(artifacts_expire_at: Time.now + 7.days)
      end
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319

      it { is_expected.to be_falsey }
    end
  end

  describe '#artifacts_metadata?' do
    subject { build.artifacts_metadata? }
    context 'artifacts metadata does not exist' do
      it { is_expected.to be_falsy }
    end

    context 'artifacts archive is a zip file and metadata exists' do
      let(:build) { create(:ci_build, :artifacts) }
      it { is_expected.to be_truthy }
    end
  end

  describe '#artifacts_expire_in' do
    subject { build.artifacts_expire_in }
    it { is_expected.to be_nil }

    context 'when artifacts_expire_at is specified' do
      let(:expire_at) { Time.now + 7.days }

320 321 322
      before do
        build.artifacts_expire_at = expire_at
      end
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341

      it { is_expected.to be_within(5).of(expire_at - Time.now) }
    end
  end

  describe '#artifacts_expire_in=' do
    subject { build.artifacts_expire_in }

    it 'when assigning valid duration' do
      build.artifacts_expire_in = '7 days'

      is_expected.to be_within(10).of(7.days.to_i)
    end

    it 'when assigning invalid duration' do
      expect { build.artifacts_expire_in = '7 elephants' }.to raise_error(ChronicDuration::DurationParseError)
      is_expected.to be_nil
    end

342
    it 'when resetting value' do
343 344
      build.artifacts_expire_in = nil

345 346 347 348 349 350
      is_expected.to be_nil
    end

    it 'when setting to 0' do
      build.artifacts_expire_in = '0'

351 352 353 354 355 356 357 358 359 360
      is_expected.to be_nil
    end
  end

  describe '#commit' do
    it 'returns commit pipeline has been created for' do
      expect(build.commit).to eq project.commit
    end
  end

361 362 363 364 365 366 367 368 369 370
  describe '#cache' do
    let(:options) { { cache: { key: "key", paths: ["public"], policy: "pull-push" } } }

    subject { build.cache }

    context 'when build has cache' do
      before do
        allow(build).to receive(:options).and_return(options)
      end

371
      context 'when project has jobs_cache_index' do
372
        before do
373
          allow_any_instance_of(Project).to receive(:jobs_cache_index).and_return(1)
374 375
        end

376
        it { is_expected.to be_an(Array).and all(include(key: "key-1")) }
377 378
      end

379
      context 'when project does not have jobs_cache_index' do
380
        before do
381
          allow_any_instance_of(Project).to receive(:jobs_cache_index).and_return(nil)
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
        end

        it { is_expected.to eq([options[:cache]]) }
      end
    end

    context 'when build does not have cache' do
      before do
        allow(build).to receive(:options).and_return({})
      end

      it { is_expected.to eq([nil]) }
    end
  end

397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
  describe '#depends_on_builds' do
    let!(:build) { create(:ci_build, pipeline: pipeline, name: 'build', stage_idx: 0, stage: 'build') }
    let!(:rspec_test) { create(:ci_build, pipeline: pipeline, name: 'rspec', stage_idx: 1, stage: 'test') }
    let!(:rubocop_test) { create(:ci_build, pipeline: pipeline, name: 'rubocop', stage_idx: 1, stage: 'test') }
    let!(:staging) { create(:ci_build, pipeline: pipeline, name: 'staging', stage_idx: 2, stage: 'deploy') }

    it 'expects to have no dependents if this is first build' do
      expect(build.depends_on_builds).to be_empty
    end

    it 'expects to have one dependent if this is test' do
      expect(rspec_test.depends_on_builds.map(&:id)).to contain_exactly(build.id)
    end

    it 'expects to have all builds from build and test stage if this is last' do
      expect(staging.depends_on_builds.map(&:id)).to contain_exactly(build.id, rspec_test.id, rubocop_test.id)
    end

    it 'expects to have retried builds instead the original ones' do
416
      project.add_developer(user)
417

418
      retried_rspec = described_class.retry(rspec_test, user)
419 420 421

      expect(staging.depends_on_builds.map(&:id))
        .to contain_exactly(build.id, retried_rspec.id, rubocop_test.id)
422 423 424
    end
  end

425 426
  describe '#triggered_by?' do
    subject { build.triggered_by?(user) }
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441

    context 'when user is owner' do
      let(:build) { create(:ci_build, pipeline: pipeline, user: user) }

      it { is_expected.to be_truthy }
    end

    context 'when user is not owner' do
      let(:another_user) { create(:user) }
      let(:build) { create(:ci_build, pipeline: pipeline, user: another_user) }

      it { is_expected.to be_falsy }
    end
  end

442 443 444 445 446 447 448
  describe '#detailed_status' do
    it 'returns a detailed status' do
      expect(build.detailed_status(user))
        .to be_a Gitlab::Ci::Status::Build::Cancelable
    end
  end

449
  describe '#coverage_regex' do
450 451
    subject { build.coverage_regex }

452
    context 'when project has build_coverage_regex set' do
453 454
      let(:project_regex) { '\(\d+\.\d+\) covered' }

455
      before do
Grzegorz Bizon's avatar
Grzegorz Bizon committed
456
        project.update_column(:build_coverage_regex, project_regex)
457
      end
458 459

      context 'and coverage_regex attribute is not set' do
460
        it { is_expected.to eq(project_regex) }
461 462 463
      end

      context 'but coverage_regex attribute is also set' do
464
        let(:build_regex) { 'Code coverage: \d+\.\d+' }
465

466 467 468 469
        before do
          build.coverage_regex = build_regex
        end

470
        it { is_expected.to eq(build_regex) }
471 472 473 474 475 476 477 478 479
      end
    end

    context 'when neither project nor build has coverage regex set' do
      it { is_expected.to be_nil }
    end
  end

  describe '#update_coverage' do
480
    context "regarding coverage_regex's value," do
481
      before do
482
        build.coverage_regex = '\(\d+.\d+\%\) covered'
483 484 485 486 487 488 489 490 491 492
        build.trace.set('Coverage 1033 / 1051 LOC (98.29%) covered')
      end

      it "saves the correct extracted coverage value" do
        expect(build.update_coverage).to be(true)
        expect(build.coverage).to eq(98.29)
      end
    end
  end

493
  describe '#parse_trace_sections!' do
494 495 496 497 498
    it 'calls ExtractSectionsFromBuildTraceService' do
      expect(Ci::ExtractSectionsFromBuildTraceService)
          .to receive(:new).with(project, build.user).once.and_call_original
      expect_any_instance_of(Ci::ExtractSectionsFromBuildTraceService)
        .to receive(:execute).with(build).once
499

500
      build.parse_trace_sections!
501 502 503
    end
  end

504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
  describe '#trace' do
    subject { build.trace }

    it { is_expected.to be_a(Gitlab::Ci::Trace) }
  end

  describe '#has_trace?' do
    subject { build.has_trace? }

    it "expect to call exist? method" do
      expect_any_instance_of(Gitlab::Ci::Trace).to receive(:exist?)
        .and_return(true)

      is_expected.to be(true)
    end
  end

  describe '#trace=' do
    it "expect to fail trace=" do
      expect { build.trace = "new" }.to raise_error(NotImplementedError)
    end
  end

  describe '#old_trace' do
    subject { build.old_trace }

    before do
      build.update_column(:trace, 'old trace')
    end

    it "expect to receive data from database" do
      is_expected.to eq('old trace')
    end
  end

  describe '#erase_old_trace!' do
    subject { build.send(:read_attribute, :trace) }

    before do
      build.send(:write_attribute, :trace, 'old trace')
    end

    it "expect to receive data from database" do
      build.erase_old_trace!

      is_expected.to be_nil
    end
  end

  describe '#hide_secrets' do
    let(:subject) { build.hide_secrets(data) }

    context 'hide runners token' do
      let(:data) { 'new token data'}

      before do
        build.project.update(runners_token: 'token')
561
      end
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580

      it { is_expected.to eq('new xxxxx data') }
    end

    context 'hide build token' do
      let(:data) { 'new token data'}

      before do
        build.update(token: 'token')
      end

      it { is_expected.to eq('new xxxxx data') }
    end

    context 'hide build token' do
      let(:data) { 'new token data'}

      before do
        build.update(token: 'token')
581
      end
582 583

      it { is_expected.to eq('new xxxxx data') }
584 585 586
    end
  end

587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650
  describe 'deployment' do
    describe '#last_deployment' do
      subject { build.last_deployment }

      context 'when multiple deployments are created' do
        let!(:deployment1) { create(:deployment, deployable: build) }
        let!(:deployment2) { create(:deployment, deployable: build) }

        it 'returns the latest one' do
          is_expected.to eq(deployment2)
        end
      end
    end

    describe '#outdated_deployment?' do
      subject { build.outdated_deployment? }

      context 'when build succeeded' do
        let(:build) { create(:ci_build, :success) }
        let!(:deployment) { create(:deployment, deployable: build) }

        context 'current deployment is latest' do
          it { is_expected.to be_falsey }
        end

        context 'current deployment is not latest on environment' do
          let!(:deployment2) { create(:deployment, environment: deployment.environment) }

          it { is_expected.to be_truthy }
        end
      end

      context 'when build failed' do
        let(:build) { create(:ci_build, :failed) }

        it { is_expected.to be_falsey }
      end
    end
  end

  describe 'environment' do
    describe '#has_environment?' do
      subject { build.has_environment? }

      context 'when environment is defined' do
        before do
          build.update(environment: 'review')
        end

        it { is_expected.to be_truthy }
      end

      context 'when environment is not defined' do
        before do
          build.update(environment: nil)
        end

        it { is_expected.to be_falsey }
      end
    end

    describe '#expanded_environment_name' do
      subject { build.expanded_environment_name }

651
      context 'when environment uses $CI_COMMIT_REF_NAME' do
652 653 654
        let(:build) do
          create(:ci_build,
                 ref: 'master',
655
                 environment: 'review/$CI_COMMIT_REF_NAME')
656 657 658 659 660 661 662 663 664 665 666 667 668 669
        end

        it { is_expected.to eq('review/master') }
      end

      context 'when environment uses yaml_variables containing symbol keys' do
        let(:build) do
          create(:ci_build,
                 yaml_variables: [{ key: :APP_HOST, value: 'host' }],
                 environment: 'review/$APP_HOST')
        end

        it { is_expected.to eq('review/host') }
      end
670 671 672 673 674 675 676 677

      context 'when using persisted variables' do
        let(:build) do
          create(:ci_build, environment: 'review/x$CI_BUILD_ID')
        end

        it { is_expected.to eq('review/x') }
      end
678 679 680 681 682 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 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
    end

    describe '#starts_environment?' do
      subject { build.starts_environment? }

      context 'when environment is defined' do
        before do
          build.update(environment: 'review')
        end

        context 'no action is defined' do
          it { is_expected.to be_truthy }
        end

        context 'and start action is defined' do
          before do
            build.update(options: { environment: { action: 'start' } } )
          end

          it { is_expected.to be_truthy }
        end
      end

      context 'when environment is not defined' do
        before do
          build.update(environment: nil)
        end

        it { is_expected.to be_falsey }
      end
    end

    describe '#stops_environment?' do
      subject { build.stops_environment? }

      context 'when environment is defined' do
        before do
          build.update(environment: 'review')
        end

        context 'no action is defined' do
          it { is_expected.to be_falsey }
        end

        context 'and stop action is defined' do
          before do
            build.update(options: { environment: { action: 'stop' } } )
          end

          it { is_expected.to be_truthy }
        end
      end

      context 'when environment is not defined' do
        before do
          build.update(environment: nil)
        end

        it { is_expected.to be_falsey }
      end
    end
  end

  describe 'erasable build' do
    shared_examples 'erasable' do
      it 'removes artifact file' do
        expect(build.artifacts_file.exists?).to be_falsy
      end

      it 'removes artifact metadata file' do
        expect(build.artifacts_metadata.exists?).to be_falsy
      end

      it 'erases build trace in trace file' do
752
        expect(build).not_to have_trace
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774
      end

      it 'sets erased to true' do
        expect(build.erased?).to be true
      end

      it 'sets erase date' do
        expect(build.erased_at).not_to be_falsy
      end
    end

    context 'build is not erasable' do
      let!(:build) { create(:ci_build) }

      describe '#erase' do
        subject { build.erase }

        it { is_expected.to be false }
      end

      describe '#erasable?' do
        subject { build.erasable? }
775

776 777 778 779 780
        it { is_expected.to eq false }
      end
    end

    context 'build is erasable' do
781
      context 'new artifacts' do
782
        let!(:build) { create(:ci_build, :trace_artifact, :success, :artifacts) }
783

784 785
        describe '#erase' do
          before do
786
            build.erase(erased_by: erased_by)
787
          end
788

789
          context 'erased by user' do
790
            let!(:erased_by) { create(:user, username: 'eraser') }
791

792
            include_examples 'erasable'
793

794
            it 'records user who erased a build' do
795
              expect(build.erased_by).to eq erased_by
796
            end
797 798
          end

799
          context 'erased by system' do
800
            let(:erased_by) { nil }
801

802
            include_examples 'erasable'
803

804 805 806
            it 'does not set user who erased a build' do
              expect(build.erased_by).to be_nil
            end
807 808 809
          end
        end

810 811 812 813
        describe '#erasable?' do
          subject { build.erasable? }
          it { is_expected.to be_truthy }
        end
814

815
        describe '#erased?' do
816
          let!(:build) { create(:ci_build, :trace_artifact, :success, :artifacts) }
817
          subject { build.erased? }
818

819 820 821 822 823 824 825 826 827 828 829
          context 'job has not been erased' do
            it { is_expected.to be_falsey }
          end

          context 'job has been erased' do
            before do
              build.erase
            end

            it { is_expected.to be_truthy }
          end
830 831
        end

832 833 834
        context 'metadata and build trace are not available' do
          let!(:build) { create(:ci_build, :success, :artifacts) }

835
          before do
836
            build.remove_artifacts_metadata!
837 838
          end

839 840 841 842 843
          describe '#erase' do
            it 'does not raise error' do
              expect { build.erase }.not_to raise_error
            end
          end
844 845
        end
      end
846
    end
847

848 849 850
    context 'old artifacts' do
      context 'build is erasable' do
        context 'new artifacts' do
851
          let!(:build) { create(:ci_build, :trace_artifact, :success, :legacy_artifacts) }
852

853 854
          describe '#erase' do
            before do
855
              build.erase(erased_by: erased_by)
856
            end
857

858
            context 'erased by user' do
859
              let!(:erased_by) { create(:user, username: 'eraser') }
860 861 862 863

              include_examples 'erasable'

              it 'records user who erased a build' do
864
                expect(build.erased_by).to eq erased_by
865 866 867 868
              end
            end

            context 'erased by system' do
869
              let(:erased_by) { nil }
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884

              include_examples 'erasable'

              it 'does not set user who erased a build' do
                expect(build.erased_by).to be_nil
              end
            end
          end

          describe '#erasable?' do
            subject { build.erasable? }
            it { is_expected.to be_truthy }
          end

          describe '#erased?' do
885
            let!(:build) { create(:ci_build, :trace_artifact, :success, :legacy_artifacts) }
886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
            subject { build.erased? }

            context 'job has not been erased' do
              it { is_expected.to be_falsey }
            end

            context 'job has been erased' do
              before do
                build.erase
              end

              it { is_expected.to be_truthy }
            end
          end

          context 'metadata and build trace are not available' do
            let!(:build) { create(:ci_build, :success, :legacy_artifacts) }

            before do
              build.remove_artifacts_metadata!
            end

            describe '#erase' do
              it 'does not raise error' do
                expect { build.erase }.not_to raise_error
              end
            end
913 914 915 916 917 918 919 920 921
          end
        end
      end
    end
  end

  describe '#first_pending' do
    let!(:first) { create(:ci_build, pipeline: pipeline, status: 'pending', created_at: Date.yesterday) }
    let!(:second) { create(:ci_build, pipeline: pipeline, status: 'pending') }
922
    subject { described_class.first_pending }
923

924
    it { is_expected.to be_a(described_class) }
925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965
    it('returns with the first pending build') { is_expected.to eq(first) }
  end

  describe '#failed_but_allowed?' do
    subject { build.failed_but_allowed? }

    context 'when build is not allowed to fail' do
      before do
        build.allow_failure = false
      end

      context 'and build.status is success' do
        before do
          build.status = 'success'
        end

        it { is_expected.to be_falsey }
      end

      context 'and build.status is failed' do
        before do
          build.status = 'failed'
        end

        it { is_expected.to be_falsey }
      end
    end

    context 'when build is allowed to fail' do
      before do
        build.allow_failure = true
      end

      context 'and build.status is success' do
        before do
          build.status = 'success'
        end

        it { is_expected.to be_falsey }
      end

966
      context 'and build status is failed' do
967 968 969 970 971 972
        before do
          build.status = 'failed'
        end

        it { is_expected.to be_truthy }
      end
973 974 975 976 977 978 979 980

      context 'when build is a manual action' do
        before do
          build.status = 'manual'
        end

        it { is_expected.to be_falsey }
      end
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
    end
  end

  describe 'flags' do
    describe '#cancelable?' do
      subject { build }

      context 'when build is cancelable' do
        context 'when build is pending' do
          it { is_expected.to be_cancelable }
        end

        context 'when build is running' do
          before do
            build.run!
          end

          it { is_expected.to be_cancelable }
        end
      end

      context 'when build is not cancelable' do
        context 'when build is successful' do
          before do
            build.success!
          end

          it { is_expected.not_to be_cancelable }
        end

        context 'when build is failed' do
          before do
            build.drop!
          end

          it { is_expected.not_to be_cancelable }
        end
      end
    end

    describe '#retryable?' do
      subject { build }

      context 'when build is retryable' do
        context 'when build is successful' do
          before do
            build.success!
          end

          it { is_expected.to be_retryable }
        end

        context 'when build is failed' do
          before do
            build.drop!
          end

          it { is_expected.to be_retryable }
        end

        context 'when build is canceled' do
          before do
            build.cancel!
          end

          it { is_expected.to be_retryable }
        end
      end

      context 'when build is not retryable' do
        context 'when build is running' do
          before do
            build.run!
          end

          it { is_expected.not_to be_retryable }
        end

        context 'when build is skipped' do
          before do
            build.skip!
          end

          it { is_expected.not_to be_retryable }
        end
      end
    end

1069
    describe '#action?' do
1070 1071 1072 1073
      before do
        build.update(when: value)
      end

1074
      subject { build.action? }
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092

      context 'when is set to manual' do
        let(:value) { 'manual' }

        it { is_expected.to be_truthy }
      end

      context 'when set to something else' do
        let(:value) { 'something else' }

        it { is_expected.to be_falsey }
      end
    end
  end

  describe '#has_tags?' do
    context 'when build has tags' do
      subject { create(:ci_build, tag_list: ['tag']) }
1093

1094 1095 1096 1097 1098
      it { is_expected.to have_tags }
    end

    context 'when build does not have tags' do
      subject { create(:ci_build, tag_list: []) }
1099

1100 1101 1102 1103
      it { is_expected.not_to have_tags }
    end
  end

1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127
  describe 'build auto retry feature' do
    describe '#retries_count' do
      subject { create(:ci_build, name: 'test', pipeline: pipeline) }

      context 'when build has been retried several times' do
        before do
          create(:ci_build, :retried, name: 'test', pipeline: pipeline)
          create(:ci_build, :retried, name: 'test', pipeline: pipeline)
        end

        it 'reports a correct retry count value' do
          expect(subject.retries_count).to eq 2
        end
      end

      context 'when build has not been retried' do
        it 'returns zero' do
          expect(subject.retries_count).to eq 0
        end
      end
    end

    describe '#retries_max' do
      context 'when max retries value is defined' do
1128
        subject { create(:ci_build, options: { retry: 1 }) }
1129 1130

        it 'returns a number of configured max retries' do
1131
          expect(subject.retries_max).to eq 1
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
        end
      end

      context 'when max retries value is not defined' do
        subject { create(:ci_build) }

        it 'returns zero' do
          expect(subject.retries_max).to eq 0
        end
      end
    end
  end

1145 1146 1147
  describe '#keep_artifacts!' do
    let(:build) { create(:ci_build, artifacts_expire_at: Time.now + 7.days) }

1148 1149
    subject { build.keep_artifacts! }

1150
    it 'to reset expire_at' do
1151
      subject
1152 1153 1154

      expect(build.artifacts_expire_at).to be_nil
    end
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164

    context 'when having artifacts files' do
      let!(:artifact) { create(:ci_job_artifact, job: build, expire_in: '7 days') }

      it 'to reset dependent objects' do
        subject

        expect(artifact.reload.expire_at).to be_nil
      end
    end
1165 1166 1167 1168
  end

  describe '#merge_request' do
    def create_mr(build, pipeline, factory: :merge_request, created_at: Time.now)
1169
      create(factory, source_project: pipeline.project,
1170 1171 1172
                      target_project: pipeline.project,
                      source_branch: build.ref,
                      created_at: created_at)
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
    end

    context 'when a MR has a reference to the pipeline' do
      before do
        @merge_request = create_mr(build, pipeline, factory: :merge_request)

        commits = [double(id: pipeline.sha)]
        allow(@merge_request).to receive(:commits).and_return(commits)
        allow(MergeRequest).to receive_message_chain(:includes, :where, :reorder).and_return([@merge_request])
      end

      it 'returns the single associated MR' do
        expect(build.merge_request.id).to eq(@merge_request.id)
      end
    end

    context 'when there is not a MR referencing the pipeline' do
      it 'returns nil' do
        expect(build.merge_request).to be_nil
      end
    end
1194

1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
    context 'when more than one MR have a reference to the pipeline' do
      before do
        @merge_request = create_mr(build, pipeline, factory: :merge_request)
        @merge_request.close!
        @merge_request2 = create_mr(build, pipeline, factory: :merge_request)

        commits = [double(id: pipeline.sha)]
        allow(@merge_request).to receive(:commits).and_return(commits)
        allow(@merge_request2).to receive(:commits).and_return(commits)
        allow(MergeRequest).to receive_message_chain(:includes, :where, :reorder).and_return([@merge_request, @merge_request2])
      end

      it 'returns the first MR' do
        expect(build.merge_request.id).to eq(@merge_request.id)
      end
    end
1211

1212 1213 1214 1215 1216 1217
    context 'when a Build is created after the MR' do
      before do
        @merge_request = create_mr(build, pipeline, factory: :merge_request_with_diffs)
        pipeline2 = create(:ci_pipeline, project: project)
        @build2 = create(:ci_build, pipeline: pipeline2)

1218
        allow(@merge_request).to receive(:commit_shas)
1219
          .and_return([pipeline.sha, pipeline2.sha])
1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
        allow(MergeRequest).to receive_message_chain(:includes, :where, :reorder).and_return([@merge_request])
      end

      it 'returns the current MR' do
        expect(@build2.merge_request.id).to eq(@merge_request.id)
      end
    end
  end

  describe '#options' do
    let(:options) do
      {
        image: "ruby:2.1",
        services: [
          "postgres"
        ]
      }
    end

    it 'contains options' do
      expect(build.options).to eq(options)
    end
  end

  describe '#other_actions' do
    let(:build) { create(:ci_build, :manual, pipeline: pipeline) }
    let!(:other_build) { create(:ci_build, :manual, pipeline: pipeline, name: 'other action') }

    subject { build.other_actions }

1250
    before do
1251
      project.add_developer(user)
1252 1253
    end

1254 1255 1256 1257 1258
    it 'returns other actions' do
      is_expected.to contain_exactly(other_build)
    end

    context 'when build is retried' do
1259
      let!(:new_build) { described_class.retry(build, user) }
1260 1261 1262 1263 1264 1265 1266

      it 'does not return any of them' do
        is_expected.not_to include(build, new_build)
      end
    end

    context 'when other build is retried' do
1267
      let!(:retried_build) { described_class.retry(other_build, user) }
1268

1269 1270 1271 1272
      before do
        retried_build.success
      end

1273 1274 1275 1276 1277 1278 1279
      it 'returns a retried build' do
        is_expected.to contain_exactly(retried_build)
      end
    end
  end

  describe '#persisted_environment' do
1280 1281
    let!(:environment) do
      create(:environment, project: project, name: "foo-#{project.default_branch}")
1282 1283 1284 1285
    end

    subject { build.persisted_environment }

1286 1287 1288 1289
    context 'when referenced literally' do
      let(:build) do
        create(:ci_build, pipeline: pipeline, environment: "foo-#{project.default_branch}")
      end
1290

1291
      it { is_expected.to eq(environment) }
1292 1293
    end

1294
    context 'when referenced with a variable' do
1295 1296 1297
      let(:build) do
        create(:ci_build, pipeline: pipeline, environment: "foo-$CI_COMMIT_REF_NAME")
      end
1298

1299
      it { is_expected.to eq(environment) }
1300
    end
1301

Lin Jen-Shin's avatar
Lin Jen-Shin committed
1302
    context 'when there is no environment' do
1303 1304
      it { is_expected.to be_nil }
    end
1305 1306 1307 1308 1309
  end

  describe '#play' do
    let(:build) { create(:ci_build, :manual, pipeline: pipeline) }

1310
    before do
1311
      project.add_developer(user)
1312 1313
    end

1314 1315
    it 'enqueues the build' do
      expect(build.play(user)).to be_pending
1316 1317 1318
    end
  end

1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
  describe '#playable?' do
    context 'when build is a manual action' do
      context 'when build has been skipped' do
        subject { build_stubbed(:ci_build, :manual, status: :skipped) }

        it { is_expected.not_to be_playable }
      end

      context 'when build has been canceled' do
        subject { build_stubbed(:ci_build, :manual, status: :canceled) }

        it { is_expected.to be_playable }
      end

      context 'when build is successful' do
        subject { build_stubbed(:ci_build, :manual, status: :success) }

        it { is_expected.to be_playable }
      end

      context 'when build has failed' do
        subject { build_stubbed(:ci_build, :manual, status: :failed) }

        it { is_expected.to be_playable }
      end

      context 'when build is a manual untriggered action' do
        subject { build_stubbed(:ci_build, :manual, status: :manual) }

        it { is_expected.to be_playable }
      end
    end

    context 'when build is not a manual action' do
      subject { build_stubbed(:ci_build, :success) }

      it { is_expected.not_to be_playable }
    end
  end

1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
  describe 'project settings' do
    describe '#allow_git_fetch' do
      it 'return project allow_git_fetch configuration' do
        expect(build.allow_git_fetch).to eq(project.build_allow_git_fetch)
      end
    end
  end

  describe '#project' do
    subject { build.project }

    it { is_expected.to eq(pipeline.project) }
  end

  describe '#project_id' do
    subject { build.project_id }

    it { is_expected.to eq(pipeline.project_id) }
  end

  describe '#project_name' do
    subject { build.project_name }

    it { is_expected.to eq(project.name) }
  end

  describe '#ref_slug' do
    {
1387 1388 1389 1390 1391 1392 1393 1394
      'master'                => 'master',
      '1-foo'                 => '1-foo',
      'fix/1-foo'             => 'fix-1-foo',
      'fix-1-foo'             => 'fix-1-foo',
      'a' * 63                => 'a' * 63,
      'a' * 64                => 'a' * 63,
      'FOO'                   => 'foo',
      '-' + 'a' * 61 + '-'    => 'a' * 61,
1395 1396
      '-' + 'a' * 62 + '-'    => 'a' * 62,
      '-' + 'a' * 63 + '-'    => 'a' * 62,
Stefan Hanreich's avatar
Stefan Hanreich committed
1397
      'a' * 62 + ' '          => 'a' * 62
1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428
    }.each do |ref, slug|
      it "transforms #{ref} to #{slug}" do
        build.ref = ref

        expect(build.ref_slug).to eq(slug)
      end
    end
  end

  describe '#repo_url' do
    subject { build.repo_url }

    it { is_expected.to be_a(String) }
    it { is_expected.to end_with(".git") }
    it { is_expected.to start_with(project.web_url[0..6]) }
    it { is_expected.to include(build.token) }
    it { is_expected.to include('gitlab-ci-token') }
    it { is_expected.to include(project.web_url[7..-1]) }
  end

  describe '#stuck?' do
    subject { build.stuck? }

    context "when commit_status.status is pending" do
      before do
        build.status = 'pending'
      end

      it { is_expected.to be_truthy }

      context "and there are specific runner" do
1429
        let!(:runner) { create(:ci_runner, :project, projects: [build.project], contacted_at: 1.second.ago) }
1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444

        it { is_expected.to be_falsey }
      end
    end

    %w[success failed canceled running].each do |state|
      context "when commit_status.status is #{state}" do
        before do
          build.status = state
        end

        it { is_expected.to be_falsey }
      end
    end
  end
1445

1446 1447
  describe '#has_expiring_artifacts?' do
    context 'when artifacts have expiration date set' do
1448 1449 1450
      before do
        build.update(artifacts_expire_at: 1.day.from_now)
      end
1451 1452 1453 1454 1455 1456 1457

      it 'has expiring artifacts' do
        expect(build).to have_expiring_artifacts
      end
    end

    context 'when artifacts do not have expiration date set' do
1458 1459 1460
      before do
        build.update(artifacts_expire_at: nil)
      end
1461 1462 1463 1464 1465

      it 'does not have expiring artifacts' do
        expect(build).not_to have_expiring_artifacts
      end
    end
1466
  end
Tomasz Maczukin's avatar
Tomasz Maczukin committed
1467

1468 1469
  context 'when updating the build' do
    let(:build) { create(:ci_build, artifacts_size: 23) }
1470

1471
    it 'updates project statistics' do
1472
      build.artifacts_size = 42
1473 1474 1475 1476 1477 1478

      expect(build).to receive(:update_project_statistics_after_save).and_call_original

      expect { build.save! }
        .to change { build.project.statistics.reload.build_artifacts_size }
        .by(19)
1479 1480
    end

1481 1482 1483
    context 'when the artifact size stays the same' do
      it 'does not update project statistics' do
        build.name = 'changed'
1484

1485 1486 1487 1488
        expect(build).not_to receive(:update_project_statistics_after_save)

        build.save!
      end
1489
    end
1490
  end
1491

1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508
  context 'when destroying the build' do
    let!(:build) { create(:ci_build, artifacts_size: 23) }

    it 'updates project statistics' do
      expect(ProjectStatistics)
        .to receive(:increment_statistic)
        .and_call_original

      expect { build.destroy! }
        .to change { build.project.statistics.reload.build_artifacts_size }
        .by(-23)
    end

    context 'when the build is destroyed due to the project being destroyed' do
      it 'does not update the project statistics' do
        expect(ProjectStatistics)
          .not_to receive(:increment_statistic)
1509

1510 1511 1512
        build.project.update_attributes(pending_delete: true)
        build.project.destroy!
      end
1513 1514
    end
  end
1515 1516 1517 1518 1519 1520 1521

  describe '#when' do
    subject { build.when }

    context 'when `when` is undefined' do
      before do
        build.when = nil
1522
      end
1523 1524

      context 'use from gitlab-ci.yml' do
1525 1526
        let(:project) { create(:project, :repository) }
        let(:pipeline) { create(:ci_pipeline, project: project) }
1527

1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540
        before do
          stub_ci_pipeline_yaml_file(config)
        end

        context 'when config is not found' do
          let(:config) { nil }

          it { is_expected.to eq('on_success') }
        end

        context 'when config does not have a questioned job' do
          let(:config) do
            YAML.dump({
1541 1542 1543 1544
              test_other: {
                script: 'Hello World'
              }
            })
1545 1546 1547 1548 1549 1550 1551 1552
          end

          it { is_expected.to eq('on_success') }
        end

        context 'when config has `when`' do
          let(:config) do
            YAML.dump({
1553 1554 1555 1556 1557
              test: {
                script: 'Hello World',
                when: 'always'
              }
            })
1558 1559 1560 1561 1562 1563
          end

          it { is_expected.to eq('always') }
        end
      end
    end
1564
  end
1565 1566 1567 1568 1569

  describe '#variables' do
    let(:container_registry_enabled) { false }
    let(:predefined_variables) do
      [
1570
        { key: 'CI_PIPELINE_ID', value: pipeline.id.to_s, public: true },
1571
        { key: 'CI_PIPELINE_URL', value: project.web_url + "/pipelines/#{pipeline.id}", public: true },
1572
        { key: 'CI_JOB_ID', value: build.id.to_s, public: true },
1573
        { key: 'CI_JOB_URL', value: project.web_url + "/-/jobs/#{build.id}", public: true },
1574 1575 1576 1577 1578 1579
        { key: 'CI_JOB_TOKEN', value: build.token, public: false },
        { key: 'CI_BUILD_ID', value: build.id.to_s, public: true },
        { key: 'CI_BUILD_TOKEN', value: build.token, public: false },
        { key: 'CI_REGISTRY_USER', value: 'gitlab-ci-token', public: true },
        { key: 'CI_REGISTRY_PASSWORD', value: build.token, public: false },
        { key: 'CI_REPOSITORY_URL', value: build.repo_url, public: false },
1580 1581
        { key: 'CI', value: 'true', public: true },
        { key: 'GITLAB_CI', value: 'true', public: true },
1582
        { key: 'GITLAB_FEATURES', value: project.licensed_features.join(','), public: true },
1583 1584
        { key: 'CI_SERVER_NAME', value: 'GitLab', public: true },
        { key: 'CI_SERVER_VERSION', value: Gitlab::VERSION, public: true },
1585
        { key: 'CI_SERVER_REVISION', value: Gitlab.revision, public: true },
1586 1587
        { key: 'CI_JOB_NAME', value: 'test', public: true },
        { key: 'CI_JOB_STAGE', value: 'test', public: true },
Z.J. van de Weg's avatar
Z.J. van de Weg committed
1588
        { key: 'CI_COMMIT_SHA', value: build.sha, public: true },
1589 1590
        { key: 'CI_COMMIT_REF_NAME', value: build.ref, public: true },
        { key: 'CI_COMMIT_REF_SLUG', value: build.ref_slug, public: true },
1591 1592 1593 1594 1595 1596
        { key: 'CI_BUILD_REF', value: build.sha, public: true },
        { key: 'CI_BUILD_BEFORE_SHA', value: build.before_sha, public: true },
        { key: 'CI_BUILD_REF_NAME', value: build.ref, public: true },
        { key: 'CI_BUILD_REF_SLUG', value: build.ref_slug, public: true },
        { key: 'CI_BUILD_NAME', value: 'test', public: true },
        { key: 'CI_BUILD_STAGE', value: 'test', public: true },
1597 1598
        { key: 'CI_PROJECT_ID', value: project.id.to_s, public: true },
        { key: 'CI_PROJECT_NAME', value: project.path, public: true },
1599
        { key: 'CI_PROJECT_PATH', value: project.full_path, public: true },
1600
        { key: 'CI_PROJECT_PATH_SLUG', value: project.full_path_slug, public: true },
1601
        { key: 'CI_PROJECT_NAMESPACE', value: project.namespace.full_path, public: true },
1602
        { key: 'CI_PROJECT_URL', value: project.web_url, public: true },
1603
        { key: 'CI_PROJECT_VISIBILITY', value: 'private', public: true },
1604
        { key: 'CI_PIPELINE_IID', value: pipeline.iid.to_s, public: true },
1605
        { key: 'CI_CONFIG_PATH', value: pipeline.ci_yaml_file_path, public: true },
1606 1607 1608 1609
        { key: 'CI_PIPELINE_SOURCE', value: pipeline.source, public: true },
        { key: 'CI_COMMIT_MESSAGE', value: pipeline.git_commit_message, public: true },
        { key: 'CI_COMMIT_TITLE', value: pipeline.git_commit_title, public: true },
        { key: 'CI_COMMIT_DESCRIPTION', value: pipeline.git_commit_description, public: true }
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
      ]
    end

    before do
      stub_container_registry_config(enabled: container_registry_enabled, host_port: 'registry.example.com')
    end

    subject { build.variables }

    context 'returns variables' do
      before do
        build.yaml_variables = []
      end

1624
      it { is_expected.to include(*predefined_variables) }
1625 1626 1627 1628
    end

    context 'when build has user' do
      let(:user_variables) do
1629 1630 1631
        [
          { key: 'GITLAB_USER_ID', value: user.id.to_s, public: true },
          { key: 'GITLAB_USER_EMAIL', value: user.email, public: true },
1632
          { key: 'GITLAB_USER_LOGIN', value: user.username, public: true },
1633 1634
          { key: 'GITLAB_USER_NAME', value: user.name, public: true }
        ]
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651
      end

      before do
        build.update_attributes(user: user)
      end

      it { user_variables.each { |v| is_expected.to include(v) } }
    end

    context 'when build has an environment' do
      let(:environment_variables) do
        [
          { key: 'CI_ENVIRONMENT_NAME', value: 'production', public: true },
          { key: 'CI_ENVIRONMENT_SLUG', value: 'prod-slug',  public: true }
        ]
      end

1652 1653
      let!(:environment) do
        create(:environment,
1654 1655 1656 1657
               project: build.project,
               name: 'production',
               slug: 'prod-slug',
               external_url: '')
1658 1659
      end

1660 1661 1662 1663
      before do
        build.update(environment: 'production')
      end

1664
      shared_examples 'containing environment variables' do
1665
        it { environment_variables.each { |v| is_expected.to include(v) } }
1666 1667 1668 1669
      end

      context 'when no URL was set' do
        it_behaves_like 'containing environment variables'
1670 1671 1672 1673 1674 1675 1676 1677 1678

        it 'does not have CI_ENVIRONMENT_URL' do
          keys = subject.map { |var| var[:key] }

          expect(keys).not_to include('CI_ENVIRONMENT_URL')
        end
      end

      context 'when an URL was set' do
1679
        let(:url) { 'http://host/test' }
1680

1681
        before do
1682
          environment_variables <<
1683
            { key: 'CI_ENVIRONMENT_URL', value: url, public: true }
1684 1685
        end

1686 1687
        context 'when the URL was set from the job' do
          before do
1688
            build.update(options: { environment: { url: url } })
1689 1690 1691
          end

          it_behaves_like 'containing environment variables'
1692 1693 1694 1695 1696 1697 1698 1699 1700 1701

          context 'when variables are used in the URL, it does not expand' do
            let(:url) { 'http://$CI_PROJECT_NAME-$CI_ENVIRONMENT_SLUG' }

            it_behaves_like 'containing environment variables'

            it 'puts $CI_ENVIRONMENT_URL in the last so all other variables are available to be used when runners are trying to expand it' do
              expect(subject.last).to eq(environment_variables.last)
            end
          end
1702 1703 1704 1705 1706 1707 1708 1709 1710
        end

        context 'when the URL was not set from the job, but environment' do
          before do
            environment.update(external_url: url)
          end

          it_behaves_like 'containing environment variables'
        end
1711
      end
1712 1713 1714 1715 1716 1717 1718 1719
    end

    context 'when build started manually' do
      before do
        build.update_attributes(when: :manual)
      end

      let(:manual_variable) do
1720
        { key: 'CI_JOB_MANUAL', value: 'true', public: true }
1721 1722 1723 1724 1725 1726 1727
      end

      it { is_expected.to include(manual_variable) }
    end

    context 'when build is for tag' do
      let(:tag_variable) do
1728
        { key: 'CI_COMMIT_TAG', value: 'master', public: true }
1729 1730 1731 1732 1733 1734 1735 1736 1737
      end

      before do
        build.update_attributes(tag: true)
      end

      it { is_expected.to include(tag_variable) }
    end

1738 1739
    context 'when secret variable is defined' do
      let(:secret_variable) do
1740 1741 1742 1743
        { key: 'SECRET_KEY', value: 'secret_value', public: false }
      end

      before do
1744 1745
        create(:ci_variable,
               secret_variable.slice(:key, :value).merge(project: project))
1746 1747
      end

1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763
      it { is_expected.to include(secret_variable) }
    end

    context 'when protected variable is defined' do
      let(:protected_variable) do
        { key: 'PROTECTED_KEY', value: 'protected_value', public: false }
      end

      before do
        create(:ci_variable,
               :protected,
               protected_variable.slice(:key, :value).merge(project: project))
      end

      context 'when the branch is protected' do
        before do
1764
          allow(build.project).to receive(:protected_for?).with(build.ref).and_return(true)
1765 1766 1767 1768 1769
        end

        it { is_expected.to include(protected_variable) }
      end

1770 1771
      context 'when the tag is protected' do
        before do
1772
          allow(build.project).to receive(:protected_for?).with(build.ref).and_return(true)
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808
        end

        it { is_expected.to include(protected_variable) }
      end

      context 'when the ref is not protected' do
        it { is_expected.not_to include(protected_variable) }
      end
    end

    context 'when group secret variable is defined' do
      let(:secret_variable) do
        { key: 'SECRET_KEY', value: 'secret_value', public: false }
      end

      before do
        create(:ci_group_variable,
               secret_variable.slice(:key, :value).merge(group: group))
      end

      it { is_expected.to include(secret_variable) }
    end

    context 'when group protected variable is defined' do
      let(:protected_variable) do
        { key: 'PROTECTED_KEY', value: 'protected_value', public: false }
      end

      before do
        create(:ci_group_variable,
               :protected,
               protected_variable.slice(:key, :value).merge(group: group))
      end

      context 'when the branch is protected' do
        before do
1809
          allow(build.project).to receive(:protected_for?).with(build.ref).and_return(true)
1810 1811 1812 1813 1814
        end

        it { is_expected.to include(protected_variable) }
      end

1815 1816
      context 'when the tag is protected' do
        before do
1817
          allow(build.project).to receive(:protected_for?).with(build.ref).and_return(true)
1818 1819 1820 1821 1822 1823
        end

        it { is_expected.to include(protected_variable) }
      end

      context 'when the ref is not protected' do
1824 1825 1826 1827
        before do
          build.update_column(:ref, 'some/feature')
        end

1828 1829
        it { is_expected.not_to include(protected_variable) }
      end
1830 1831 1832 1833
    end

    context 'when build is for triggers' do
      let(:trigger) { create(:ci_trigger, project: project) }
1834 1835
      let(:trigger_request) { create(:ci_trigger_request, pipeline: pipeline, trigger: trigger) }

1836
      let(:user_trigger_variable) do
1837
        { key: 'TRIGGER_KEY_1', value: 'TRIGGER_VALUE_1', public: false }
1838
      end
1839

1840
      let(:predefined_trigger_variable) do
1841
        { key: 'CI_PIPELINE_TRIGGERED', value: 'true', public: true }
1842 1843 1844 1845 1846 1847
      end

      before do
        build.trigger_request = trigger_request
      end

1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867
      shared_examples 'returns variables for triggers' do
        it { is_expected.to include(user_trigger_variable) }
        it { is_expected.to include(predefined_trigger_variable) }
      end

      context 'when variables are stored in trigger_request' do
        before do
          trigger_request.update_attribute(:variables, { 'TRIGGER_KEY_1' => 'TRIGGER_VALUE_1' } )
        end

        it_behaves_like 'returns variables for triggers'
      end

      context 'when variables are stored in pipeline_variables' do
        before do
          create(:ci_pipeline_variable, pipeline: pipeline, key: 'TRIGGER_KEY_1', value: 'TRIGGER_VALUE_1')
        end

        it_behaves_like 'returns variables for triggers'
      end
1868 1869
    end

1870 1871 1872 1873 1874 1875
    context 'when pipeline has a variable' do
      let!(:pipeline_variable) { create(:ci_pipeline_variable, pipeline: pipeline) }

      it { is_expected.to include(pipeline_variable.to_runner_variable) }
    end

Shinya Maeda's avatar
Shinya Maeda committed
1876 1877 1878 1879 1880
    context 'when a job was triggered by a pipeline schedule' do
      let(:pipeline_schedule) { create(:ci_pipeline_schedule, project: project) }

      let!(:pipeline_schedule_variable) do
        create(:ci_pipeline_schedule_variable,
1881 1882
               key: 'SCHEDULE_VARIABLE_KEY',
               pipeline_schedule: pipeline_schedule)
Shinya Maeda's avatar
Shinya Maeda committed
1883 1884 1885 1886 1887 1888 1889 1890 1891 1892
      end

      before do
        pipeline_schedule.pipelines << pipeline
        pipeline_schedule.reload
      end

      it { is_expected.to include(pipeline_schedule_variable.to_runner_variable) }
    end

1893
    context 'when yaml_variables are undefined' do
1894 1895
      let(:pipeline) { create(:ci_pipeline, project: project) }

1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907
      before do
        build.yaml_variables = nil
      end

      context 'use from gitlab-ci.yml' do
        before do
          stub_ci_pipeline_yaml_file(config)
        end

        context 'when config is not found' do
          let(:config) { nil }

1908
          it { is_expected.to include(*predefined_variables) }
1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919
        end

        context 'when config does not have a questioned job' do
          let(:config) do
            YAML.dump({
              test_other: {
                script: 'Hello World'
              }
            })
          end

1920
          it { is_expected.to include(*predefined_variables) }
1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937
        end

        context 'when config has variables' do
          let(:config) do
            YAML.dump({
              test: {
                script: 'Hello World',
                variables: {
                  KEY: 'value'
                }
              }
            })
          end
          let(:variables) do
            [{ key: 'KEY', value: 'value', public: true }]
          end

1938 1939
          it { is_expected.to include(*predefined_variables) }
          it { is_expected.to include(*variables) }
1940 1941 1942 1943 1944 1945 1946 1947 1948 1949
        end
      end
    end

    context 'when container registry is enabled' do
      let(:container_registry_enabled) { true }
      let(:ci_registry) do
        { key: 'CI_REGISTRY',  value: 'registry.example.com',  public: true }
      end
      let(:ci_registry_image) do
1950
        { key: 'CI_REGISTRY_IMAGE',  value: project.container_registry_url, public: true }
1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972
      end

      context 'and is disabled for project' do
        before do
          project.update(container_registry_enabled: false)
        end

        it { is_expected.to include(ci_registry) }
        it { is_expected.not_to include(ci_registry_image) }
      end

      context 'and is enabled for project' do
        before do
          project.update(container_registry_enabled: true)
        end

        it { is_expected.to include(ci_registry) }
        it { is_expected.to include(ci_registry_image) }
      end
    end

    context 'when runner is assigned to build' do
Douwe Maan's avatar
Douwe Maan committed
1973
      let(:runner) { create(:ci_runner, description: 'description', tag_list: %w(docker linux)) }
1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988

      before do
        build.update(runner: runner)
      end

      it { is_expected.to include({ key: 'CI_RUNNER_ID', value: runner.id.to_s, public: true }) }
      it { is_expected.to include({ key: 'CI_RUNNER_DESCRIPTION', value: 'description', public: true }) }
      it { is_expected.to include({ key: 'CI_RUNNER_TAGS', value: 'docker, linux', public: true }) }
    end

    context 'when build is for a deployment' do
      let(:deployment_variable) { { key: 'KUBERNETES_TOKEN', value: 'TOKEN', public: false } }

      before do
        build.environment = 'production'
1989 1990 1991 1992

        allow_any_instance_of(Project)
          .to receive(:deployment_variables)
          .and_return([deployment_variable])
1993 1994 1995 1996 1997
      end

      it { is_expected.to include(deployment_variable) }
    end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
1998 1999 2000 2001
    context 'when project has custom CI config path' do
      let(:ci_config_path) { { key: 'CI_CONFIG_PATH', value: 'custom', public: true } }

      before do
2002
        project.update(ci_config_path: 'custom')
Lin Jen-Shin's avatar
Lin Jen-Shin committed
2003 2004 2005 2006 2007
      end

      it { is_expected.to include(ci_config_path) }
    end

2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030
    context 'when using auto devops' do
      context 'and is enabled' do
        before do
          project.create_auto_devops!(enabled: true, domain: 'example.com')
        end

        it "includes AUTO_DEVOPS_DOMAIN" do
          is_expected.to include(
            { key: 'AUTO_DEVOPS_DOMAIN', value: 'example.com', public: true })
        end
      end

      context 'and is disabled' do
        before do
          project.create_auto_devops!(enabled: false, domain: 'example.com')
        end

        it "includes AUTO_DEVOPS_DOMAIN" do
          is_expected.not_to include(
            { key: 'AUTO_DEVOPS_DOMAIN', value: 'example.com', public: true })
        end
      end
    end
2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049

    context 'when pipeline variable overrides build variable' do
      before do
        build.yaml_variables = [{ key: 'MYVAR', value: 'myvar', public: true }]
        pipeline.variables.build(key: 'MYVAR', value: 'pipeline value')
      end

      it 'overrides YAML variable using a pipeline variable' do
        variables = subject.reverse.uniq { |variable| variable[:key] }.reverse

        expect(variables)
          .not_to include(key: 'MYVAR', value: 'myvar', public: true)
        expect(variables)
          .to include(key: 'MYVAR', value: 'pipeline value', public: false)
      end
    end

    describe 'variables ordering' do
      context 'when variables hierarchy is stubbed' do
2050 2051 2052 2053
        let(:build_pre_var) { { key: 'build', value: 'value', public: true } }
        let(:project_pre_var) { { key: 'project', value: 'value', public: true } }
        let(:pipeline_pre_var) { { key: 'pipeline', value: 'value', public: true } }
        let(:build_yaml_var) { { key: 'yaml', value: 'value', public: true } }
2054 2055 2056 2057

        before do
          allow(build).to receive(:predefined_variables) { [build_pre_var] }
          allow(build).to receive(:yaml_variables) { [build_yaml_var] }
2058
          allow(build).to receive(:persisted_variables) { [] }
2059 2060 2061 2062

          allow_any_instance_of(Project)
            .to receive(:predefined_variables) { [project_pre_var] }

2063
          allow_any_instance_of(EE::Project)
2064 2065 2066 2067 2068
            .to receive(:secret_variables_for)
            .with(ref: 'master', environment: nil) do
            [create(:ci_variable, key: 'secret', value: 'value')]
          end

2069
          allow_any_instance_of(Ci::Pipeline)
2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106
            .to receive(:predefined_variables) { [pipeline_pre_var] }
        end

        it 'returns variables in order depending on resource hierarchy' do
          is_expected.to eq(
            [build_pre_var,
             project_pre_var,
             pipeline_pre_var,
             build_yaml_var,
             { key: 'secret', value: 'value', public: false }])
        end
      end

      context 'when build has environment and user-provided variables' do
        let(:expected_variables) do
          predefined_variables.map { |variable| variable.fetch(:key) } +
            %w[YAML_VARIABLE CI_ENVIRONMENT_NAME CI_ENVIRONMENT_SLUG
               CI_ENVIRONMENT_URL]
        end

        before do
          create(:environment, project: build.project,
                               name: 'staging')

          build.yaml_variables = [{ key: 'YAML_VARIABLE',
                                    value: 'var',
                                    public: true }]
          build.environment = 'staging'
        end

        it 'matches explicit variables ordering' do
          received_variables = subject.map { |variable| variable.fetch(:key) }

          expect(received_variables).to eq expected_variables
        end
      end
    end
2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125

    context 'when build has not been persisted yet' do
      let(:build) do
        described_class.new(
          name: 'rspec',
          stage: 'test',
          ref: 'feature',
          project: project,
          pipeline: pipeline
        )
      end

      it 'returns static predefined variables' do
        expect(build.variables.size).to be >= 28
        expect(build.variables)
          .to include(key: 'CI_COMMIT_REF_NAME', value: 'feature', public: true)
        expect(build).not_to be_persisted
      end
    end
2126 2127 2128 2129 2130 2131

    context 'for deploy tokens' do
      let(:deploy_token) { create(:deploy_token, :gitlab_deploy_token) }

      let(:deploy_token_variables) do
        [
2132
          { key: 'CI_DEPLOY_USER', value: deploy_token.username, public: true },
2133
          { key: 'CI_DEPLOY_PASSWORD', value: deploy_token.token, public: false }
2134 2135 2136
        ]
      end

2137
      context 'when gitlab-deploy-token exists' do
2138 2139 2140 2141 2142
        before do
          project.deploy_tokens << deploy_token
        end

        it 'should include deploy token variables' do
2143
          is_expected.to include(*deploy_token_variables)
2144 2145 2146 2147 2148
        end
      end

      context 'when gitlab-deploy-token does not exist' do
        it 'should not include deploy token variables' do
2149 2150
          expect(subject.find { |v| v[:key] == 'CI_DEPLOY_USER'}).to be_nil
          expect(subject.find { |v| v[:key] == 'CI_DEPLOY_PASSWORD'}).to be_nil
2151 2152 2153
        end
      end
    end
2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195
  end

  describe '#scoped_variables' do
    context 'when build has not been persisted yet' do
      let(:build) do
        described_class.new(
          name: 'rspec',
          stage: 'test',
          ref: 'feature',
          project: project,
          pipeline: pipeline
        )
      end

      it 'does not persist the build' do
        expect(build).to be_valid
        expect(build).not_to be_persisted

        build.scoped_variables

        expect(build).not_to be_persisted
      end

      it 'returns static predefined variables' do
        keys = %w[CI_JOB_NAME
                  CI_COMMIT_SHA
                  CI_COMMIT_REF_NAME
                  CI_COMMIT_REF_SLUG
                  CI_JOB_STAGE]

        variables = build.scoped_variables

        variables.map { |env| env[:key] }.tap do |names|
          expect(names).to include(*keys)
        end

        expect(variables)
          .to include(key: 'CI_COMMIT_REF_NAME', value: 'feature', public: true)
      end

      it 'does not return prohibited variables' do
        keys = %w[CI_JOB_ID
2196
                  CI_JOB_URL
2197 2198 2199 2200 2201 2202
                  CI_JOB_TOKEN
                  CI_BUILD_ID
                  CI_BUILD_TOKEN
                  CI_REGISTRY_USER
                  CI_REGISTRY_PASSWORD
                  CI_REPOSITORY_URL
2203 2204 2205
                  CI_ENVIRONMENT_URL
                  CI_DEPLOY_USER
                  CI_DEPLOY_PASSWORD]
2206 2207 2208 2209 2210 2211 2212 2213

        build.scoped_variables.map { |env| env[:key] }.tap do |names|
          expect(names).not_to include(*keys)
        end
      end
    end
  end

2214
  describe '#scoped_variables_hash' do
2215 2216 2217 2218 2219 2220 2221
    context 'when overriding secret variables' do
      before do
        project.variables.create!(key: 'MY_VAR', value: 'my value 1')
        pipeline.variables.create!(key: 'MY_VAR', value: 'my value 2')
      end

      it 'returns a regular hash created using valid ordering' do
2222 2223
        expect(build.scoped_variables_hash).to include('MY_VAR': 'my value 2')
        expect(build.scoped_variables_hash).not_to include('MY_VAR': 'my value 1')
2224
      end
2225 2226
    end

2227 2228 2229 2230 2231 2232 2233
    context 'when overriding user-provided variables' do
      before do
        pipeline.variables.build(key: 'MY_VAR', value: 'pipeline value')
        build.yaml_variables = [{ key: 'MY_VAR', value: 'myvar', public: true }]
      end

      it 'returns a hash including variable with higher precedence' do
2234 2235
        expect(build.scoped_variables_hash).to include('MY_VAR': 'pipeline value')
        expect(build.scoped_variables_hash).not_to include('MY_VAR': 'myvar')
2236
      end
2237
    end
2238
  end
Kamil Trzcinski's avatar
Kamil Trzcinski committed
2239

2240
  describe 'state transition: any => [:pending]' do
Kamil Trzcinski's avatar
Kamil Trzcinski committed
2241 2242 2243 2244 2245 2246 2247 2248
    let(:build) { create(:ci_build, :created) }

    it 'queues BuildQueueWorker' do
      expect(BuildQueueWorker).to receive(:perform_async).with(build.id)

      build.enqueue
    end
  end
2249

2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309
  describe 'state transition: pending: :running' do
    let(:runner) { create(:ci_runner) }
    let(:job) { create(:ci_build, :pending, runner: runner) }

    before do
      job.project.update_attribute(:build_timeout, 1800)
    end

    def run_job_without_exception
      job.run!
    rescue StateMachines::InvalidTransition
    end

    shared_examples 'saves data on transition' do
      it 'saves timeout' do
        expect { job.run! }.to change { job.reload.ensure_metadata.timeout }.from(nil).to(expected_timeout)
      end

      it 'saves timeout_source' do
        expect { job.run! }.to change { job.reload.ensure_metadata.timeout_source }.from('unknown_timeout_source').to(expected_timeout_source)
      end

      context 'when Ci::BuildMetadata#update_timeout_state fails update' do
        before do
          allow_any_instance_of(Ci::BuildMetadata).to receive(:update_timeout_state).and_return(false)
        end

        it "doesn't save timeout" do
          expect { run_job_without_exception }.not_to change { job.reload.ensure_metadata.timeout_source }
        end

        it "doesn't save timeout_source" do
          expect { run_job_without_exception }.not_to change { job.reload.ensure_metadata.timeout_source }
        end
      end
    end

    context 'when runner timeout overrides project timeout' do
      let(:expected_timeout) { 900 }
      let(:expected_timeout_source) { 'runner_timeout_source' }

      before do
        runner.update_attribute(:maximum_timeout, 900)
      end

      it_behaves_like 'saves data on transition'
    end

    context "when runner timeout doesn't override project timeout" do
      let(:expected_timeout) { 1800 }
      let(:expected_timeout_source) { 'project_timeout_source' }

      before do
        runner.update_attribute(:maximum_timeout, 3600)
      end

      it_behaves_like 'saves data on transition'
    end
  end

2310
  describe 'state transition: any => [:running]' do
2311 2312
    shared_examples 'validation is active' do
      context 'when depended job has not been completed yet' do
2313
        let!(:pre_stage_job) { create(:ci_build, :manual, pipeline: pipeline, name: 'test', stage_idx: 0) }
Shinya Maeda's avatar
Shinya Maeda committed
2314

2315
        it { expect { job.run! }.not_to raise_error }
2316
      end
2317

2318 2319
      context 'when artifacts of depended job has been expired' do
        let!(:pre_stage_job) { create(:ci_build, :success, :expired, pipeline: pipeline, name: 'test', stage_idx: 0) }
2320

2321 2322
        it { expect { job.run! }.to raise_error(Ci::Build::MissingDependenciesError) }
      end
2323

2324 2325
      context 'when artifacts of depended job has been erased' do
        let!(:pre_stage_job) { create(:ci_build, :success, pipeline: pipeline, name: 'test', stage_idx: 0, erased_at: 1.minute.ago) }
2326

2327 2328 2329 2330 2331 2332
        before do
          pre_stage_job.erase
        end

        it { expect { job.run! }.to raise_error(Ci::Build::MissingDependenciesError) }
      end
2333 2334
    end

2335 2336
    shared_examples 'validation is not active' do
      context 'when depended job has not been completed yet' do
2337
        let!(:pre_stage_job) { create(:ci_build, :manual, pipeline: pipeline, name: 'test', stage_idx: 0) }
2338

2339 2340 2341 2342 2343 2344 2345
        it { expect { job.run! }.not_to raise_error }
      end
      context 'when artifacts of depended job has been expired' do
        let!(:pre_stage_job) { create(:ci_build, :success, :expired, pipeline: pipeline, name: 'test', stage_idx: 0) }

        it { expect { job.run! }.not_to raise_error }
      end
2346

2347 2348
      context 'when artifacts of depended job has been erased' do
        let!(:pre_stage_job) { create(:ci_build, :success, pipeline: pipeline, name: 'test', stage_idx: 0, erased_at: 1.minute.ago) }
2349

2350 2351
        before do
          pre_stage_job.erase
2352
        end
2353

2354 2355 2356
        it { expect { job.run! }.not_to raise_error }
      end
    end
Shinya Maeda's avatar
Shinya Maeda committed
2357

2358
    let!(:job) { create(:ci_build, :pending, pipeline: pipeline, stage_idx: 1, options: options) }
Shinya Maeda's avatar
Shinya Maeda committed
2359

2360 2361 2362 2363
    context 'when validates for dependencies is enabled' do
      before do
        stub_feature_flags(ci_disable_validates_dependencies: false)
      end
Shinya Maeda's avatar
Shinya Maeda committed
2364

2365
      let!(:pre_stage_job) { create(:ci_build, :success, pipeline: pipeline, name: 'test', stage_idx: 0) }
Shinya Maeda's avatar
Shinya Maeda committed
2366

2367 2368
      context 'when "dependencies" keyword is not defined' do
        let(:options) { {} }
Shinya Maeda's avatar
Shinya Maeda committed
2369

2370 2371
        it { expect { job.run! }.not_to raise_error }
      end
Shinya Maeda's avatar
Shinya Maeda committed
2372

2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
      context 'when "dependencies" keyword is empty' do
        let(:options) { { dependencies: [] } }

        it { expect { job.run! }.not_to raise_error }
      end

      context 'when "dependencies" keyword is specified' do
        let(:options) { { dependencies: ['test'] } }

        it_behaves_like 'validation is active'
2383 2384
      end
    end
2385 2386 2387 2388 2389 2390 2391 2392 2393 2394

    context 'when validates for dependencies is disabled' do
      let(:options) { { dependencies: ['test'] } }

      before do
        stub_feature_flags(ci_disable_validates_dependencies: true)
      end

      it_behaves_like 'validation is not active'
    end
2395 2396
  end

2397
  describe 'state transition when build fails' do
2398 2399 2400 2401 2402 2403 2404
    let(:service) { MergeRequests::AddTodoWhenBuildFailsService.new(project, user) }

    before do
      allow(MergeRequests::AddTodoWhenBuildFailsService).to receive(:new).and_return(service)
      allow(service).to receive(:close)
    end

2405
    context 'when build is configured to be retried' do
2406
      subject { create(:ci_build, :running, options: { retry: 3 }, project: project, user: user) }
2407

2408
      it 'retries build and assigns the same user to it' do
2409
        expect(described_class).to receive(:retry)
2410 2411 2412 2413 2414 2415 2416 2417 2418
          .with(subject, user)

        subject.drop!
      end

      it 'does not try to create a todo' do
        project.add_developer(user)

        expect(service).not_to receive(:commit_status_merge_requests)
2419 2420 2421

        subject.drop!
      end
2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450

      context 'when retry service raises Gitlab::Access::AccessDeniedError exception' do
        let(:retry_service) { Ci::RetryBuildService.new(subject.project, subject.user) }

        before do
          allow_any_instance_of(Ci::RetryBuildService)
            .to receive(:execute)
            .with(subject)
            .and_raise(Gitlab::Access::AccessDeniedError)
          allow(Rails.logger).to receive(:error)
        end

        it 'handles raised exception' do
          expect { subject.drop! }.not_to raise_exception(Gitlab::Access::AccessDeniedError)
        end

        it 'logs the error' do
          subject.drop!

          expect(Rails.logger)
            .to have_received(:error)
            .with(a_string_matching("Unable to auto-retry job #{subject.id}"))
        end

        it 'fails the job' do
          subject.drop!
          expect(subject.failed?).to be_truthy
        end
      end
2451 2452 2453
    end

    context 'when build is not configured to be retried' do
2454
      subject { create(:ci_build, :running, project: project, user: user) }
2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468

      it 'does not retry build' do
        expect(described_class).not_to receive(:retry)

        subject.drop!
      end

      it 'does not count retries when not necessary' do
        expect(described_class).not_to receive(:retry)
        expect_any_instance_of(described_class)
          .not_to receive(:retries_count)

        subject.drop!
      end
2469 2470 2471 2472 2473 2474 2475 2476

      it 'creates a todo' do
        project.add_developer(user)

        expect(service).to receive(:commit_status_merge_requests)

        subject.drop!
      end
2477 2478
    end
  end
2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551

  describe '.matches_tag_ids' do
    set(:build) { create(:ci_build, project: project, user: user) }
    let(:tag_ids) { ::ActsAsTaggableOn::Tag.named_any(tag_list).ids }

    subject { described_class.where(id: build).matches_tag_ids(tag_ids) }

    before do
      build.update(tag_list: build_tag_list)
    end

    context 'when have different tags' do
      let(:build_tag_list) { %w(A B) }
      let(:tag_list) { %w(C D) }

      it "does not match a build" do
        is_expected.not_to contain_exactly(build)
      end
    end

    context 'when have a subset of tags' do
      let(:build_tag_list) { %w(A B) }
      let(:tag_list) { %w(A B C D) }

      it "does match a build" do
        is_expected.to contain_exactly(build)
      end
    end

    context 'when build does not have tags' do
      let(:build_tag_list) { [] }
      let(:tag_list) { %w(C D) }

      it "does match a build" do
        is_expected.to contain_exactly(build)
      end
    end

    context 'when does not have a subset of tags' do
      let(:build_tag_list) { %w(A B C) }
      let(:tag_list) { %w(C D) }

      it "does not match a build" do
        is_expected.not_to contain_exactly(build)
      end
    end
  end

  describe '.matches_tags' do
    set(:build) { create(:ci_build, project: project, user: user) }

    subject { described_class.where(id: build).with_any_tags }

    before do
      build.update(tag_list: tag_list)
    end

    context 'when does have tags' do
      let(:tag_list) { %w(A B) }

      it "does match a build" do
        is_expected.to contain_exactly(build)
      end
    end

    context 'when does not have tags' do
      let(:tag_list) { [] }

      it "does not match a build" do
        is_expected.not_to contain_exactly(build)
      end
    end
  end
2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590

  describe 'pages deployments' do
    set(:build) { create(:ci_build, project: project, user: user) }

    context 'when job is "pages"' do
      before do
        build.name = 'pages'
      end

      context 'when pages are enabled' do
        before do
          allow(Gitlab.config.pages).to receive_messages(enabled: true)
        end

        it 'is marked as pages generator' do
          expect(build).to be_pages_generator
        end

        context 'job succeeds' do
          it "calls pages worker" do
            expect(PagesWorker).to receive(:perform_async).with(:deploy, build.id)

            build.success!
          end
        end

        context 'job fails' do
          it "does not call pages worker" do
            expect(PagesWorker).not_to receive(:perform_async)

            build.drop!
          end
        end
      end

      context 'when pages are disabled' do
        before do
          allow(Gitlab.config.pages).to receive_messages(enabled: false)
        end
2591

2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623
        it 'is not marked as pages generator' do
          expect(build).not_to be_pages_generator
        end

        context 'job succeeds' do
          it "does not call pages worker" do
            expect(PagesWorker).not_to receive(:perform_async)

            build.success!
          end
        end
      end
    end

    context 'when job is not "pages"' do
      before do
        build.name = 'other-job'
      end

      it 'is not marked as pages generator' do
        expect(build).not_to be_pages_generator
      end

      context 'job succeeds' do
        it "does not call pages worker" do
          expect(PagesWorker).not_to receive(:perform_async)

          build.success
        end
      end
    end
  end
2624
end