quiz_api_client 4.2.0 → 4.2.1

data/spec/quiz_api_client/http_request/failure_spec.rb

@@ -0,0 +1,100 @@
+require 'sentry-raven'
+
+describe QuizApiClient::HttpRequest::Failure do
+  let(:config) { QuizApiClient::Config.new }
+  let(:method) { 'GET' }
+  let(:url) { 'https://something.com' }
+  let(:response_code) { 500 }
+  let(:response_body) { 'I am a response body!' }
+  let(:response) { instance_double('HTTParty::Response', code: response_code, body: response_body) }
+
+  subject { described_class.new(config) }
+
+  describe '#raise_error' do
+    it 'raises the QuizApiClient::HttpClient::RequestFailed error' do
+      expect do
+        subject.raise_error(method, url)
+      end.to raise_error(QuizApiClient::HttpClient::RequestFailed)
+    end
+
+    context 'when there is a current exception' do
+      let(:error_context) do
+        {
+          quiz_api_client: {
+            request: {
+              method: method,
+              url: url
+            }
+          }
+        }
+      end
+      let(:current_error_message) { 'standard error message' }
+      let(:current_error) { StandardError.new(current_error_message) }
+      let(:raise_error_call) { -> { subject.raise_error(method, url, current_error: current_error) } }
+
+      it 'sets the context on the error' do
+        expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed) do |error|
+          expect(error.context).to eq error_context
+        end
+      end
+
+      it 'sets the error message' do
+        expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed) do |error|
+          expect(error.message).to eq current_error_message
+        end
+      end
+
+      context 'when error_handler is set to :sentry_raven' do
+        before do
+          config.error_handler = :sentry_raven
+        end
+
+        it 'sets the Raven context to the context on the error' do
+          expect(Raven).to receive(:extra_context).with(error_context)
+          expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed)
+        end
+      end
+    end
+
+    context 'when there is a response' do
+      let(:error_context) do
+        {
+          quiz_api_client: {
+            request: {
+              method: method,
+              url: url
+            },
+            response: {
+              body: response_body,
+              code: response_code
+            }
+          }
+        }
+      end
+      let(:raise_error_call) { -> { subject.raise_error(method, url, response: response) } }
+
+      it 'sets the context on the error' do
+        expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed) do |error|
+          expect(error.context).to eq error_context
+        end
+      end
+
+      it 'sets the error message' do
+        expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed) do |error|
+          expect(error.message).to eq "#{url} responded #{response_body} (#{response_code})"
+        end
+      end
+
+      context 'when error_handler is set to :sentry_raven' do
+        before do
+          config.error_handler = :sentry_raven
+        end
+
+        it 'sets the Raven context to the context on the error' do
+          expect(Raven).to receive(:extra_context).with(error_context)
+          expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed)
+        end
+      end
+    end
+  end
+end

data/spec/quiz_api_client/http_request/metrics_spec.rb

@@ -0,0 +1,75 @@
+require 'inst_statsd'
+
+describe QuizApiClient::HttpRequest::Metrics do
+  let(:config) { QuizApiClient::Config.new }
+  let(:method) { 'GET' }
+  let(:url) { 'https://something.com' }
+  let(:code) { 200 }
+
+  subject { described_class.new(config, method, url, code) }
+
+  describe '#increment' do
+    it 'does nothing when the metrics handler is nil' do
+      allow(config).to receive(:metrics_handler).and_return(nil)
+      expect(InstStatsd::Statsd).to receive(:increment).never
+
+      subject.increment
+    end
+
+    it 'does nothing when the metrics namespace is nil' do
+      allow(config).to receive(:metrics_namespace).and_return(nil)
+      expect(InstStatsd::Statsd).to receive(:increment).never
+
+      subject.increment
+    end
+
+    it 'calls the #increment method for InstStatsd' do
+      config.setup_metrics(:inststatsd, 'fake-namespace')
+      expect(InstStatsd::Statsd).to receive(:increment).with(
+        'fake-namespace.quiz_api_client.request.count',
+        tags: {
+          method: method,
+          status: code,
+          url: url
+        }
+      )
+
+      subject.increment
+    end
+  end
+
+  describe '#duration' do
+    let(:duration_in_secs) { 10 }
+    let(:start_time) { Time.parse('2021-11-09 15:11:48 -0500') }
+    let(:end_time) { start_time + duration_in_secs }
+
+    it 'does nothing when the metrics handler is nil' do
+      allow(config).to receive(:metrics_handler).and_return(nil)
+      expect(InstStatsd::Statsd).to receive(:timing).never
+
+      subject.duration(start_time, end_time)
+    end
+
+    it 'does nothing when the metrics namespace is nil' do
+      allow(config).to receive(:metrics_namespace).and_return(nil)
+      expect(InstStatsd::Statsd).to receive(:timing).never
+
+      subject.duration(start_time, end_time)
+    end
+
+    it 'calls the #timing method for InstStatsd' do
+      config.setup_metrics(:inststatsd, 'fake-namespace')
+      expect(InstStatsd::Statsd).to receive(:timing).with(
+        'fake-namespace.quiz_api_client.request.duration_ms',
+        duration_in_secs * 1_000,
+        tags: {
+          method: method,
+          status: code,
+          url: url
+        }
+      )
+
+      subject.duration(start_time, end_time)
+    end
+  end
+end

