quiz_api_client 4.2.0 → 4.4.0

data/spec/quiz_api_client_spec.rb

@@ -0,0 +1,124 @@
+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 '#courses_service' do
+      it 'creates the service' do
+        expect(QuizApiClient::Services::CoursesService).to receive(:new).with(subject.config)
+        subject.courses_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/courses_service_spec.rb

@@ -0,0 +1,59 @@
+describe QuizApiClient::Services::CoursesService 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) do
+      {
+        title: 'foo',
+        canvas_id: 2,
+        is_blueprint: true
+      }
+    end
+
+    let(:response) do
+      {
+        'id' => '4',
+        'title' => 'foo',
+        'canvas_id' => '2',
+        'is_blueprint' => true,
+        'created_at' => '2022-06-22T18:59:27.577Z',
+        'updated_at' => '2022-06-22T18:59:27.577Z'
+      }
+    end
+
+    let(:expected_url) { "https://#{host}/api/courses" }
+
+    before do
+      stub_request(:post, expected_url)
+        .with(body: { course: params }.to_json)
+        .to_return(
+          status: 201,
+          body: response.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+    end
+
+    it 'posts to the correct endpoint and returns the response' do
+      expect(
+        subject.create(params: params, token: 'token').parsed_response
+      ).to eq(response)
+    end
+  end
+
+  describe '#destroy' do
+    let(:params) { { canvas_id: 1 } }
+    let(:expected_url) { "https://#{host}/api/courses/1" }
+
+    before do
+      stub_request(:delete, expected_url).to_return(status: 204)
+    end
+
+    it 'deletes to the correct endpoint and returns the response' do
+      response = subject.destroy(params: params, token: 'token')
+      expect(response.code).to eq 204
+      expect(response.body).to be_nil
+    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

data/spec/services/quiz_analyses_service_spec.rb

@@ -0,0 +1,44 @@
+describe QuizApiClient::Services::QuizAnalysesService 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' } }
+    let(:expected_url) do
+      "https://#{host}/api/quizzes/#{params[:quiz_id]}/stats/quiz_analysis"
+    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 quiz_api/api/quizzes 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.get(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/quiz_clone_job_service_spec.rb

@@ -0,0 +1,41 @@
+describe QuizApiClient::Services::QuizCloneJobService do
+  let(:host) { 'api.host' }
+  let(:config) { QuizApiClient::Config.new { |c| c.host = host } }
+  let(:subject) { described_class.new(config) }
+
+  describe '#show' do
+    let(:expected_url) { "https://#{host}/api/quiz_clone_jobs/#{params[:id]}" }
+    let(:params) { { id: 1 } }
+    let(:stubbed_response) { { 'id' => 1, 'original_quiz_id' => 666, 'status' => 'completed' } }
+
+    context 'on success' do
+      before do
+        stub_request(:get, expected_url)
+          .to_return(
+            status: 200,
+            body: stubbed_response.to_json,
+            headers: { 'Content-Type' => 'application/json' }
+          )
+      end
+
+      it 'gets from /api/quiz_clone_jobs/:id' do
+        result = subject.show(params: params, token: 'token')
+        expect(result.parsed_response).to eql(stubbed_response)
+      end
+    end
+
+    context 'on failure' do
+      let(:status_code) { 401 }
+
+      before do
+        stub_request(:get, expected_url)
+          .to_return(status: status_code)
+      end
+
+      it 'returns a response with the correct code' do
+        response = subject.show(params: params, token: 'token')
+        expect(response.code).to eq(status_code)
+      end
+    end
+  end
+end