649 lines
22 KiB
Ruby
649 lines
22 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'spec_helper'
|
|
|
|
RSpec.describe Gitlab::Utils::UsageData do
|
|
include Database::DatabaseHelpers
|
|
|
|
shared_examples 'failing hardening method' do |raised_exception|
|
|
let(:exception) { raised_exception || ActiveRecord::StatementInvalid }
|
|
|
|
before do
|
|
allow(Gitlab::ErrorTracking).to receive(:should_raise_for_dev?).and_return(should_raise_for_dev)
|
|
stub_const("Gitlab::Utils::UsageData::FALLBACK", fallback)
|
|
allow(failing_class).to receive(failing_method).and_raise(exception) unless failing_class.nil?
|
|
end
|
|
|
|
context 'with should_raise_for_dev? false' do
|
|
let(:should_raise_for_dev) { false }
|
|
|
|
it 'returns the fallback' do
|
|
expect(subject).to eq(fallback)
|
|
end
|
|
end
|
|
|
|
context 'with should_raise_for_dev? true' do
|
|
let(:should_raise_for_dev) { true }
|
|
|
|
it 'raises an error' do
|
|
expect { subject }.to raise_error(exception)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '.with_duration' do
|
|
it 'yields passed block' do
|
|
expect { |block| described_class.with_duration(&block) }.to yield_with_no_args
|
|
end
|
|
end
|
|
|
|
describe '#add_metric' do
|
|
let(:metric) { 'UuidMetric'}
|
|
|
|
it 'computes the metric value for given metric' do
|
|
expect(described_class.add_metric(metric)).to eq(Gitlab::CurrentSettings.uuid)
|
|
end
|
|
end
|
|
|
|
describe '#count' do
|
|
let(:relation) { double(:relation) }
|
|
|
|
it 'returns the count when counting succeeds' do
|
|
allow(relation).to receive(:count).and_return(1)
|
|
|
|
expect(described_class.count(relation, batch: false)).to eq(1)
|
|
end
|
|
|
|
it 'records duration' do
|
|
expect(described_class).to receive(:with_duration)
|
|
allow(relation).to receive(:count).and_return(1)
|
|
|
|
described_class.count(relation, batch: false)
|
|
end
|
|
|
|
context 'when counting fails' do
|
|
subject { described_class.count(relation, batch: false) }
|
|
|
|
let(:fallback) { 15 }
|
|
let(:failing_class) { relation }
|
|
let(:failing_method) { :count }
|
|
|
|
it_behaves_like 'failing hardening method'
|
|
end
|
|
end
|
|
|
|
describe '#distinct_count' do
|
|
let(:relation) { double(:relation) }
|
|
|
|
it 'returns the count when counting succeeds' do
|
|
allow(relation).to receive(:distinct_count_by).and_return(1)
|
|
|
|
expect(described_class.distinct_count(relation, batch: false)).to eq(1)
|
|
end
|
|
|
|
it 'records duration' do
|
|
expect(described_class).to receive(:with_duration)
|
|
allow(relation).to receive(:distinct_count_by).and_return(1)
|
|
|
|
described_class.distinct_count(relation, batch: false)
|
|
end
|
|
|
|
context 'when counting fails' do
|
|
subject { described_class.distinct_count(relation, batch: false) }
|
|
|
|
let(:fallback) { 15 }
|
|
let(:failing_class) { relation }
|
|
let(:failing_method) { :distinct_count_by }
|
|
|
|
it_behaves_like 'failing hardening method'
|
|
end
|
|
end
|
|
|
|
describe '#estimate_batch_distinct_count' do
|
|
let(:error_rate) { Gitlab::Database::PostgresHll::BatchDistinctCounter::ERROR_RATE } # HyperLogLog is a probabilistic algorithm, which provides estimated data, with given error margin
|
|
let(:relation) { double(:relation, connection: double(:connection)) }
|
|
|
|
before do
|
|
allow(relation.connection).to receive(:transaction_open?).and_return(false)
|
|
end
|
|
|
|
it 'delegates counting to counter class instance' do
|
|
buckets = instance_double(Gitlab::Database::PostgresHll::Buckets)
|
|
|
|
expect_next_instance_of(Gitlab::Database::PostgresHll::BatchDistinctCounter, relation, 'column') do |instance|
|
|
expect(instance).to receive(:execute)
|
|
.with(batch_size: nil, start: nil, finish: nil)
|
|
.and_return(buckets)
|
|
end
|
|
expect(buckets).to receive(:estimated_distinct_count).and_return(5)
|
|
|
|
expect(described_class.estimate_batch_distinct_count(relation, 'column')).to eq(5)
|
|
end
|
|
|
|
it 'yield provided block with PostgresHll::Buckets' do
|
|
buckets = Gitlab::Database::PostgresHll::Buckets.new
|
|
|
|
allow_next_instance_of(Gitlab::Database::PostgresHll::BatchDistinctCounter) do |instance|
|
|
allow(instance).to receive(:execute).and_return(buckets)
|
|
end
|
|
|
|
expect { |block| described_class.estimate_batch_distinct_count(relation, 'column', &block) }.to yield_with_args(buckets)
|
|
end
|
|
|
|
context 'quasi integration test for different counting parameters' do
|
|
# HyperLogLog http://algo.inria.fr/flajolet/Publications/FlFuGaMe07.pdf algorithm
|
|
# used in estimate_batch_distinct_count produce probabilistic
|
|
# estimations of unique values present in dataset, because of that its results
|
|
# are always off by some small factor from real value. However for given
|
|
# dataset it provide consistent and deterministic result. In the following context
|
|
# analyzed sets consist of values:
|
|
# build_needs set: ['1', '2', '3', '4', '5']
|
|
# ci_build set ['a', 'b']
|
|
# with them, current implementation is expected to consistently report
|
|
# the same static values
|
|
# This test suite is expected to assure, that HyperLogLog implementation
|
|
# behaves consistently between changes made to other parts of codebase.
|
|
# In case of fine tuning or changes to HyperLogLog algorithm implementation
|
|
# one should run in depth analysis of accuracy with supplementary rake tasks
|
|
# currently under implementation at https://gitlab.com/gitlab-org/gitlab/-/merge_requests/51118
|
|
# and adjust used values in this context accordingly.
|
|
let_it_be(:build) { create(:ci_build, name: 'a') }
|
|
let_it_be(:another_build) { create(:ci_build, name: 'b') }
|
|
|
|
let(:model) { Ci::BuildNeed }
|
|
let(:column) { :name }
|
|
let(:build_needs_estimated_cardinality) { 5.024574181542231 }
|
|
let(:ci_builds_estimated_cardinality) { 2.003916452421793 }
|
|
|
|
before do
|
|
allow(model.connection).to receive(:transaction_open?).and_return(false)
|
|
end
|
|
|
|
context 'different counting parameters' do
|
|
before_all do
|
|
1.upto(3) { |i| create(:ci_build_need, name: i, build: build) }
|
|
4.upto(5) { |i| create(:ci_build_need, name: i, build: another_build) }
|
|
end
|
|
|
|
it 'counts with symbol passed in column argument' do
|
|
expect(described_class.estimate_batch_distinct_count(model, column)).to eq(build_needs_estimated_cardinality)
|
|
end
|
|
|
|
it 'counts with string passed in column argument' do
|
|
expect(described_class.estimate_batch_distinct_count(model, column.to_s)).to eq(build_needs_estimated_cardinality)
|
|
end
|
|
|
|
it 'counts with table.column passed in column argument' do
|
|
expect(described_class.estimate_batch_distinct_count(model, "#{model.table_name}.#{column}")).to eq(build_needs_estimated_cardinality)
|
|
end
|
|
|
|
it 'counts with Arel passed in column argument' do
|
|
expect(described_class.estimate_batch_distinct_count(model, model.arel_table[column])).to eq(build_needs_estimated_cardinality)
|
|
end
|
|
|
|
it 'counts over joined relations' do
|
|
expect(described_class.estimate_batch_distinct_count(model.joins(:build), "ci_builds.name")).to eq(ci_builds_estimated_cardinality)
|
|
end
|
|
|
|
it 'counts with :column field with batch_size of 50K' do
|
|
expect(described_class.estimate_batch_distinct_count(model, column, batch_size: 50_000)).to eq(build_needs_estimated_cardinality)
|
|
end
|
|
|
|
it 'counts with different number of batches and aggregates total result' do
|
|
stub_const('Gitlab::Database::PostgresHll::BatchDistinctCounter::MIN_REQUIRED_BATCH_SIZE', 0)
|
|
|
|
[1, 2, 4, 5, 6].each { |i| expect(described_class.estimate_batch_distinct_count(model, column, batch_size: i)).to eq(build_needs_estimated_cardinality) }
|
|
end
|
|
|
|
it 'counts with a start and finish' do
|
|
expect(described_class.estimate_batch_distinct_count(model, column, start: model.minimum(:id), finish: model.maximum(:id))).to eq(build_needs_estimated_cardinality)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'error handling' do
|
|
before do
|
|
stub_const("Gitlab::Utils::UsageData::FALLBACK", 3)
|
|
stub_const("Gitlab::Utils::UsageData::DISTRIBUTED_HLL_FALLBACK", 4)
|
|
end
|
|
|
|
context 'when counter raises WRONG_CONFIGURATION_ERROR' do
|
|
subject { described_class.estimate_batch_distinct_count(relation, 'id', start: 1, finish: 0) }
|
|
|
|
let(:fallback) { 3 }
|
|
let(:failing_class) { Gitlab::Database::PostgresHll::BatchDistinctCounter }
|
|
let(:failing_method) { :new }
|
|
|
|
it_behaves_like 'failing hardening method'
|
|
end
|
|
|
|
context 'when counting fails due to database error' do
|
|
subject { described_class.estimate_batch_distinct_count(relation) }
|
|
|
|
let(:fallback) { 3 }
|
|
let(:failing_class) { Gitlab::Database::PostgresHll::BatchDistinctCounter }
|
|
let(:failing_method) { :new }
|
|
|
|
it_behaves_like 'failing hardening method'
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#sum' do
|
|
let(:relation) { double(:relation) }
|
|
|
|
it 'returns the count when counting succeeds' do
|
|
allow(Gitlab::Database::BatchCount)
|
|
.to receive(:batch_sum)
|
|
.with(relation, :column, batch_size: 100, start: 2, finish: 3)
|
|
.and_return(1)
|
|
|
|
expect(described_class.sum(relation, :column, batch_size: 100, start: 2, finish: 3)).to eq(1)
|
|
end
|
|
|
|
it 'records duration' do
|
|
expect(described_class).to receive(:with_duration)
|
|
allow(Gitlab::Database::BatchCount).to receive(:batch_sum).and_return(1)
|
|
|
|
described_class.sum(relation, :column)
|
|
end
|
|
|
|
context 'when counting fails' do
|
|
subject { described_class.sum(relation, :column) }
|
|
|
|
let(:fallback) { 15 }
|
|
let(:failing_class) { Gitlab::Database::BatchCount }
|
|
let(:failing_method) { :batch_sum }
|
|
|
|
it_behaves_like 'failing hardening method'
|
|
end
|
|
end
|
|
|
|
describe '#histogram' do
|
|
let_it_be(:projects) { create_list(:project, 3) }
|
|
|
|
let(:project1) { projects.first }
|
|
let(:project2) { projects.second }
|
|
let(:project3) { projects.third }
|
|
|
|
let(:fallback) { described_class::HISTOGRAM_FALLBACK }
|
|
let(:relation) { AlertManagement::HttpIntegration.active }
|
|
let(:column) { :project_id }
|
|
|
|
def expect_error(exception, message, &block)
|
|
expect(Gitlab::ErrorTracking)
|
|
.to receive(:track_and_raise_for_dev_exception)
|
|
.with(instance_of(exception))
|
|
.and_call_original
|
|
|
|
expect(&block).to raise_error(
|
|
an_instance_of(exception).and(
|
|
having_attributes(message: message, backtrace: be_kind_of(Array)))
|
|
)
|
|
end
|
|
|
|
it 'checks bucket bounds to be not equal' do
|
|
expect_error(ArgumentError, 'Lower bucket bound cannot equal to upper bucket bound') do
|
|
described_class.histogram(relation, column, buckets: 1..1)
|
|
end
|
|
end
|
|
|
|
it 'checks bucket_size being non-zero' do
|
|
expect_error(ArgumentError, 'Bucket size cannot be zero') do
|
|
described_class.histogram(relation, column, buckets: 1..2, bucket_size: 0)
|
|
end
|
|
end
|
|
|
|
it 'limits the amount of buckets without providing bucket_size argument' do
|
|
expect_error(ArgumentError, 'Bucket size 101 exceeds the limit of 100') do
|
|
described_class.histogram(relation, column, buckets: 1..101)
|
|
end
|
|
end
|
|
|
|
it 'limits the amount of buckets when providing bucket_size argument' do
|
|
expect_error(ArgumentError, 'Bucket size 101 exceeds the limit of 100') do
|
|
described_class.histogram(relation, column, buckets: 1..2, bucket_size: 101)
|
|
end
|
|
end
|
|
|
|
it 'without data' do
|
|
histogram = described_class.histogram(relation, column, buckets: 1..100)
|
|
|
|
expect(histogram).to eq({})
|
|
end
|
|
|
|
it 'aggregates properly within bounds' do
|
|
create(:alert_management_http_integration, :active, project: project1)
|
|
create(:alert_management_http_integration, :inactive, project: project1)
|
|
|
|
create(:alert_management_http_integration, :active, project: project2)
|
|
create(:alert_management_http_integration, :active, project: project2)
|
|
create(:alert_management_http_integration, :inactive, project: project2)
|
|
|
|
create(:alert_management_http_integration, :active, project: project3)
|
|
create(:alert_management_http_integration, :inactive, project: project3)
|
|
|
|
histogram = described_class.histogram(relation, column, buckets: 1..100)
|
|
|
|
expect(histogram).to eq('1' => 2, '2' => 1)
|
|
end
|
|
|
|
it 'aggregates properly out of bounds' do
|
|
create_list(:alert_management_http_integration, 3, :active, project: project1)
|
|
histogram = described_class.histogram(relation, column, buckets: 1..2)
|
|
|
|
expect(histogram).to eq('2' => 1)
|
|
end
|
|
|
|
it 'records duration' do
|
|
expect(described_class).to receive(:with_duration)
|
|
|
|
described_class.histogram(relation, column, buckets: 1..100)
|
|
end
|
|
|
|
context 'when query timeout' do
|
|
subject do
|
|
with_statement_timeout(0.001) do
|
|
relation = AlertManagement::HttpIntegration.select('pg_sleep(0.002)')
|
|
described_class.histogram(relation, column, buckets: 1..100)
|
|
end
|
|
end
|
|
|
|
before do
|
|
allow(Gitlab::ErrorTracking).to receive(:should_raise_for_dev?).and_return(should_raise_for_dev)
|
|
create(:alert_management_http_integration, :active, project: project1)
|
|
end
|
|
|
|
context 'with should_raise_for_dev? false' do
|
|
let(:should_raise_for_dev) { false }
|
|
|
|
it 'logs canceled queries' do
|
|
expect(Gitlab::AppJsonLogger).to receive(:error).with(
|
|
event: 'histogram',
|
|
relation: relation.table_name,
|
|
operation: 'histogram',
|
|
operation_args: [column, 1, 100, 99],
|
|
query: kind_of(String),
|
|
message: /PG::QueryCanceled/
|
|
)
|
|
subject
|
|
end
|
|
|
|
it 'returns fallback' do
|
|
expect(subject).to eq(fallback)
|
|
end
|
|
end
|
|
|
|
context 'with should_raise_for_dev? true' do
|
|
let(:should_raise_for_dev) { true }
|
|
|
|
it 'raises error' do
|
|
expect { subject }.to raise_error(ActiveRecord::QueryCanceled)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#add' do
|
|
it 'adds given values' do
|
|
expect(described_class.add(1, 3)).to eq(4)
|
|
end
|
|
|
|
it 'adds given values' do
|
|
expect(described_class.add).to eq(0)
|
|
end
|
|
|
|
it 'records duration' do
|
|
expect(described_class).to receive(:with_duration)
|
|
|
|
described_class.add
|
|
end
|
|
|
|
context 'when adding fails' do
|
|
subject { described_class.add(nil, 3) }
|
|
|
|
let(:fallback) { -1 }
|
|
let(:failing_class) { nil }
|
|
|
|
it_behaves_like 'failing hardening method', StandardError
|
|
end
|
|
|
|
it 'returns the fallback value one of the arguments is negative' do
|
|
expect(described_class.add(-1, 1)).to eq(-1)
|
|
end
|
|
end
|
|
|
|
describe '#alt_usage_data' do
|
|
context 'when method fails' do
|
|
subject { described_class.alt_usage_data { raise StandardError } }
|
|
|
|
let(:fallback) { -1 }
|
|
let(:failing_class) { nil }
|
|
|
|
it_behaves_like 'failing hardening method', StandardError
|
|
end
|
|
|
|
it 'records duration' do
|
|
expect(described_class).to receive(:with_duration)
|
|
|
|
described_class.alt_usage_data
|
|
end
|
|
|
|
it 'returns the evaluated block when give' do
|
|
expect(described_class.alt_usage_data { Gitlab::CurrentSettings.uuid } ).to eq(Gitlab::CurrentSettings.uuid)
|
|
end
|
|
|
|
it 'returns the value when given' do
|
|
expect(described_class.alt_usage_data(1)).to eq 1
|
|
end
|
|
end
|
|
|
|
describe '#redis_usage_data' do
|
|
it 'records duration' do
|
|
expect(described_class).to receive(:with_duration)
|
|
|
|
described_class.redis_usage_data
|
|
end
|
|
|
|
context 'with block given' do
|
|
context 'when method fails' do
|
|
subject { described_class.redis_usage_data { raise ::Redis::CommandError } }
|
|
|
|
let(:fallback) { -1 }
|
|
let(:failing_class) { nil }
|
|
|
|
it_behaves_like 'failing hardening method', ::Redis::CommandError
|
|
end
|
|
|
|
context 'when Redis HLL raises any error' do
|
|
subject { described_class.redis_usage_data { raise Gitlab::UsageDataCounters::HLLRedisCounter::CategoryMismatch } }
|
|
|
|
let(:fallback) { 15 }
|
|
let(:failing_class) { nil }
|
|
|
|
it_behaves_like 'failing hardening method', Gitlab::UsageDataCounters::HLLRedisCounter::CategoryMismatch
|
|
end
|
|
|
|
it 'returns the evaluated block when given' do
|
|
expect(described_class.redis_usage_data { 1 }).to eq(1)
|
|
end
|
|
end
|
|
|
|
context 'with counter given' do
|
|
context 'when gets an error' do
|
|
subject { described_class.redis_usage_data(::Gitlab::UsageDataCounters::WikiPageCounter) }
|
|
|
|
let(:fallback) { ::Gitlab::UsageDataCounters::WikiPageCounter.fallback_totals }
|
|
let(:failing_class) { ::Gitlab::UsageDataCounters::WikiPageCounter }
|
|
let(:failing_method) { :totals }
|
|
|
|
it_behaves_like 'failing hardening method', ::Redis::CommandError
|
|
end
|
|
|
|
it 'returns the totals when couter is given' do
|
|
allow(::Gitlab::UsageDataCounters::WikiPageCounter).to receive(:totals).and_return({ wiki_pages_create: 2 })
|
|
expect(described_class.redis_usage_data(::Gitlab::UsageDataCounters::WikiPageCounter)).to eql({ wiki_pages_create: 2 })
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#with_prometheus_client' do
|
|
it 'records duration' do
|
|
expect(described_class).to receive(:with_duration)
|
|
|
|
described_class.with_prometheus_client { |client| client }
|
|
end
|
|
|
|
it 'returns fallback with for an exception in yield block' do
|
|
allow(described_class).to receive(:prometheus_client).and_return(Gitlab::PrometheusClient.new('http://localhost:9090'))
|
|
result = described_class.with_prometheus_client(fallback: -42) { |client| raise StandardError }
|
|
|
|
expect(result).to be(-42)
|
|
end
|
|
|
|
shared_examples 'query data from Prometheus' do
|
|
it 'yields a client instance and returns the block result' do
|
|
result = described_class.with_prometheus_client { |client| client }
|
|
|
|
expect(result).to be_an_instance_of(Gitlab::PrometheusClient)
|
|
end
|
|
end
|
|
|
|
shared_examples 'does not query data from Prometheus' do
|
|
it 'returns {} by default' do
|
|
result = described_class.with_prometheus_client { |client| client }
|
|
|
|
expect(result).to eq({})
|
|
end
|
|
|
|
it 'returns fallback if provided' do
|
|
result = described_class.with_prometheus_client(fallback: []) { |client| client }
|
|
|
|
expect(result).to eq([])
|
|
end
|
|
end
|
|
|
|
shared_examples 'try to query Prometheus with given address' do
|
|
context 'Prometheus is ready' do
|
|
before do
|
|
stub_request(:get, %r{/-/ready})
|
|
.to_return(status: 200, body: 'Prometheus is Ready.\n')
|
|
end
|
|
|
|
context 'Prometheus is reachable through HTTPS' do
|
|
it_behaves_like 'query data from Prometheus'
|
|
end
|
|
|
|
context 'Prometheus is not reachable through HTTPS' do
|
|
before do
|
|
stub_request(:get, %r{https://.*}).to_raise(Errno::ECONNREFUSED)
|
|
end
|
|
|
|
context 'Prometheus is reachable through HTTP' do
|
|
it_behaves_like 'query data from Prometheus'
|
|
end
|
|
|
|
context 'Prometheus is not reachable through HTTP' do
|
|
before do
|
|
stub_request(:get, %r{http://.*}).to_raise(Errno::ECONNREFUSED)
|
|
end
|
|
|
|
it_behaves_like 'does not query data from Prometheus'
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'Prometheus is not ready' do
|
|
before do
|
|
stub_request(:get, %r{/-/ready})
|
|
.to_return(status: 503, body: 'Service Unavailable')
|
|
end
|
|
|
|
it_behaves_like 'does not query data from Prometheus'
|
|
end
|
|
end
|
|
|
|
context 'when Prometheus server address is available from settings' do
|
|
before do
|
|
expect(Gitlab::Prometheus::Internal).to receive(:prometheus_enabled?).and_return(true)
|
|
expect(Gitlab::Prometheus::Internal).to receive(:uri).and_return('http://prom:9090')
|
|
end
|
|
|
|
it_behaves_like 'try to query Prometheus with given address'
|
|
end
|
|
|
|
context 'when Prometheus server address is available from Consul service discovery' do
|
|
before do
|
|
expect(Gitlab::Prometheus::Internal).to receive(:prometheus_enabled?).and_return(false)
|
|
expect(Gitlab::Consul::Internal).to receive(:api_url).and_return('http://localhost:8500')
|
|
expect(Gitlab::Consul::Internal).to receive(:discover_prometheus_server_address).and_return('prom:9090')
|
|
end
|
|
|
|
it_behaves_like 'try to query Prometheus with given address'
|
|
end
|
|
|
|
context 'when Prometheus server address is not available' do
|
|
before do
|
|
expect(Gitlab::Prometheus::Internal).to receive(:prometheus_enabled?).and_return(false)
|
|
expect(Gitlab::Consul::Internal).to receive(:api_url).and_return(nil)
|
|
end
|
|
|
|
it_behaves_like 'does not query data from Prometheus'
|
|
end
|
|
end
|
|
|
|
describe '#measure_duration' do
|
|
it 'returns block result and execution duration' do
|
|
allow(Process).to receive(:clock_gettime).and_return(1, 3)
|
|
|
|
result, duration = described_class.measure_duration { 42 }
|
|
|
|
expect(result).to eq(42)
|
|
expect(duration).to eq(2)
|
|
end
|
|
end
|
|
|
|
describe '#with_finished_at' do
|
|
it 'adds a timestamp to the hash yielded by the block' do
|
|
freeze_time do
|
|
result = described_class.with_finished_at(:current_time) { { a: 1 } }
|
|
|
|
expect(result).to eq(a: 1, current_time: Time.current)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#track_usage_event' do
|
|
let(:value) { '9f302fea-f828-4ca9-aef4-e10bd723c0b3' }
|
|
let(:event_name) { 'incident_management_alert_status_changed' }
|
|
let(:unknown_event) { 'unknown' }
|
|
|
|
it 'tracks redis hll event' do
|
|
expect(Gitlab::UsageDataCounters::HLLRedisCounter).to receive(:track_event).with(event_name, values: value)
|
|
|
|
described_class.track_usage_event(event_name, value)
|
|
end
|
|
|
|
it 'raise an error for unknown event' do
|
|
expect { described_class.track_usage_event(unknown_event, value) }.to raise_error(Gitlab::UsageDataCounters::HLLRedisCounter::UnknownEvent)
|
|
end
|
|
end
|
|
|
|
describe 'min/max' do
|
|
let(:model) { double(:relation) }
|
|
|
|
it 'returns min from the model' do
|
|
allow(model).to receive(:minimum).and_return(2)
|
|
allow(model).to receive(:name).and_return('sample_min_model')
|
|
|
|
expect(described_class.minimum_id(model)).to eq(2)
|
|
end
|
|
|
|
it 'returns max from the model' do
|
|
allow(model).to receive(:maximum).and_return(100)
|
|
allow(model).to receive(:name).and_return('sample_max_model')
|
|
|
|
expect(described_class.maximum_id(model)).to eq(100)
|
|
end
|
|
end
|
|
end
|