gitlab_ci_yaml_processor_spec.rb 33.4 KB
Newer Older
1 2
require 'spec_helper'

Valery Sizov's avatar
Valery Sizov committed
3
module Ci
Douwe Maan's avatar
Douwe Maan committed
4
  describe GitlabCiYamlProcessor, lib: true do
5
    let(:path) { 'path' }
6

Valery Sizov's avatar
Valery Sizov committed
7 8 9 10 11 12 13 14 15
    describe "#builds_for_ref" do
      let(:type) { 'test' }

      it "returns builds if no branch specified" do
        config = YAML.dump({
          before_script: ["pwd"],
          rspec: { script: "rspec" }
        })

16
        config_processor = GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
17 18 19 20

        expect(config_processor.builds_for_stage_and_ref(type, "master").size).to eq(1)
        expect(config_processor.builds_for_stage_and_ref(type, "master").first).to eq({
          stage: "test",
21
          stage_idx: 1,
Valery Sizov's avatar
Valery Sizov committed
22 23 24
          except: nil,
          name: :rspec,
          only: nil,
Kamil Trzcinski's avatar
Kamil Trzcinski committed
25 26
          commands: "pwd\nrspec",
          tag_list: [],
Valery Sizov's avatar
Valery Sizov committed
27
          options: {},
Kamil Trzcinski's avatar
Kamil Trzcinski committed
28 29
          allow_failure: false,
          when: "on_success"
Valery Sizov's avatar
Valery Sizov committed
30 31
        })
      end
32

33 34 35 36 37 38
      describe :only do
        it "does not return builds if only has another branch" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", only: ["deploy"] }
                             })
Valery Sizov's avatar
Valery Sizov committed
39

40
          config_processor = GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
41

42 43
          expect(config_processor.builds_for_stage_and_ref(type, "master").size).to eq(0)
        end
Valery Sizov's avatar
Valery Sizov committed
44

45 46 47 48 49
        it "does not return builds if only has regexp with another branch" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", only: ["/^deploy$/"] }
                             })
Valery Sizov's avatar
Valery Sizov committed
50

51
          config_processor = GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
52

53 54
          expect(config_processor.builds_for_stage_and_ref(type, "master").size).to eq(0)
        end
Valery Sizov's avatar
Valery Sizov committed
55

56 57 58 59 60
        it "returns builds if only has specified this branch" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", only: ["master"] }
                             })
Valery Sizov's avatar
Valery Sizov committed
61

62
          config_processor = GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
63

64 65
          expect(config_processor.builds_for_stage_and_ref(type, "master").size).to eq(1)
        end
Valery Sizov's avatar
Valery Sizov committed
66

67 68 69 70 71
        it "returns builds if only has a list of branches including specified" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, only: ["master", "deploy"] }
                             })
Valery Sizov's avatar
Valery Sizov committed
72

73
          config_processor = GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
74

75 76
          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(1)
        end
Valery Sizov's avatar
Valery Sizov committed
77

78 79 80 81 82
        it "returns builds if only has a branches keyword specified" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, only: ["branches"] }
                             })
Valery Sizov's avatar
Valery Sizov committed
83