data/spec/quiz_api_client_spec.rb

@@ -0,0 +1,117 @@
+describe QuizApiClient do
+  it 'has a version number' do
+    expect(QuizApiClient::VERSION).not_to be nil
+  end
+
+  context 'service helper methods' do
+    let(:host) { 'api.host' }
+    let(:shared_secret) { 'secret' }
+    let(:protocol) { 'http' }
+    let(:consumer_key) { 'some consumer_key' }
+    let(:consumer_request_id) { 'guid_value' }
+    let(:subject) do
+      QuizApiClient::Client.new(
+        consumer_key: consumer_key,
+        consumer_request_id: consumer_request_id,
+        host: host,
+        shared_secret: shared_secret,
+        protocol: protocol
+      )
+    end
+
+    describe '#config' do
+      it 'should populate the values' do
+        config = subject.config
+        expect(config.consumer_key).to eq consumer_key
+        expect(config.consumer_request_id).to eq consumer_request_id
+        expect(config.host).to eq host
+        expect(config.shared_secret).to eq shared_secret
+        expect(config.protocol).to eq protocol
+      end
+
+      it 'should yield the config on instantiation' do
+        client = QuizApiClient::Client.new(
+          consumer_key: consumer_key,
+          consumer_request_id: consumer_request_id,
+          host: host,
+          shared_secret: shared_secret,
+          protocol: protocol
+        ) do |config|
+          config.host = 'my.hosting'
+        end
+
+        expect(client.config.host).to eq 'my.hosting'
+      end
+    end
+
+    describe '#jwt_service' do
+      it 'should create the service' do
+        expect(QuizApiClient::Services::JwtService).to receive(:new).with(subject.config)
+        subject.jwt_service
+      end
+    end
+
+    describe '#quizzes_service' do
+      it 'should create the service' do
+        expect(QuizApiClient::Services::QuizzesService).to receive(:new).with(subject.config)
+        subject.quizzes_service
+      end
+    end
+
+    describe '#quiz_session_service' do
+      it 'should create the service' do
+        expect(QuizApiClient::Services::QuizSessionService).to receive(:new).with(subject.config)
+        subject.quiz_session_service
+      end
+    end
+
+    describe '#quiz_sessions_service' do
+      it 'should create the service' do
+        expect(QuizApiClient::Services::QuizSessionsService).to receive(:new).with(subject.config)
+        subject.quiz_sessions_service
+      end
+    end
+
+    describe '#qti_imports_service' do
+      it 'should create the service' do
+        expect(QuizApiClient::Services::QtiImportsService).to receive(:new).with(subject.config)
+        subject.qti_imports_service
+      end
+    end
+
+    describe '#item_analyses_service' do
+      it 'should create the service' do
+        expect(QuizApiClient::Services::ItemAnalysesService).to receive(:new).with(subject.config)
+        subject.item_analyses_service
+      end
+    end
+
+    describe '#quiz_analyses_service' do
+      it 'should create the service' do
+        expect(QuizApiClient::Services::QuizAnalysesService).to receive(:new).with(subject.config)
+        subject.quiz_analyses_service
+      end
+    end
+
+    describe '#quiz_session_events_service' do
+      it 'should create the service' do
+        expect(QuizApiClient::Services::QuizSessionEventsService).to receive(:new).with(subject.config)
+        subject.quiz_session_events_service
+      end
+    end
+
+    describe '#items_service' do
+      it 'should create the service' do
+        expect(QuizApiClient::Services::ItemsService).to receive(:new).with(subject.config)
+        subject.items_service
+      end
+    end
+
+    describe '#interaction_types_service' do
+      it 'should create the service' do
+        expect(QuizApiClient::Services::InteractionTypesService).to receive(:new).with(subject.config)
+        subject.interaction_types_service
+      end
+    end
+  end
+end

