240 lines
7.4 KiB
Ruby
240 lines
7.4 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'spec_helper'
|
|
|
|
RSpec.describe Prometheus::ProxyService do
|
|
include ReactiveCachingHelpers
|
|
|
|
let_it_be(:project) { create(:project) }
|
|
let_it_be(:environment) { create(:environment, project: project) }
|
|
|
|
describe 'configuration' do
|
|
it 'ReactiveCaching refresh is not needed' do
|
|
expect(described_class.reactive_cache_refresh_interval).to be > described_class.reactive_cache_lifetime
|
|
end
|
|
end
|
|
|
|
describe '#initialize' do
|
|
let(:params) { ActionController::Parameters.new(query: '1').permit! }
|
|
|
|
it 'initializes attributes' do
|
|
result = described_class.new(environment, 'GET', 'query', params)
|
|
|
|
expect(result.proxyable).to eq(environment)
|
|
expect(result.method).to eq('GET')
|
|
expect(result.path).to eq('query')
|
|
expect(result.params).to eq('query' => '1')
|
|
end
|
|
|
|
it 'converts ActionController::Parameters into hash' do
|
|
result = described_class.new(environment, 'GET', 'query', params)
|
|
|
|
expect(result.params).to be_an_instance_of(Hash)
|
|
end
|
|
|
|
context 'with unknown params' do
|
|
let(:params) { ActionController::Parameters.new(query: '1', other_param: 'val').permit! }
|
|
|
|
it 'filters unknown params' do
|
|
result = described_class.new(environment, 'GET', 'query', params)
|
|
|
|
expect(result.params).to eq('query' => '1')
|
|
end
|
|
end
|
|
|
|
context 'with series method' do
|
|
let(:params) do
|
|
ActionController::Parameters.new(
|
|
match: ['1'],
|
|
start: "2020-06-11T10:15:51Z",
|
|
end: "2020-06-11T11:16:06Z",
|
|
unknown_param: 'val'
|
|
).permit!
|
|
end
|
|
|
|
it 'allows match, start and end parameters' do
|
|
result = described_class.new(environment, 'GET', 'series', params)
|
|
|
|
expect(result.params).to eq(
|
|
'match' => ['1'],
|
|
'start' => "2020-06-11T10:15:51Z",
|
|
'end' => "2020-06-11T11:16:06Z"
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#execute' do
|
|
let(:prometheus_adapter) { instance_double(::Integrations::Prometheus) }
|
|
let(:params) { ActionController::Parameters.new(query: '1').permit! }
|
|
|
|
subject { described_class.new(environment, 'GET', 'query', params) }
|
|
|
|
context 'when prometheus_adapter is nil' do
|
|
before do
|
|
allow(environment).to receive(:prometheus_adapter).and_return(nil)
|
|
end
|
|
|
|
it 'returns error' do
|
|
expect(subject.execute).to eq(
|
|
status: :error,
|
|
message: 'No prometheus server found',
|
|
http_status: :service_unavailable
|
|
)
|
|
end
|
|
end
|
|
|
|
context 'when prometheus_adapter cannot query' do
|
|
before do
|
|
allow(environment).to receive(:prometheus_adapter).and_return(prometheus_adapter)
|
|
allow(prometheus_adapter).to receive(:can_query?).and_return(false)
|
|
end
|
|
|
|
it 'returns error' do
|
|
expect(subject.execute).to eq(
|
|
status: :error,
|
|
message: 'No prometheus server found',
|
|
http_status: :service_unavailable
|
|
)
|
|
end
|
|
end
|
|
|
|
context 'cannot proxy' do
|
|
subject { described_class.new(environment, 'POST', 'garbage', params) }
|
|
|
|
it 'returns error' do
|
|
expect(subject.execute).to eq(
|
|
message: 'Proxy support for this API is not available currently',
|
|
status: :error
|
|
)
|
|
end
|
|
end
|
|
|
|
context 'with caching', :use_clean_rails_memory_store_caching do
|
|
let(:return_value) { { 'http_status' => 200, 'body' => 'body' } }
|
|
|
|
let(:opts) do
|
|
[environment.class.name, environment.id, 'GET', 'query', { 'query' => '1' }]
|
|
end
|
|
|
|
before do
|
|
allow(environment).to receive(:prometheus_adapter)
|
|
.and_return(prometheus_adapter)
|
|
allow(prometheus_adapter).to receive(:can_query?).and_return(true)
|
|
end
|
|
|
|
context 'when value present in cache' do
|
|
before do
|
|
stub_reactive_cache(subject, return_value, opts)
|
|
end
|
|
|
|
it 'returns cached value' do
|
|
result = subject.execute
|
|
|
|
expect(result[:http_status]).to eq(return_value[:http_status])
|
|
expect(result[:body]).to eq(return_value[:body])
|
|
end
|
|
end
|
|
|
|
context 'when value not present in cache' do
|
|
it 'returns nil' do
|
|
expect(ExternalServiceReactiveCachingWorker)
|
|
.to receive(:perform_async)
|
|
.with(subject.class, subject.id, *opts)
|
|
|
|
result = subject.execute
|
|
|
|
expect(result).to eq(nil)
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'call prometheus api' do
|
|
let(:prometheus_client) { instance_double(Gitlab::PrometheusClient) }
|
|
|
|
before do
|
|
synchronous_reactive_cache(subject)
|
|
|
|
allow(environment).to receive(:prometheus_adapter)
|
|
.and_return(prometheus_adapter)
|
|
allow(prometheus_adapter).to receive(:can_query?).and_return(true)
|
|
allow(prometheus_adapter).to receive(:prometheus_client)
|
|
.and_return(prometheus_client)
|
|
end
|
|
|
|
context 'connection to prometheus server succeeds' do
|
|
let(:rest_client_response) { instance_double(RestClient::Response) }
|
|
let(:prometheus_http_status_code) { 400 }
|
|
|
|
let(:response_body) do
|
|
'{"status":"error","errorType":"bad_data","error":"parse error at char 1: no expression found in input"}'
|
|
end
|
|
|
|
before do
|
|
allow(prometheus_client).to receive(:proxy).and_return(rest_client_response)
|
|
|
|
allow(rest_client_response).to receive(:code)
|
|
.and_return(prometheus_http_status_code)
|
|
allow(rest_client_response).to receive(:body).and_return(response_body)
|
|
end
|
|
|
|
it 'returns the http status code and body from prometheus' do
|
|
expect(subject.execute).to eq(
|
|
http_status: prometheus_http_status_code,
|
|
body: response_body,
|
|
status: :success
|
|
)
|
|
end
|
|
end
|
|
|
|
context 'connection to prometheus server fails' do
|
|
context 'prometheus client raises Gitlab::PrometheusClient::Error' do
|
|
before do
|
|
allow(prometheus_client).to receive(:proxy)
|
|
.and_raise(Gitlab::PrometheusClient::Error, 'Network connection error')
|
|
end
|
|
|
|
it 'returns error' do
|
|
expect(subject.execute).to eq(
|
|
status: :error,
|
|
message: 'Network connection error',
|
|
http_status: :service_unavailable
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'with series API' do
|
|
let(:rest_client_response) { instance_double(RestClient::Response, code: 200, body: '') }
|
|
|
|
let(:params) do
|
|
ActionController::Parameters.new(match: ['1'], start: 1.hour.ago.rfc3339, end: Time.current.rfc3339).permit!
|
|
end
|
|
|
|
subject { described_class.new(environment, 'GET', 'series', params) }
|
|
|
|
it 'calls PrometheusClient with given parameters' do
|
|
expect(prometheus_client).to receive(:proxy)
|
|
.with('series', params.to_h)
|
|
.and_return(rest_client_response)
|
|
|
|
subject.execute
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '.from_cache' do
|
|
it 'initializes an instance of ProxyService class' do
|
|
result = described_class.from_cache(
|
|
environment.class.name, environment.id, 'GET', 'query', { 'query' => '1' }
|
|
)
|
|
|
|
expect(result).to be_an_instance_of(described_class)
|
|
expect(result.proxyable).to eq(environment)
|
|
expect(result.method).to eq('GET')
|
|
expect(result.path).to eq('query')
|
|
expect(result.params).to eq('query' => '1')
|
|
end
|
|
end
|
|
end
|