84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(1)
        end

        it "does not return builds if only has a tags keyword" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, only: ["tags"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(0)
        end

100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
        it "returns builds if only has a triggers keyword specified and a trigger is provided" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, only: ["triggers"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy", false, true).size).to eq(1)
        end

        it "does not return builds if only has a triggers keyword specified and no trigger is provided" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, only: ["triggers"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(0)
        end

122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
        it "returns builds if only has current repository path" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, only: ["branches@path"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(1)
        end

        it "does not return builds if only has different repository path" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, only: ["branches@fork"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(0)
        end

        it "returns build only for specified type" do

          config = YAML.dump({
                               before_script: ["pwd"],
Kamil Trzcinski's avatar
Kamil Trzcinski committed
148
                               rspec: { script: "rspec", type: "test", only: ["master", "deploy"] },
149 150 151
                               staging: { script: "deploy", type: "deploy", only: ["master", "deploy"] },
                               production: { script: "deploy", type: "deploy", only: ["master@path", "deploy"] },
                             })
Valery Sizov's avatar
Valery Sizov committed
152

Kamil Trzcinski's avatar
Kamil Trzcinski committed
153
          config_processor = GitlabCiYamlProcessor.new(config, 'fork')
Valery Sizov's avatar
Valery Sizov committed
154

155
          expect(config_processor.builds_for_stage_and_ref("deploy", "deploy").size).to eq(2)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
156 157
          expect(config_processor.builds_for_stage_and_ref("test", "deploy").size).to eq(1)
          expect(config_processor.builds_for_stage_and_ref("deploy", "master").size).to eq(1)
158
        end
Valery Sizov's avatar
Valery Sizov committed
159 160
      end

161 162 163 164 165 166
      describe :except do
        it "returns builds if except has another branch" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", except: ["deploy"] }
                             })
Valery Sizov's avatar
Valery Sizov committed
167

168
          config_processor = GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
169

170 171 172 173 174 175 176 177 178 179 180 181 182
          expect(config_processor.builds_for_stage_and_ref(type, "master").size).to eq(1)
        end

        it "returns builds if except has regexp with another branch" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", except: ["/^deploy$/"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "master").size).to eq(1)
        end
Valery Sizov's avatar
Valery Sizov committed
183

184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
        it "does not return builds if except has specified this branch" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", except: ["master"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "master").size).to eq(0)
        end

        it "does not return builds if except has a list of branches including specified" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, except: ["master", "deploy"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(0)
        end

        it "does not return builds if except has a branches keyword specified" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, except: ["branches"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(0)
        end

        it "returns builds if except has a tags keyword" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, except: ["tags"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(1)
        end

228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
        it "does not return builds if except has a triggers keyword specified and a trigger is provided" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, except: ["triggers"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy", false, true).size).to eq(0)
        end

        it "returns builds if except has a triggers keyword specified and no trigger is provided" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, except: ["triggers"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(1)
        end

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
        it "does not return builds if except has current repository path" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, except: ["branches@path"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(0)
        end

        it "returns builds if except has different repository path" do
          config = YAML.dump({
                               before_script: ["pwd"],
                               rspec: { script: "rspec", type: type, except: ["branches@fork"] }
                             })

          config_processor = GitlabCiYamlProcessor.new(config, path)

          expect(config_processor.builds_for_stage_and_ref(type, "deploy").size).to eq(1)
        end

        it "returns build except specified type" do
          config = YAML.dump({
                               before_script: ["pwd"],
Kamil Trzcinski's avatar
Kamil Trzcinski committed
275 276 277
                               rspec: { script: "rspec", type: "test", except: ["master", "deploy", "test@fork"] },
                               staging: { script: "deploy", type: "deploy", except: ["master"] },
                               production: { script: "deploy", type: "deploy", except: ["master@fork"] },
278 279
                             })

Kamil Trzcinski's avatar
Kamil Trzcinski committed
280
          config_processor = GitlabCiYamlProcessor.new(config, 'fork')
281

Kamil Trzcinski's avatar
Kamil Trzcinski committed
282 283 284
          expect(config_processor.builds_for_stage_and_ref("deploy", "deploy").size).to eq(2)
          expect(config_processor.builds_for_stage_and_ref("test", "test").size).to eq(0)
          expect(config_processor.builds_for_stage_and_ref("deploy", "master").size).to eq(0)
285
        end
Valery Sizov's avatar
Valery Sizov committed
286
      end
287

288
    end
289 290 291 292 293 294 295
    
    describe "Scripts handling" do
      let(:config_data) { YAML.dump(config) }
      let(:config_processor) { GitlabCiYamlProcessor.new(config_data, path) }
      
      subject { config_processor.builds_for_stage_and_ref("test", "master").first }
      
296
      describe "after_script" do
297 298 299
        context "in global context" do
          let(:config) {
            {
300
              after_script: ["after_script"],
301 302 303 304
              test: { script: ["script"] }
            }
          }

305 306
          it "return after_script in options" do
            expect(subject[:options][:after_script]).to eq(["after_script"])
307 308 309 310
          end
        end
      end
    end
311

Valery Sizov's avatar
Valery Sizov committed
312 313 314 315 316 317 318 319 320
    describe "Image and service handling" do
      it "returns image and service when defined" do
        config = YAML.dump({
                             image: "ruby:2.1",
                             services: ["mysql"],
                             before_script: ["pwd"],
                             rspec: { script: "rspec" }
                           })

321
        config_processor = GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
322 323 324 325 326

        expect(config_processor.builds_for_stage_and_ref("test", "master").size).to eq(1)
        expect(config_processor.builds_for_stage_and_ref("test", "master").first).to eq({
          except: nil,
          stage: "test",
327
          stage_idx: 1,
Valery Sizov's avatar
Valery Sizov committed
328 329
          name: :rspec,
          only: nil,
Kamil Trzcinski's avatar
Kamil Trzcinski committed
330 331
          commands: "pwd\nrspec",
          tag_list: [],
Valery Sizov's avatar
Valery Sizov committed
332 333 334 335
          options: {
            image: "ruby:2.1",
            services: ["mysql"]
          },
336 337
          allow_failure: false,
          when: "on_success"
Valery Sizov's avatar
Valery Sizov committed
338 339 340 341 342 343 344 345 346 347 348
        })
      end

      it "returns image and service when overridden for job" do
        config = YAML.dump({
                             image:         "ruby:2.1",
                             services:      ["mysql"],
                             before_script: ["pwd"],
                             rspec:         { image: "ruby:2.5", services: ["postgresql"], script: "rspec" }
                           })

349
        config_processor = GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
350 351 352 353 354

        expect(config_processor.builds_for_stage_and_ref("test", "master").size).to eq(1)
        expect(config_processor.builds_for_stage_and_ref("test", "master").first).to eq({
          except: nil,
          stage: "test",
355
          stage_idx: 1,
Valery Sizov's avatar
Valery Sizov committed
356 357
          name: :rspec,
          only: nil,
Kamil Trzcinski's avatar
Kamil Trzcinski committed
358 359
          commands: "pwd\nrspec",
          tag_list: [],
Valery Sizov's avatar
Valery Sizov committed
360 361 362 363
          options: {
            image: "ruby:2.5",
            services: ["postgresql"]
          },
364 365
          allow_failure: false,
          when: "on_success"
Valery Sizov's avatar
Valery Sizov committed
366 367
        })
      end
368 369
    end

Valery Sizov's avatar
Valery Sizov committed
370 371 372 373 374 375 376 377 378 379 380 381
    describe "Variables" do
      it "returns variables when defined" do
        variables = {
          var1: "value1",
          var2: "value2",
        }
        config = YAML.dump({
                             variables: variables,
                             before_script: ["pwd"],
                             rspec: { script: "rspec" }
                           })

382
        config_processor = GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
383 384
        expect(config_processor.variables).to eq(variables)
      end
385 386
    end

387 388 389 390 391 392 393
    describe "When" do
      %w(on_success on_failure always).each do |when_state|
        it "returns #{when_state} when defined" do
          config = YAML.dump({
                               rspec: { script: "rspec", when: when_state }
                             })

394
          config_processor = GitlabCiYamlProcessor.new(config, path)
395 396 397 398 399 400 401
          builds = config_processor.builds_for_stage_and_ref("test", "master")
          expect(builds.size).to eq(1)
          expect(builds.first[:when]).to eq(when_state)
        end
      end
    end

402 403 404
    describe "Caches" do
      it "returns cache when defined globally" do
        config = YAML.dump({
405
                             cache: { paths: ["logs/", "binaries/"], untracked: true, key: 'key' },
406 407 408 409 410 411 412 413 414 415 416
                             rspec: {
                               script: "rspec"
                             }
                           })

        config_processor = GitlabCiYamlProcessor.new(config)

        expect(config_processor.builds_for_stage_and_ref("test", "master").size).to eq(1)
        expect(config_processor.builds_for_stage_and_ref("test", "master").first[:options][:cache]).to eq(
          paths: ["logs/", "binaries/"],
          untracked: true,
417
          key: 'key',
418 419 420 421 422 423
        )
      end

      it "returns cache when defined in a job" do
        config = YAML.dump({
                             rspec: {
424
                               cache: { paths: ["logs/", "binaries/"], untracked: true, key: 'key' },
425 426 427 428 429 430 431 432 433 434
                               script: "rspec"
                             }
                           })

        config_processor = GitlabCiYamlProcessor.new(config)

        expect(config_processor.builds_for_stage_and_ref("test", "master").size).to eq(1)
        expect(config_processor.builds_for_stage_and_ref("test", "master").first[:options][:cache]).to eq(
          paths: ["logs/", "binaries/"],
          untracked: true,
435
          key: 'key',
436 437 438 439 440
        )
      end

      it "overwrite cache when defined for a job and globally" do
        config = YAML.dump({
441
                             cache: { paths: ["logs/", "binaries/"], untracked: true, key: 'global' },
442 443
                             rspec: {
                               script: "rspec",
444
                               cache: { paths: ["test/"], untracked: false, key: 'local' },
445 446 447 448 449 450 451 452 453
                             }
                           })

        config_processor = GitlabCiYamlProcessor.new(config)

        expect(config_processor.builds_for_stage_and_ref("test", "master").size).to eq(1)
        expect(config_processor.builds_for_stage_and_ref("test", "master").first[:options][:cache]).to eq(
          paths: ["test/"],
          untracked: false,
454
          key: 'local',
455 456 457 458
        )
      end
    end

459 460 461 462 463 464
    describe "Artifacts" do
      it "returns artifacts when defined" do
        config = YAML.dump({
                             image:         "ruby:2.1",
                             services:      ["mysql"],
                             before_script: ["pwd"],
465
                             rspec:         {
466
                               artifacts: { paths: ["logs/", "binaries/"], untracked: true, name: "custom_name" },
467 468
                               script: "rspec"
                             }
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
                           })

        config_processor = GitlabCiYamlProcessor.new(config)

        expect(config_processor.builds_for_stage_and_ref("test", "master").size).to eq(1)
        expect(config_processor.builds_for_stage_and_ref("test", "master").first).to eq({
          except: nil,
          stage: "test",
          stage_idx: 1,
          name: :rspec,
          only: nil,
          commands: "pwd\nrspec",
          tag_list: [],
          options: {
            image: "ruby:2.1",
            services: ["mysql"],
485
            artifacts: {
486
              name: "custom_name",
487 488 489
              paths: ["logs/", "binaries/"],
              untracked: true
            }
490 491 492 493 494 495 496
          },
          when: "on_success",
          allow_failure: false
        })
      end
    end

497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
    describe "Dependencies" do
      let(:config) do
        {
          build1: { stage: 'build', script: 'test' },
          build2: { stage: 'build', script: 'test' },
          test1: { stage: 'test', script: 'test', dependencies: dependencies },
          test2: { stage: 'test', script: 'test' },
          deploy: { stage: 'test', script: 'test' }
        }
      end

      subject { GitlabCiYamlProcessor.new(YAML.dump(config)) }

      context 'no dependencies' do
        let(:dependencies) { }

        it { expect { subject }.to_not raise_error }
      end

      context 'dependencies to builds' do
517
        let(:dependencies) { ['build1', 'build2'] }
518 519 520 521

        it { expect { subject }.to_not raise_error }
      end

522 523 524 525 526 527
      context 'dependencies to builds defined as symbols' do
        let(:dependencies) { [:build1, :build2] }

        it { expect { subject }.to_not raise_error }
      end

528
      context 'undefined dependency' do
529
        let(:dependencies) { ['undefined'] }
530 531 532 533 534

        it { expect { subject }.to raise_error(GitlabCiYamlProcessor::ValidationError, 'test1 job: undefined dependency: undefined') }
      end

      context 'dependencies to deploy' do
535
        let(:dependencies) { ['deploy'] }
536 537 538 539 540

        it { expect { subject }.to raise_error(GitlabCiYamlProcessor::ValidationError, 'test1 job: dependency deploy is not defined in prior stages') }
      end
    end

541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
    describe "Hidden jobs" do
      let(:config) do
        YAML.dump({
                    '.hidden_job' => { script: 'test' },
                    'normal_job' => { script: 'test' }
                  })
      end

      let(:config_processor) { GitlabCiYamlProcessor.new(config) }

      subject { config_processor.builds_for_stage_and_ref("test", "master") }

      it "doesn't create jobs that starts with dot" do
        expect(subject.size).to eq(1)
        expect(subject.first).to eq({
          except: nil,
          stage: "test",
          stage_idx: 1,
          name: :normal_job,
          only: nil,
          commands: "\ntest",
          tag_list: [],
          options: {},
          when: "on_success",
          allow_failure: false
        })
      end
    end

570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
    describe "YAML Alias/Anchor" do
      it "is correctly supported for jobs" do
        config = <<EOT
job1: &JOBTMPL
  script: execute-script-for-job

job2: *JOBTMPL
EOT

        config_processor = GitlabCiYamlProcessor.new(config)

        expect(config_processor.builds_for_stage_and_ref("test", "master").size).to eq(2)
        expect(config_processor.builds_for_stage_and_ref("test", "master").first).to eq({
          except: nil,
          stage: "test",
          stage_idx: 1,
          name: :job1,
          only: nil,
          commands: "\nexecute-script-for-job",
          tag_list: [],
          options: {},
          when: "on_success",
          allow_failure: false
        })
        expect(config_processor.builds_for_stage_and_ref("test", "master").second).to eq({
          except: nil,
          stage: "test",
          stage_idx: 1,
          name: :job2,
          only: nil,
          commands: "\nexecute-script-for-job",
          tag_list: [],
          options: {},
          when: "on_success",
          allow_failure: false
        })
      end
    end

Valery Sizov's avatar
Valery Sizov committed
609
    describe "Error handling" do
610 611 612 613
      it "fails to parse YAML" do
        expect{GitlabCiYamlProcessor.new("invalid: yaml: test")}.to raise_error(Psych::SyntaxError)
      end

Valery Sizov's avatar
Valery Sizov committed
614
      it "indicates that object is invalid" do
615
        expect{GitlabCiYamlProcessor.new("invalid_yaml")}.to raise_error(GitlabCiYamlProcessor::ValidationError)
Valery Sizov's avatar
Valery Sizov committed
616 617 618 619 620
      end

      it "returns errors if tags parameter is invalid" do
        config = YAML.dump({ rspec: { script: "test", tags: "mysql" } })
        expect do
621
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
622 623 624 625 626 627
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: tags parameter should be an array of strings")
      end

      it "returns errors if before_script parameter is invalid" do
        config = YAML.dump({ before_script: "bundle update", rspec: { script: "test" } })
        expect do
628
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
629 630 631
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "before_script should be an array of strings")
      end

632 633
      it "returns errors if after_script parameter is invalid" do
        config = YAML.dump({ after_script: "bundle update", rspec: { script: "test" } })
634 635
        expect do
          GitlabCiYamlProcessor.new(config, path)
636
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "after_script should be an array of strings")
637 638
      end

Valery Sizov's avatar
Valery Sizov committed
639 640 641
      it "returns errors if image parameter is invalid" do
        config = YAML.dump({ image: ["test"], rspec: { script: "test" } })
        expect do
642
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
643 644 645
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "image should be a string")
      end

Kamil Trzcinski's avatar
Kamil Trzcinski committed
646 647 648
      it "returns errors if job name is blank" do
        config = YAML.dump({ '' => { script: "test" } })
        expect do
649
          GitlabCiYamlProcessor.new(config, path)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
650 651 652 653 654 655
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "job name should be non-empty string")
      end

      it "returns errors if job name is non-string" do
        config = YAML.dump({ 10 => { script: "test" } })
        expect do
656
          GitlabCiYamlProcessor.new(config, path)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
657 658 659
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "job name should be non-empty string")
      end

Valery Sizov's avatar
Valery Sizov committed
660 661 662
      it "returns errors if job image parameter is invalid" do
        config = YAML.dump({ rspec: { script: "test", image: ["test"] } })
        expect do
663
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
664 665 666 667 668 669
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: image should be a string")
      end

      it "returns errors if services parameter is not an array" do
        config = YAML.dump({ services: "test", rspec: { script: "test" } })
        expect do
670
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
671 672 673 674 675 676
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "services should be an array of strings")
      end

      it "returns errors if services parameter is not an array of strings" do
        config = YAML.dump({ services: [10, "test"], rspec: { script: "test" } })
        expect do
677
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
678 679 680 681 682 683
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "services should be an array of strings")
      end

      it "returns errors if job services parameter is not an array" do
        config = YAML.dump({ rspec: { script: "test", services: "test" } })
        expect do
684
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
685 686 687 688 689 690
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: services should be an array of strings")
      end

      it "returns errors if job services parameter is not an array of strings" do
        config = YAML.dump({ rspec: { script: "test", services: [10, "test"] } })
        expect do
691
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
692 693 694 695 696 697
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: services should be an array of strings")
      end

      it "returns errors if there are unknown parameters" do
        config = YAML.dump({ extra: "bundle update" })
        expect do
698
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
699 700 701 702 703 704
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "Unknown parameter: extra")
      end

      it "returns errors if there are unknown parameters that are hashes, but doesn't have a script" do
        config = YAML.dump({ extra: { services: "test" } })
        expect do
705
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
706 707 708
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "Unknown parameter: extra")
      end