data/spec/services/base_api_service_spec.rb

@@ -0,0 +1,50 @@
+describe QuizApiClient::Services::BaseApiService do
+  let(:consumer_key) { 'consumer key' }
+  let(:host) { 'api.host' }
+  let(:shared_secret) { 'secret' }
+  let(:protocol) { 'http' }
+  let(:service_class) do
+    Class.new(QuizApiClient::Services::BaseApiService) do
+      def test_uri
+        uri
+      end
+    end
+  end
+  let(:service) do
+    service_class.new(QuizApiClient::Config.new do |c|
+      c.consumer_key = consumer_key
+      c.host = host
+      c.shared_secret = shared_secret
+      c.protocol = protocol
+    end)
+  end
+
+  def decode_token(token, secret)
+    JWT.decode(
+      token, secret, true,
+      algorithm: QuizApiClient::Services::JwtService::HASHING_ALGORITHM
+    )
+  end
+
+  describe '#uri' do
+    it 'returns full URI' do
+      expect(service.test_uri).to eq 'http://api.host'
+    end
+
+    context 'with https protocol' do
+      let(:protocol) { 'https' }
+
+      it 'uses specified protocol' do
+        expect(service.test_uri).to eq 'https://api.host'
+      end
+    end
+
+    context 'with port specified in host' do
+      let(:host) { 'api.host:8443' }
+
+      it 'includes port in URI' do
+        expect(service.test_uri).to eq 'http://api.host:8443'
+      end
+    end
+  end
+end

data/spec/services/interaction_types_service_spec.rb

