mirror of
https://github.com/scinote-eln/scinote-web.git
synced 2024-11-16 22:25:30 +08:00
227 lines
6.6 KiB
Ruby
227 lines
6.6 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'rails_helper'
|
|
|
|
describe ExternalProtocolsController, type: :controller do
|
|
login_user
|
|
|
|
let(:user) { subject.current_user }
|
|
let(:team) { create :team, created_by: user }
|
|
|
|
describe 'GET index' do
|
|
let(:params) do
|
|
{
|
|
team_id: team.id,
|
|
key: 'search_string',
|
|
protocol_source: 'protocolsio/v3',
|
|
page_id: 2,
|
|
page_size: 50,
|
|
order_field: 'activity',
|
|
order_dir: 'desc'
|
|
}
|
|
end
|
|
|
|
let(:action) { get :index, params: params }
|
|
|
|
let(:valid_search_response) do
|
|
{
|
|
protocols: [],
|
|
pagination: {
|
|
current_page: 2,
|
|
total_pages: 6,
|
|
page_size: 10
|
|
}
|
|
}
|
|
end
|
|
|
|
before do
|
|
service = double('success_service')
|
|
allow(service).to(receive(:succeed?)).and_return(true)
|
|
allow(service).to(receive(:protocols_list)).and_return(valid_search_response)
|
|
|
|
allow_any_instance_of(ProtocolImporters::SearchProtocolsService).to(receive(:call)).and_return(service)
|
|
end
|
|
|
|
it 'returns JSON, 200 response when protocol parsing was valid' do
|
|
action
|
|
expect(response).to have_http_status(:success)
|
|
expect(response.media_type).to eq 'application/json'
|
|
end
|
|
|
|
it 'contains html key in the response' do
|
|
action
|
|
expect(JSON.parse(response.body)).to have_key('html')
|
|
end
|
|
|
|
it 'contains page_id in the response' do
|
|
action
|
|
expect(JSON.parse(response.body)['page_id']).to eq 2
|
|
end
|
|
end
|
|
|
|
describe 'GET show' do
|
|
let(:params) do
|
|
{
|
|
team_id: team.id,
|
|
protocol_source: 'protocolsio/v3',
|
|
protocol_id: 'protocolsio_uri'
|
|
}
|
|
end
|
|
|
|
let(:action) { get :show, params: params }
|
|
|
|
let(:html_preview) { double('html_preview', body: '<html></html>') }
|
|
|
|
before do
|
|
allow(html_preview).to(receive(:as_json).and_return('<html></html>'))
|
|
allow(html_preview).to(receive_message_chain(:request, :last_uri, :to_s).and_return('http://www.protocols.io/test_protocol'))
|
|
end
|
|
|
|
it 'returns JSON, 200 response when preview was successfully returned' do
|
|
allow_any_instance_of(ProtocolImporters::ProtocolsIo::V3::ApiClient)
|
|
.to(receive(:protocol_html_preview)).and_return(html_preview)
|
|
|
|
# Call action
|
|
action
|
|
expect(response).to have_http_status(:success)
|
|
expect(response.media_type).to eq 'application/json'
|
|
end
|
|
|
|
it 'should return html preview in the JSON' do
|
|
allow_any_instance_of(ProtocolImporters::ProtocolsIo::V3::ApiClient)
|
|
.to(receive(:protocol_html_preview)).and_return(html_preview)
|
|
|
|
# Call action
|
|
action
|
|
expect(JSON.parse(response.body)['html']).to eq('<html></html>')
|
|
end
|
|
|
|
it 'returns error JSON and 400 response when something went wrong' do
|
|
allow_any_instance_of(ProtocolImporters::ProtocolsIo::V3::ApiClient)
|
|
.to(receive(:protocol_html_preview)).and_raise(StandardError)
|
|
|
|
# Call action
|
|
action
|
|
expect(response).to have_http_status(:bad_request)
|
|
expect(JSON.parse(response.body)).to have_key('errors')
|
|
end
|
|
end
|
|
|
|
describe 'GET new' do
|
|
let(:params) do
|
|
{
|
|
team_id: team.id,
|
|
protocol_source: 'protocolsio/v3',
|
|
page_id: 1,
|
|
page_size: 10,
|
|
order_field: 'activity',
|
|
order_dir: 'desc'
|
|
}
|
|
end
|
|
|
|
let(:action) { get :new, params: params }
|
|
|
|
context 'successful response' do
|
|
let(:protocol) { create :protocol }
|
|
|
|
before do
|
|
service = double('success_service')
|
|
allow(service).to(receive(:succeed?)).and_return(true)
|
|
allow(service).to(receive(:built_protocol)).and_return(protocol)
|
|
allow(service).to(receive(:serialized_steps)).and_return({}.to_s)
|
|
allow(service).to(receive(:steps_assets)).and_return([])
|
|
|
|
allow_any_instance_of(ProtocolImporters::BuildProtocolFromClientService)
|
|
.to(receive(:call)).and_return(service)
|
|
end
|
|
|
|
it 'returns JSON, 200 response when protocol parsing was valid' do
|
|
action
|
|
expect(response).to have_http_status(:success)
|
|
expect(response.media_type).to eq 'application/json'
|
|
end
|
|
|
|
it 'should return html form in the JSON' do
|
|
action
|
|
expect(JSON.parse(response.body)).to have_key('html')
|
|
end
|
|
end
|
|
|
|
it 'returns JSON, 400 response when protocol parsing was invalid' do
|
|
# Setup double
|
|
service = double('failed_service')
|
|
allow(service).to(receive(:succeed?)).and_return(false)
|
|
allow(service).to(receive(:errors)).and_return({})
|
|
|
|
allow_any_instance_of(ProtocolImporters::BuildProtocolFromClientService)
|
|
.to(receive(:call)).and_return(service)
|
|
|
|
# Call action
|
|
action
|
|
expect(response).to have_http_status(:bad_request)
|
|
expect(response.media_type).to eq 'application/json'
|
|
end
|
|
end
|
|
|
|
describe 'POST create' do
|
|
context 'when user has import permissions for the team' do
|
|
let(:params) do
|
|
{
|
|
team_id: team.id,
|
|
protocol: {
|
|
name: 'name',
|
|
steps: {}.to_s
|
|
}
|
|
}
|
|
end
|
|
|
|
let(:action) { post :create, params: params }
|
|
|
|
it 'returns JSON, 200 response when protocol parsing was valid' do
|
|
# Setup double
|
|
service = double('success_service')
|
|
allow(service).to(receive(:succeed?)).and_return(true)
|
|
allow(service).to(receive(:protocol)).and_return(create(:protocol))
|
|
|
|
allow_any_instance_of(ProtocolImporters::ImportProtocolService).to(receive(:call)).and_return(service)
|
|
|
|
# Call action
|
|
action
|
|
expect(response).to have_http_status(:success)
|
|
expect(response.media_type).to eq 'application/json'
|
|
end
|
|
|
|
it 'returns JSON, 400 response when protocol parsing was invalid' do
|
|
# Setup double
|
|
service = double('success_service')
|
|
allow(service).to(receive(:succeed?)).and_return(false)
|
|
allow(service).to(receive(:errors)).and_return({})
|
|
|
|
allow_any_instance_of(ProtocolImporters::ImportProtocolService).to(receive(:call)).and_return(service)
|
|
|
|
# Call action
|
|
action
|
|
expect(response).to have_http_status(:bad_request)
|
|
expect(response.media_type).to eq 'application/json'
|
|
end
|
|
end
|
|
|
|
context 'when user has no import permissions for the team' do
|
|
let(:user_two) { create :user }
|
|
let(:team_two) { create :team, created_by: user_two }
|
|
|
|
let(:params) do
|
|
{
|
|
team_id: team_two.id,
|
|
protocol_params: {},
|
|
steps_params: {}
|
|
}
|
|
end
|
|
|
|
it 'returns 403 when trying to import to forbidden team' do
|
|
post :create, params: params
|
|
expect(response).to have_http_status(:forbidden)
|
|
end
|
|
end
|
|
end
|
|
end
|