709
      it "returns errors if there are no jobs defined" do
Valery Sizov's avatar
Valery Sizov committed
710 711
        config = YAML.dump({ before_script: ["bundle update"] })
        expect do
712
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
713 714 715 716 717 718
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "Please define at least one job")
      end

      it "returns errors if job allow_failure parameter is not an boolean" do
        config = YAML.dump({ rspec: { script: "test", allow_failure: "string" } })
        expect do
719
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
720 721 722 723
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: allow_failure parameter should be an boolean")
      end

      it "returns errors if job stage is not a string" do
724
        config = YAML.dump({ rspec: { script: "test", type: 1 } })
Valery Sizov's avatar
Valery Sizov committed
725
        expect do
726
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
727 728 729 730
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: stage parameter should be build, test, deploy")
      end

      it "returns errors if job stage is not a pre-defined stage" do
731
        config = YAML.dump({ rspec: { script: "test", type: "acceptance" } })
Valery Sizov's avatar
Valery Sizov committed
732
        expect do
733
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
734 735 736 737
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: stage parameter should be build, test, deploy")
      end

      it "returns errors if job stage is not a defined stage" do
738
        config = YAML.dump({ types: ["build", "test"], rspec: { script: "test", type: "acceptance" } })
Valery Sizov's avatar
Valery Sizov committed
739
        expect do
