BigW Consortium Gitlab

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

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

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

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

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

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

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

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

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

Z.J. van de Weg committed
37 38 39 40 41
  describe '#nullify_external_url' do
    it 'replaces a blank url with nil' do
      env = build(:environment, external_url: "")

      expect(env.save).to be true
42
      expect(env.external_url).to be_nil
Z.J. van de Weg committed
43 44
    end
  end
Z.J. van de Weg committed
45

46
  describe '#includes_commit?' do
47
    let(:project) { create(:project, :repository) }
48

Z.J. van de Weg committed
49 50
    context 'without a last deployment' do
      it "returns false" do
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
        expect(environment.includes_commit?('HEAD')).to be false
      end
    end

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

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

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

        it 'returns false' do
          expect(environment.includes_commit?(RepoHelpers.sample_commit)).to be false
        end
Z.J. van de Weg committed
74 75 76
      end
    end
  end
77

78
  describe '#update_merge_request_metrics?' do
79 80
    {
      'production' => true,
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
      'production/eu' => true,
      'production/www.gitlab.com' => true,
      'productioneu' => false,
      'Production' => false,
      'Production/eu' => false,
      'test-production' => false
    }.each do |name, expected_value|
      it "returns #{expected_value} for #{name}" do
        env = create(:environment, name: name)

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

96
  describe '#first_deployment_for' do
97
    let(:project)       { create(:project, :repository) }
98 99 100 101 102
    let!(:deployment)   { create(:deployment, environment: environment, ref: commit.parent.id) }
    let!(:deployment1)  { create(:deployment, environment: environment, ref: commit.id) }
    let(:head_commit)   { project.commit }
    let(:commit)        { project.commit.parent }

Kim "BKC" Carlbäcker committed
103
    context 'Gitaly find_ref_name feature disabled' do
104 105 106 107 108 109 110
      it 'returns deployment id for the environment' do
        expect(environment.first_deployment_for(commit)).to eq deployment1
      end

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

113 114 115 116 117 118 119 120 121 122 123 124
    # TODO: Uncomment when feature is reenabled
    # context 'Gitaly find_ref_name feature enabled' do
    #   before do
    #     allow(Gitlab::GitalyClient).to receive(:feature_enabled?).with(:find_ref_name).and_return(true)
    #   end
    #
    #   it 'calls GitalyClient' do
    #     expect_any_instance_of(Gitlab::GitalyClient::Ref).to receive(:find_ref_name)
    #
    #     environment.first_deployment_for(commit)
    #   end
    # end
125 126
  end

127 128 129 130
  describe '#environment_type' do
    subject { environment.environment_type }

    it 'sets a environment type if name has multiple segments' do
131
      environment.update!(name: 'production/worker.gitlab.com')
132 133 134 135 136

      is_expected.to eq('production')
    end

    it 'nullifies a type if it\'s a simple name' do
137
      environment.update!(name: 'production')
138 139 140 141

      is_expected.to be_nil
    end
  end
Kamil Trzcinski committed
142

Kamil Trzcinski committed
143 144
  describe '#stop_action?' do
    subject { environment.stop_action? }
Kamil Trzcinski committed
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171

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

    context 'when matching action is defined' do
      let(:build) { create(:ci_build) }
      let!(:deployment) { create(:deployment, environment: environment, deployable: build, on_stop: 'close_app') }
      let!(:close_action) { create(:ci_build, pipeline: build.pipeline, name: 'close_app', when: :manual) }

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

        it { is_expected.to be_truthy }
      end

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

        it { is_expected.to be_falsey }
      end
    end
  end
172

Kamil Trzcinski committed
173
  describe '#stop_with_action!' do
174
    let(:user) { create(:admin) }
175

Kamil Trzcinski committed
176
    subject { environment.stop_with_action!(user) }
177 178

    before do
179
      expect(environment).to receive(:available?).and_call_original
180 181 182
    end

    context 'when no other actions' do
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205
      context 'environment is available' do
        before do
          environment.update(state: :available)
        end

        it do
          subject

          expect(environment).to be_stopped
        end
      end

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

        it do
          subject

          expect(environment).to be_stopped
        end
      end
206 207 208 209 210 211 212 213 214 215
    end

    context 'when matching action is defined' do
      let(:build) { create(:ci_build) }
      let!(:deployment) { create(:deployment, environment: environment, deployable: build, on_stop: 'close_app') }

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

        it 'returns the same action' do
