summaryrefslogtreecommitdiff
path: root/spec/models/namespace/aggregation_schedule_spec.rb
blob: 0289e4a54620a832100dc3d2c7cdfc8f36740a6c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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
84
85
86
87
88
89
90
91
92
93
94
95
# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Namespace::AggregationSchedule, :clean_gitlab_redis_shared_state, type: :model do
  include ExclusiveLeaseHelpers

  let(:namespace) { create(:namespace) }
  let(:aggregation_schedule) { namespace.build_aggregation_schedule }
  let(:default_timeout) { aggregation_schedule.default_lease_timeout }

  it { is_expected.to belong_to :namespace }

  describe "#default_lease_timeout" do
    before do
      aggregation_schedule.save!
    end

    context 'when reduce_aggregation_schedule_lease FF is enabled' do
      it 'is 2 minutes' do
        stub_feature_flags(reduce_aggregation_schedule_lease: true)
        expect(aggregation_schedule.default_lease_timeout).to eq 2.minutes.to_i
      end
    end

    context 'when reduce_aggregation_schedule_lease FF is disabled' do
      it 'is 30 minutes' do
        stub_feature_flags(reduce_aggregation_schedule_lease: false)
        expect(aggregation_schedule.default_lease_timeout).to eq 30.minutes.to_i
      end
    end
  end

  describe '#schedule_root_storage_statistics' do
    let(:lease_key) { "namespace:namespaces_root_statistics:#{namespace.id}" }

    context "when we can't obtain the lease" do
      it 'does not schedule the workers' do
        stub_exclusive_lease_taken(lease_key, timeout: default_timeout)

        expect(Namespaces::RootStatisticsWorker)
          .not_to receive(:perform_async)

        expect(Namespaces::RootStatisticsWorker)
          .not_to receive(:perform_in)

        aggregation_schedule.save!
      end
    end

    context 'when we can obtain the lease' do
      it 'schedules a root storage statistics after create' do
        stub_exclusive_lease(lease_key, timeout: default_timeout)

        expect(Namespaces::RootStatisticsWorker)
          .to receive(:perform_async).once

        expect(Namespaces::RootStatisticsWorker)
          .to receive(:perform_in).once
          .with(default_timeout, aggregation_schedule.namespace_id)

        aggregation_schedule.save!
      end

      it 'does not release the lease' do
        stub_exclusive_lease(lease_key, timeout: default_timeout)

        aggregation_schedule.save!

        exclusive_lease = aggregation_schedule.exclusive_lease
        expect(exclusive_lease.exists?).to be_truthy
      end

      it 'only executes the workers once' do
        # Avoid automatic deletion of Namespace::AggregationSchedule
        # for testing purposes.
        expect(Namespaces::RootStatisticsWorker)
          .to receive(:perform_async).once
          .and_return(nil)

        expect(Namespaces::RootStatisticsWorker)
          .to receive(:perform_in).once
          .with(default_timeout, aggregation_schedule.namespace_id)
          .and_return(nil)

        # Scheduling workers for the first time
        aggregation_schedule.schedule_root_storage_statistics

        # Executing again, this time workers should not be scheduled
        # due to the lease not been released.
        aggregation_schedule.schedule_root_storage_statistics
      end
    end
  end
end