environment_spec.rb 11.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's avatar
Kamil Trzcinski committed
10
  it { is_expected.to delegate_method(:stop_action).to(:last_deployment) }
11
  it { is_expected.to delegate_method(:manual_actions).to(:last_deployment) }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
12

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

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

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

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

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

Z.J. van de Weg's avatar
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's avatar
Z.J. van de Weg committed
43 44
    end
  end
Z.J. van de Weg's avatar
Z.J. van de Weg committed
45

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

Z.J. van de Weg's avatar
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's avatar
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

Z.J. van de Weg's avatar
Z.J. van de Weg committed
96
  describe '#first_deployment_for' do
97
    let(:project)       { create(:project, :repository) }
98 99 100 101 102 103
    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 }

    it 'returns deployment id for the environment' do
Z.J. van de Weg's avatar
Z.J. van de Weg committed
104
      expect(environment.first_deployment_for(commit)).to eq deployment1
105 106 107
    end

    it 'return nil when no deployment is found' do
Z.J. van de Weg's avatar
Z.J. van de Weg committed
108
      expect(environment.first_deployment_for(head_commit)).to eq nil
109 110 111
    end
  end

112 113 114 115
  describe '#environment_type' do
    subject { environment.environment_type }

    it 'sets a environment type if name has multiple segments' do
116
      environment.update!(name: 'production/worker.gitlab.com')
117 118 119 120 121

      is_expected.to eq('production')
    end

    it 'nullifies a type if it\'s a simple name' do
122
      environment.update!(name: 'production')
123 124 125 126

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

Kamil Trzcinski's avatar
Kamil Trzcinski committed
128 129
  describe '#stop_action?' do
    subject { environment.stop_action? }
Kamil Trzcinski's avatar
Kamil Trzcinski committed
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156

    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
157

Kamil Trzcinski's avatar
Kamil Trzcinski committed
158
  describe '#stop_with_action!' do
159
    let(:user) { create(:admin) }
160

Kamil Trzcinski's avatar
Kamil Trzcinski committed
161
    subject { environment.stop_with_action!(user) }
162 163

    before do
164
      expect(environment).to receive(:available?).and_call_original
165 166 167
    end

    context 'when no other actions' do
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
      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
191 192 193 194 195 196 197 198 199 200
    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
Kamil Trzcinski's avatar
Kamil Trzcinski committed
201 202
          expect(subject).to eq(close_action)
          expect(subject.user).to eq(user)
203 204 205 206 207 208 209 210
        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
Kamil Trzcinski's avatar
Kamil Trzcinski committed
211 212
          expect(subject.name).to eq(close_action.name)
          expect(subject.user).to eq(user)
213 214 215 216
        end
      end
    end
  end
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237

  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
238 239 240 241 242 243 244 245 246 247 248

  describe '#actions_for' do
    let(:deployment) { create(:deployment, environment: environment) }
    let(:pipeline) { deployment.deployable.pipeline }
    let!(:review_action) { create(:ci_build, :manual, name: 'review-apps', pipeline: pipeline, environment: 'review/$CI_BUILD_REF_NAME' )}
    let!(:production_action) { create(:ci_build, :manual, name: 'production', pipeline: pipeline, environment: 'production' )}

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

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 275 276 277 278 279 280 281 282 283 284 285 286
  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) }
      before { environment.stop }
      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
      before { allow(environment).to receive(:has_terminals?).and_return(true) }

      it 'returns the terminals from the deployment service' do
287 288 289
        expect(project.deployment_service)
          .to receive(:terminals).with(environment)
          .and_return(:fake_terminals)
290 291 292 293 294 295 296 297 298 299 300

        is_expected.to eq(:fake_terminals)
      end
    end

    context 'when the environment does not have terminals' do
      before { allow(environment).to receive(:has_terminals?).and_return(false) }
      it { is_expected.to eq(nil) }
    end
  end

Nick Thomas's avatar
Nick Thomas committed
301 302 303 304 305 306 307 308 309 310 311 312 313 314
  describe '#slug' do
    it "is automatically generated" do
      expect(environment.slug).not_to be_nil
    end

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

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

  describe '#generate_slug' do
Douwe Maan's avatar
Douwe Maan committed
315
    SUFFIX = "-[a-z0-9]{6}".freeze
Nick Thomas's avatar
Nick Thomas committed
316 317 318 319 320 321 322 323 324 325
    {
      "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,
326 327 328 329 330
      "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's avatar
Nick Thomas committed
331 332
    }.each do |name, matcher|
      it "returns a slug matching #{matcher}, given #{name}" do
333
        slug = described_class.new(name: name).generate_slug
Nick Thomas's avatar
Nick Thomas committed
334 335 336 337 338

        expect(slug).to match(/\A#{matcher}\z/)
      end
    end
  end
Douwe Maan's avatar
Douwe Maan committed
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

  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
368
end