740
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
741 742 743 744 745 746
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: stage parameter should be build, test")
      end

      it "returns errors if stages is not an array" do
        config = YAML.dump({ types: "test", rspec: { script: "test" } })
        expect do
747
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
748 749 750 751 752 753
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "stages should be an array of strings")
      end

      it "returns errors if stages is not an array of strings" do
        config = YAML.dump({ types: [true, "test"], rspec: { script: "test" } })
        expect do
754
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
755 756 757 758 759 760
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "stages should be an array of strings")
      end

      it "returns errors if variables is not a map" do
        config = YAML.dump({ variables: "test", rspec: { script: "test" } })
        expect do
761
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
762 763 764 765 766 767
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "variables should be a map of key-valued strings")
      end

      it "returns errors if variables is not a map of key-valued strings" do
        config = YAML.dump({ variables: { test: false }, rspec: { script: "test" } })
        expect do
768
          GitlabCiYamlProcessor.new(config, path)
Valery Sizov's avatar
Valery Sizov committed
769 770
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "variables should be a map of key-valued strings")
      end
771 772

      it "returns errors if job when is not on_success, on_failure or always" do
Kamil Trzcinski's avatar
Kamil Trzcinski committed
773
        config = YAML.dump({ rspec: { script: "test", when: 1 } })
