debian-mirror-gitlab/spec/services/grafana/proxy_service_spec.rb
2020-05-24 23:13:21 +05:30

139 lines
3.8 KiB
Ruby

# frozen_string_literal: true
require 'spec_helper'
describe Grafana::ProxyService do
include ReactiveCachingHelpers
let_it_be(:project) { create(:project) }
let_it_be(:grafana_integration) { create(:grafana_integration, project: project) }
let(:proxy_path) { 'api/v1/query_range' }
let(:datasource_id) { '1' }
let(:query_params) do
{
'query' => 'rate(relevant_metric)',
'start' => '1570441248',
'end' => '1570444848',
'step' => '900'
}
end
let(:cache_params) { [project.id, datasource_id, proxy_path, query_params] }
let(:service) do
described_class.new(project, datasource_id, proxy_path, query_params)
end
shared_examples_for 'initializes an instance' do
it 'initializes an instance of ProxyService class' do
expect(subject).to be_an_instance_of(described_class)
expect(subject.project).to eq(project)
expect(subject.datasource_id).to eq('1')
expect(subject.proxy_path).to eq('api/v1/query_range')
expect(subject.query_params).to eq(query_params)
end
end
describe '.from_cache' do
subject { described_class.from_cache(*cache_params) }
it_behaves_like 'initializes an instance'
end
describe '#initialize' do
subject { service }
it_behaves_like 'initializes an instance'
end
describe '#execute' do
subject(:result) { service.execute }
context 'when grafana integration is not configured' do
before do
allow(project).to receive(:grafana_integration).and_return(nil)
end
it 'returns error' do
expect(result).to eq(
status: :error,
message: 'Proxy support for this API is not available currently'
)
end
end
context 'with caching', :use_clean_rails_memory_store_caching do
context 'when value not present in cache' do
it 'returns nil' do
expect(ExternalServiceReactiveCachingWorker)
.to receive(:perform_async)
.with(service.class, service.id, *cache_params)
expect(result).to eq(nil)
end
end
context 'when value present in cache' do
let(:return_value) { { 'http_status' => 200, 'body' => 'body' } }
before do
stub_reactive_cache(service, return_value, cache_params)
end
it 'returns cached value' do
expect(ReactiveCachingWorker)
.not_to receive(:perform_async)
.with(service.class, service.id, *cache_params)
expect(result[:http_status]).to eq(return_value[:http_status])
expect(result[:body]).to eq(return_value[:body])
end
end
end
context 'call prometheus api' do
let(:client) { service.send(:client) }
before do
synchronous_reactive_cache(service)
end
context 'connection to grafana datasource succeeds' do
let(:response) { instance_double(Gitlab::HTTP::Response) }
let(:status_code) { 400 }
let(:body) { 'body' }
before do
allow(client).to receive(:proxy_datasource).and_return(response)
allow(response).to receive(:code).and_return(status_code)
allow(response).to receive(:body).and_return(body)
end
it 'returns the http status code and body from prometheus' do
expect(result).to eq(
http_status: status_code,
body: body,
status: :success
)
end
end
context 'connection to grafana datasource fails' do
before do
allow(client).to receive(:proxy_datasource)
.and_raise(Grafana::Client::Error, 'Network connection error')
end
it 'returns error' do
expect(result).to eq(
status: :error,
message: 'Network connection error',
http_status: :service_unavailable
)
end
end
end
end
end