@@ -0,0 +1,25 @@
+describe QuizApiClient::Services::InteractionTypesService do
+  let(:host) { 'api.host' }
+  let(:config) { QuizApiClient::Config.new { |c| c.host = host } }
+  let(:subject) { described_class.new(config) }
+
+  describe '#list' do
+    let(:status_code) { 200 }
+    let(:expected_url) { "https://#{host}/api/interaction_types" }
+    let(:stubbed_response) { [{ 'name' => 'Type One', 'id' => 1 }] }
+
+    before do
+      stub_request(:get, expected_url)
+        .to_return(
+          status: status_code,
+          body: stubbed_response.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+    end
+
+    it 'gets from quiz_api/api/interaction_types and returns the response' do
+      result = subject.list(token: 'token')
+      expect(result.parsed_response).to eql(stubbed_response)
+    end
+  end
+end

data/spec/services/item_analyses_service_spec.rb

@@ -0,0 +1,76 @@
+describe QuizApiClient::Services::ItemAnalysesService do
+  let(:host) { 'api.host' }
+  let(:config) { QuizApiClient::Config.new { |c| c.host = host } }
+  let(:subject) { described_class.new(config) }
+
+  describe '#list' do
+    let(:params) { { quiz_id: 1, id: 7 } }
+    let(:stubbed_response) { { 'id' => '1' } }
+    let(:expected_url) do
+      "https://#{host}/api/quizzes/#{params[:quiz_id]}/stats/item_analyses"
+    end
+    let(:expected_body) { '' }
+    let(:status_code) { 200 }
+
+    before do
+      stub_request(:get, expected_url)
+        .with(body: expected_body)
+        .to_return(
+          status: status_code,
+          body: stubbed_response.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+    end
+
+    it 'posts to /api/quizzes/1/stats/item_analyses and returns the response' do
+      result = subject.list(params: params, token: 'token')
+      expect(result.parsed_response).to eql(stubbed_response)
+    end
+
+    it 'raises an error when no quiz_id is specified' do
+      params = {}
+      expect do
+        subject.list(params: params, token: 'token')
+      end.to raise_error 'Quiz Id Required'
+    end
+  end
+
+  describe '#get' do
+    let(:params) { { quiz_id: 1, id: 7 } }
+    let(:stubbed_response) { { 'id' => '1' } }
+    let(:expected_url) do
+      "https://#{host}/api/quizzes/#{params[:quiz_id]}/stats/item_analyses/#{params[:id]}"
+    end
+    let(:expected_body) { '' }
+    let(:status_code) { 200 }
+
+    before do
+      stub_request(:get, expected_url)
+        .with(body: expected_body)
+        .to_return(
+          status: status_code,
+          body: stubbed_response.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+    end
+
+    it 'posts to /api/quizzes/1/stats/item_analyses/7 and returns the response' do
+      result = subject.get(params: params, token: 'token')
+      expect(result.parsed_response).to eql(stubbed_response)
+    end
+
+    it 'raises an error when no quiz_id is specified' do
+      params = {}
+      expect do
+        subject.list(params: params, token: 'token')
+      end.to raise_error 'Quiz Id Required'
+    end
+
+    context 'response' do
+      it 'returns the response with the correct status code' do
+        response = subject.get(params: params, token: 'token')
+        expect(response.code).to eq(status_code)
+      end
+    end
+  end
+end

data/spec/services/items_service_spec.rb

@@ -0,0 +1,56 @@
+describe QuizApiClient::Services::ItemsService do
+  let(:host) { 'api.host' }
+  let(:config) { QuizApiClient::Config.new { |c| c.host = host } }
+  let(:subject) { described_class.new(config) }
+
+  describe '#list' do
+    let(:params) { { quiz_id: 1 } }
+    let(:stubbed_response) { { 'id' => 1, 'item' => { 'id' => 1 } } }
+    let(:expected_url) { "https://#{host}/api/quizzes/#{params[:quiz_id]}/items" }
+    let(:status_code) { 200 }
+
+    before do
+      stub_request(:get, expected_url)
+        .to_return(
+          status: status_code,
+          body: stubbed_response.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+    end
+
+    it 'list from quiz_api/api/quizzes/{id}/items and returns the response' do
+      result = subject.list(params: params, token: 'token')
+      expect(result.parsed_response).to eql(stubbed_response)
+    end
+  end
+
+  describe '#create' do
+    let(:params) do
+      {
+        quiz_id: 1,
+        item_body: 'item body',
+        scoring_data: { value: 'value' },
+        scoring_algorithm: 'Equivalence',
+        interaction_type_id: 'choice',
+        user_response_type: 'response type'
+      }
+    end
+    let(:stubbed_response) { { 'id' => 1, 'item' => { 'id' => 1 } } }
+    let(:expected_url) { "https://#{host}/api/quizzes/#{params[:quiz_id]}/items" }
+    let(:status_code) { 201 }
+
+    before do
+      stub_request(:post, expected_url)
+        .to_return(
+          status: status_code,
+          body: stubbed_response.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+    end
+
+    it 'posts to quiz_api/api/quizzes/{id}/items and returns the response' do
+      result = subject.create(params: params, token: 'token')
+      expect(result.parsed_response).to eql(stubbed_response)
+    end
+  end
+end

data/spec/services/jwt_service_spec.rb

@@ -0,0 +1,66 @@
+describe QuizApiClient::Services::JwtService do
+  let(:host) { 'test.host' }
+  let(:shared_secret) { 'secret' }
+  let(:consumer_key) { 'some consumer_key' }
+
+  let(:config) do
+    QuizApiClient::Config.new do |c|
+      c.shared_secret = shared_secret
+      c.host = host
+      c.consumer_key = consumer_key
+    end
+  end
+
+  subject do
+    QuizApiClient::Services::JwtService.new(config)
+  end
+
+  describe 'grant_permission' do
+    it 'generates a JWT using the shared_secret' do
+      jwt = subject.grant_permission(scope: 'quiz.create')
+
+      payload, header = JWT.decode(jwt, shared_secret, true, algorithm: 'HS512')
+
+      expect(payload['host']).to eq(host)
+      expect(payload['scope']).to eq('quiz.create')
+      expect(payload['consumer_key']).to eq(consumer_key)
+      expect(payload).not_to have_key('resource_id')
+      expect(payload).not_to have_key('user')
+      expect(payload).to have_key('exp')
+      expect(header['alg']).to eq('HS512')
+    end
+
+    it 'includes user uuid in payload when provided' do
+      jwt = subject.grant_permission(scope: 'quiz.create', uuid: '123')
+
+      payload = JWT.decode(jwt, shared_secret, true, algorithm: 'HS512').first
+
+      expect(payload['user']).to eq('uuid' => '123')
+    end
+
+    it 'merges in other provided user context' do
+      jwt = subject.grant_permission(scope: 'quiz.create', uuid: '123', user: { email: 'test@example.com' })
+
+      payload = JWT.decode(jwt, shared_secret, true, algorithm: 'HS512').first
+
+      expect(payload['user']).to eq('uuid' => '123', 'email' => 'test@example.com')
+    end
+
+    it 'allows arbitrary additional params' do
+      jwt = subject.grant_permission(scope: 'quiz.create', foo: 'bar', monkey: 'do')
+      payload = JWT.decode(jwt, shared_secret, true, algorithm: 'HS512').first
+      expect(payload['foo']).to eq 'bar'
+      expect(payload['monkey']).to eq 'do'
+    end
+
+    context 'with port in host' do
+      let(:host) { 'test.host:8443' }
+
+      it 'leaves port out of payload host' do
+        jwt = subject.grant_permission scope: 'quiz.build'
+        payload, _header = JWT.decode(jwt, shared_secret, true, algorithm: 'HS512')
+        expect(payload['host']).to eq 'test.host'
+      end
+    end
+  end
+end

data/spec/services/qti_imports_service_spec.rb

@@ -0,0 +1,114 @@
+describe QuizApiClient::Services::QtiImportsService do
+  let(:host) { 'api.host' }
+  let(:config) { QuizApiClient::Config.new { |c| c.host = host } }
+  let(:subject) { described_class.new(config) }
+
+  describe '#create' do
+    let(:params) { { url: 'https://fake-s3-url.com', quiz_id: 1 } }
+    let(:stubbed_response) { { 'id' => '1', 'status' => 'created' } }
+    let(:expected_url) { "https://#{host}/api/quizzes/1/qti_imports" }
+    let(:expected_body) { {} }
+    let(:status_code) { 200 }
+
+    before do
+      stub_request(:post, expected_url)
+        .with(body: expected_body)
+        .to_return(
+          status: 200,
+          body: stubbed_response.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+    end
+
+    it 'posts to quiz_api/api/qti_imports and returns the response' do
+      result = subject.create(params: params, token: 'token')
+      expect(result.parsed_response).to eql(stubbed_response)
+    end
+
+    context 'response' do
+      it 'returns the response with the correct code' do
+        response = subject.create(params: params, token: 'token')
+        expect(response.code).to eq(status_code)
+      end
+    end
+
+    context 'no quiz id provided' do
+      let(:params) {}
+      it 'raises Quiz Id Required' do
+        expect do
+          subject.create(params: params, token: 'token')
+        end.to raise_error('Quiz Id Required')
+      end
+    end
+  end
+
+  describe '#banks' do
+    let(:params) { { everything: false, overwrite: false, assessment_question_banks: ['abc123'] } }
+    let(:stubbed_response) { { 'id' => '1', 'status' => 'created' } }
+    let(:expected_url) { "https://#{host}/api/qti_imports/banks" }
+    let(:expected_body) { {} }
+    let(:status_code) { 200 }
+
+    before do
+      stub_request(:post, expected_url)
+        .with(body: expected_body)
+        .to_return(
+          status: 200,
+          body: stubbed_response.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+    end
+
+    it 'posts to quiz_api/api/qti_imports and returns the response' do
+      result = subject.banks(params: params, token: 'token')
+      expect(result.parsed_response).to eql(stubbed_response)
+    end
+
+    context 'response' do
+      it 'returns the response with the correct code' do
+        response = subject.banks(params: params, token: 'token')
+        expect(response.code).to eq(status_code)
+      end
+    end
+  end
+
+  describe '#get_imported_consumer_settings' do
+    let(:params) { { quiz_id: 1 } }
+    let(:stubbed_response) { { 'score_to_keep' => 'highest', 'max_attempts' => '10' } }
+    let(:expected_url) { "https://#{host}/api/quizzes/1/qti_imports/imported_consumer_settings" }
+
+    let(:expected_body) { {} }
+    let(:status_code) { 200 }
+
+    before do
+      stub_request(:get, expected_url)
+        .with(body: expected_body)
+        .to_return(
+          status: 200,
+          body: stubbed_response.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+    end
+
+    it 'posts to quiz_api/api/qti_imports and returns the response' do
+      result = subject.get_imported_consumer_settings(params: params, token: 'token')
+      expect(result.parsed_response).to eql(stubbed_response)
+    end
+
+    context 'response' do
+      it 'returns the response with the correct code' do
+        response = subject.get_imported_consumer_settings(params: params, token: 'token')
+        expect(response.code).to eq(status_code)
+      end
+    end
+
+    context 'no quiz id provided' do
+      let(:params) {}
+      it 'raises Quiz Id Required' do
+        expect do
+          subject.create(params: params, token: 'token')
+        end.to raise_error('Quiz Id Required')
+      end
+    end
+  end
+end