774
        expect do
775
          GitlabCiYamlProcessor.new(config, path)
776 777
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: when parameter should be on_success, on_failure or always")
      end
778

779 780 781 782 783 784 785
      it "returns errors if job artifacts:name is not an a string" do
        config = YAML.dump({ types: ["build", "test"], rspec: { script: "test", artifacts: { name: 1 } } })
        expect do
          GitlabCiYamlProcessor.new(config)
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: artifacts:name parameter should be a string")
      end

786 787
      it "returns errors if job artifacts:untracked is not an array of strings" do
        config = YAML.dump({ types: ["build", "test"], rspec: { script: "test", artifacts: { untracked: "string" } } })
788 789
        expect do
          GitlabCiYamlProcessor.new(config)
790 791 792 793 794 795 796 797
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: artifacts:untracked parameter should be an boolean")
      end

      it "returns errors if job artifacts:paths is not an array of strings" do
        config = YAML.dump({ types: ["build", "test"], rspec: { script: "test", artifacts: { paths: "string" } } })
        expect do
          GitlabCiYamlProcessor.new(config)
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: artifacts:paths parameter should be an array of strings")
798
      end
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813

      it "returns errors if cache:untracked is not an array of strings" do
        config = YAML.dump({ cache: { untracked: "string" }, rspec: { script: "test" } })
        expect do
          GitlabCiYamlProcessor.new(config)
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "cache:untracked parameter should be an boolean")
      end

      it "returns errors if cache:paths is not an array of strings" do
        config = YAML.dump({ cache: { paths: "string" }, rspec: { script: "test" } })
        expect do
          GitlabCiYamlProcessor.new(config)
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "cache:paths parameter should be an array of strings")
      end