216 217
          expect(subject).to eq(close_action)
          expect(subject.user).to eq(user)
218 219 220 221 222 223 224 225
        end
      end

      context 'if action did finish' do
        let!(:close_action) { create(:ci_build, :manual, :success, pipeline: build.pipeline, name: 'close_app') }

        it 'returns a new action of the same type' do
          is_expected.to be_persisted
226 227
          expect(subject.name).to eq(close_action.name)
          expect(subject.user).to eq(user)
228 229 230 231
        end
      end
    end
  end
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252

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

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

      it { is_expected.to be true }
    end

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

      it { is_expected.to be false }
    end
  end
253 254 255 256

  describe '#actions_for' do
    let(:deployment) { create(:deployment, environment: environment) }
    let(:pipeline) { deployment.deployable.pipeline }
257
    let!(:review_action) { create(:ci_build, :manual, name: 'review-apps', pipeline: pipeline, environment: 'review/$CI_COMMIT_REF_NAME' )}
258 259 260 261 262 263
    let!(:production_action) { create(:ci_build, :manual, name: 'production', pipeline: pipeline, environment: 'production' )}

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

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
  describe '#has_terminals?' do
    subject { environment.has_terminals? }

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

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

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

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

    context 'when the environment is unavailable' do
      let(:project) { create(:kubernetes_project) }
289 290 291 292 293

      before do
        environment.stop
      end

294 295 296 297 298 299 300 301 302
      it { is_expected.to be_falsy }
    end
  end

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

    context 'when the environment has terminals' do
303 304 305
      before do
        allow(environment).to receive(:has_terminals?).and_return(true)
      end
306 307

      it 'returns the terminals from the deployment service' do
308 309 310
        expect(project.deployment_service)
          .to receive(:terminals).with(environment)
          .and_return(:fake_terminals)
311 312 313 314 315 316

        is_expected.to eq(:fake_terminals)
      end
    end

    context 'when the environment does not have terminals' do
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
      before do
        allow(environment).to receive(:has_terminals?).and_return(false)
      end

      it { is_expected.to be_nil }
    end
  end

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

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

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

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

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

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

      before do
        environment.stop
      end

      it { is_expected.to be_falsy }
    end
  end

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

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

      it 'returns the metrics from the deployment service' do
        expect(project.monitoring_service)
          .to receive(:metrics).with(environment)
          .and_return(:fake_metrics)

        is_expected.to eq(:fake_metrics)
      end
    end

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

      it { is_expected.to be_nil }
382 383 384
    end
  end

Nick Thomas committed
385 386 387 388 389 390 391 392 393 394 395 396 397 398
  describe '#slug' do
    it "is automatically generated" do
      expect(environment.slug).not_to be_nil
    end

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

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

  describe '#generate_slug' do
399
    SUFFIX = "-[a-z0-9]{6}".freeze
Nick Thomas committed
400 401 402 403 404 405 406 407 408 409
    {
      "staging-12345678901234567" => "staging-123456789" + SUFFIX,
      "9-staging-123456789012345" => "env-9-staging-123" + SUFFIX,
      "staging-1234567890123456"  => "staging-1234567890123456",
      "production"                => "production",
      "PRODUCTION"                => "production" + SUFFIX,
      "review/1-foo"              => "review-1-foo" + SUFFIX,
      "1-foo"                     => "env-1-foo" + SUFFIX,
      "1/foo"                     => "env-1-foo" + SUFFIX,
      "foo-"                      => "foo" + SUFFIX,
410 411 412 413 414
      "foo--bar"                  => "foo-bar" + SUFFIX,
      "foo**bar"                  => "foo-bar" + SUFFIX,
      "*-foo"                     => "env-foo" + SUFFIX,
      "staging-12345678-"         => "staging-12345678" + SUFFIX,
      "staging-12345678-01234567" => "staging-12345678" + SUFFIX,
Nick Thomas committed
415 416
    }.each do |name, matcher|
      it "returns a slug matching #{matcher}, given #{name}" do
417
        slug = described_class.new(name: name).generate_slug
Nick Thomas committed
418 419 420 421 422

        expect(slug).to match(/\A#{matcher}\z/)
      end
    end
  end
Douwe Maan committed
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451

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

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

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

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

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

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