814 815 816 817 818 819 820 821 822 823 824 825 826 827
      it "returns errors if cache:key is not a string" do
        config = YAML.dump({ cache: { key: 1 }, rspec: { script: "test" } })
        expect do
          GitlabCiYamlProcessor.new(config)
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "cache:key parameter should be a string")
      end

      it "returns errors if job cache:key is not an a string" do
        config = YAML.dump({ types: ["build", "test"], rspec: { script: "test", cache: { key: 1 } } })
        expect do
          GitlabCiYamlProcessor.new(config)
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: cache:key parameter should be a string")
      end

828 829 830 831 832 833 834 835 836 837 838 839 840
      it "returns errors if job cache:untracked is not an array of strings" do
        config = YAML.dump({ types: ["build", "test"], rspec: { script: "test", cache: { untracked: "string" } } })
        expect do
          GitlabCiYamlProcessor.new(config)
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: cache:untracked parameter should be an boolean")
      end

      it "returns errors if job cache:paths is not an array of strings" do
        config = YAML.dump({ types: ["build", "test"], rspec: { script: "test", cache: { paths: "string" } } })
        expect do
          GitlabCiYamlProcessor.new(config)
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: cache:paths parameter should be an array of strings")
      end
841 842 843 844 845 846 847

      it "returns errors if job dependencies is not an array of strings" do
        config = YAML.dump({ types: ["build", "test"], rspec: { script: "test", dependencies: "string" } })
        expect do
          GitlabCiYamlProcessor.new(config)
        end.to raise_error(GitlabCiYamlProcessor::ValidationError, "rspec job: dependencies parameter should be an array of strings")
      end
848 849 850
    end
  end
end