d2l-valence 0.0.1

data/lib/d2l/valence/version.rb

@@ -0,0 +1,5 @@
+module D2L
+  module Valence
+    VERSION = '0.0.1'.freeze
+  end
+end

data/spec/d2l/valence/app_context_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe D2L::Valence::AppContext, type: :service do
+  include_context :common_context
+
+  context '.auth_url' do
+    subject { described_class.new(brightspace_host: auth_host, app_id: app_id, app_key: app_key) }
+    let(:expected_url) { "https://partners.brightspace.com/d2l/auth/api/token?x_a=#{app_id}&x_b=#{auth_key}&x_target=#{CGI.escape(callback_uri.to_s)}" }
+
+    it('will generate an authentication URL') do
+      expect(subject.auth_url(callback_uri)).to eq expected_url
+    end
+  end
+end

data/spec/d2l/valence/auth_tokens_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe D2L::Valence::AuthTokens, type: :service do
+  include_context :common_context
+
+  context '.generate' do
+    subject { described_class.new(request: request) }
+    let(:request) do
+      D2L::Valence::Request.new(
+        user_context: user_context,
+        http_method: 'GET',
+        route: '/d2l/api/lp/:version/users/whoami'
+      )
+    end
+
+    let(:signature) { "#{request.http_method}&#{CGI.unescape(request.path)}&#{subject.adjusted_timestamp}" }
+    let(:signature_by_app_key) { D2L::Valence::Encrypt.generate_from(app_key, signature) }
+    let(:signature_by_user_key) { D2L::Valence::Encrypt.generate_from(user_key, signature) }
+    let(:tokens) { subject.generate }
+
+    it 'will generate the right token values' do
+      expect(tokens[described_class::APP_ID_PARAM]).to eq app_id
+      expect(tokens[described_class::SIGNATURE_BY_APP_KEY_PARAM]).to eq signature_by_app_key
+      expect(tokens[described_class::USER_ID_PARAM]).to eq user_id
+      expect(tokens[described_class::SIGNATURE_BY_USER_KEY_PARAM]).to eq signature_by_user_key
+      expect(tokens[described_class::TIMESTAMP_PARAM]).to eq subject.adjusted_timestamp
+    end
+  end
+
+end

data/spec/d2l/valence/host_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe D2L::Valence::Host do
+  context '.initialize' do
+    let(:host) { 'www.somehost.com' }
+
+    context 'for scheme string' do
+      subject { described_class.new(scheme: 'HTTPS', host: host) }
+
+      its(:scheme) { is_expected.to eq :https }
+      its(:host) { is_expected.to eq host }
+      its(:port) { is_expected.to be_nil}
+    end
+
+    context 'for scheme symbol' do
+      subject { described_class.new(scheme: :http, host: host) }
+
+      its(:scheme) { is_expected.to eq :http }
+      its(:host) { is_expected.to eq host }
+      its(:port) { is_expected.to be_nil}
+    end
+
+    context 'for unsupported scheme' do
+      it('will raise an exception') do
+        expect { described_class.new(scheme: :sftp, host: host) }.to raise_error RuntimeError, 'sftp is an unsupported scheme. Please use either HTTP or HTTPS'
+      end
+    end
+  end
+
+  context '.to_uri' do
+    let(:host) { 'www.somehost.com' }
+
+    context 'for HTTP' do
+      subject { described_class.new(scheme: :http, host: host, port: port) }
+
+      context 'with no port' do
+        let(:port) { nil }
+
+        its('to_uri.to_s') { is_expected.to eq 'http://www.somehost.com' }
+      end
+      context 'with specific port' do
+        let(:port) { 8080 }
+
+        its('to_uri.to_s') { is_expected.to eq 'http://www.somehost.com:8080' }
+      end
+    end
+
+    context 'for HTTPS' do
+      subject { described_class.new(scheme: :https, host: host, port: port) }
+
+      context 'with no port' do
+        let(:port) { nil }
+
+        its('to_uri.to_s') { is_expected.to eq 'https://www.somehost.com' }
+      end
+      context 'with specific port' do
+        let(:port) { 4040 }
+
+        its('to_uri.to_s') { is_expected.to eq 'https://www.somehost.com:4040' }
+      end
+    end
+  end
+
+end

data/spec/d2l/valence/request/authenticated_uri_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe D2L::Valence::Request, type: :service do
+  include_context :common_context
+
+  subject do
+    described_class.new(
+      user_context: user_context,
+      http_method: http_method,
+      route: route,
+      route_params: route_params,
+      query_params: query_params
+    )
+  end
+
+  context '.authenticated_uri' do
+    context 'with no parameters' do
+      let(:http_method) { 'GET' }
+      let(:route) { '/d2l/api/lp/:version/users/whoami' }
+      let(:route_params) { {} }
+      let(:query_params) { {} }
+      let(:expected_path) { '/d2l/api/lp/1.0/users/whoami' }
+
+      its('authenticated_uri.path') { is_expected.to eq expected_path }
+      it('will include the authentication query parameters') do
+        auth_token_parameters.each { |t| expect(subject.authenticated_uri.query).to include "#{t}=" }
+      end
+    end
+
+    context 'with a specific API version' do
+      let(:api_version) { '1.1' }
+      let(:http_method) { 'GET' }
+      let(:route) { '/d2l/api/lp/:version/users/whoami' }
+      let(:route_params) { {} }
+      let(:query_params) { {} }
+      let(:expected_path) { "/d2l/api/lp/#{api_version}/users/whoami" }
+
+      its('authenticated_uri.path') { is_expected.to eq expected_path }
+    end
+
+    context 'with route parameters' do
+      let(:http_method) { 'GET' }
+      let(:route) { '/d2l/api/lp/:version/:org_unit_id/groupcategories/:groupCategoryId' }
+      let(:route_params) do
+        {
+          org_unit_id: 4,
+          groupCategoryId: 23,
+        }
+      end
+      let(:query_params) { {} }
+      let(:expected_path) { "/d2l/api/lp/#{api_version}/#{route_params[:org_unit_id]}/groupcategories/#{route_params[:groupCategoryId]}" }
+
+      its('authenticated_uri.path') { is_expected.to eq expected_path }
+      it('will include the authentication query parameters') do
+        auth_token_parameters.each { |t| expect(subject.authenticated_uri.query).to include "#{t}=" }
+      end
+    end
+
+    context 'with query parameters' do
+      let(:http_method) { 'GET' }
+      let(:route) { '/d2l/api/lp/:version/users/' }
+      let(:query_params) { {userName: 'student123'} }
+      let(:route_params) { {} }
+      let(:expected_path) { "/d2l/api/lp/1.0/users/" }
+
+      its('authenticated_uri.path') { is_expected.to eq expected_path }
+      it('will include the query params') do
+        query_params.each { |k,v| expect(subject.authenticated_uri.query).to include "#{k}=#{v}" }
+      end
+      it('will include the authentication query parameters') do
+        auth_token_parameters.each { |t| expect(subject.authenticated_uri.query).to include "#{t}=" }
+      end
+    end
+  end
+end

data/spec/d2l/valence/request/execute/invalid_time_stamp_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe D2L::Valence::Request, type: :service do
+  include_context :common_context
+
+  subject do
+    described_class.new(
+      user_context: user_context,
+      http_method: http_method,
+      route: route,
+      route_params: route_params,
+      query_params: query_params
+    )
+  end
+
+  context '.execute' do
+    let(:user_id) { ENV['D2L_USER_ID'] }
+    let(:user_key) { ENV['D2L_USER_KEY'] }
+
+    context 'with the timestamp is invalid' do
+      let(:http_method) { 'GET' }
+      let(:route) { '/d2l/api/lp/:version/users/whoami' }
+      let(:route_params) { {} }
+      let(:query_params) { {} }
+      let(:api_version) { '1.15' }
+      let(:skewed_start_time) { Time.at(1491940559) }
+      # NB: The commented line below is the needed for the regeneration of VCR cassettes
+      # let(:skewed_start_time) { Time.at(Time.now.to_i - 20000) }
+
+      context 'on second try', vcr: {cassette_name: 'request/execute/invalid_timestamp'} do
+        it 'will succeed' do
+          Timecop.travel skewed_start_time do
+            expect(subject.execute.code).to eq :INVALID_TIMESTAMP
+            expect(subject.execute.code).to eq :HTTP_200
+          end
+        end
+      end
+    end
+  end
+end

data/spec/d2l/valence/request/execute/lti_links/create_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe D2L::Valence::Request, type: :service do
+  include_context :common_context
+
+  subject do
+    described_class.new(
+      user_context: user_context,
+      http_method: http_method,
+      route: route,
+      route_params: route_params,
+      query_params: query_params
+    )
+  end
+
+  context '.execute' do
+    let(:user_id) { ENV['D2L_USER_ID'] }
+    let(:user_key) { ENV['D2L_USER_KEY'] }
+
+    context 'for POST', vcr: {cassette_name: 'request/execute/create_lti_link'} do
+      let(:http_method) { 'POST' }
+      let(:route) { '/d2l/api/le/:version/lti/link/:orgUnitId' }
+      let(:route_params) { {orgUnitId: 8041} }
+      let(:query_params) do
+        {
+          Title: 'LTI Link',
+          Url: 'http://myapplication.com/tool/launch',
+          Description: 'Link for external tool',
+          Key: '2015141297208',
+          PlainSecret: 'a30be7c3550149b7a7daac3065f0e5e5',
+          IsVisible: false,
+          SignMessage: true,
+          SignWithTc: true,
+          SendTcInfo: true,
+          SendContextInfo: true,
+          SendUserId: true,
+          SendUserName: true,
+          SendUserEmail: true,
+          SendLinkTitle: true,
+          SendLinkDescription: true,
+          SendD2LUserName: true,
+          SendD2LOrgDefinedId: true,
+          SendD2LOrgRoleId: true,
+          UseToolProviderSecuritySettings: false,
+          CustomParameters: nil
+        }
+      end
+      let(:api_version) { '1.15' }
+      let(:response) { subject.execute }
+
+      before do
+        Timecop.freeze Time.at(1491960645)
+      end
+
+      after { Timecop.return }
+
+      it 'will return the version information' do
+        expect(response.to_hash['LtiLinkId']).to_not be_nil
+        query_params.each do |k, v|
+          expect("#{k}: #{response.to_hash[k.to_s]}").to eq "#{k}: #{v}" if not [:PlainSecret, :CustomParameters].include? k
+        end
+        expect(response.code).to eq :HTTP_200
+      end
+    end
+  end
+end

data/spec/d2l/valence/request/execute/lti_links/delete_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe D2L::Valence::Request, type: :service do
+  include_context :common_context
+
+  subject do
+    described_class.new(
+      user_context: user_context,
+      http_method: http_method,
+      route: route,
+      route_params: route_params,
+      query_params: query_params
+    )
+  end
+
+  context '.execute' do
+    let(:user_id) { ENV['D2L_USER_ID'] }
+    let(:user_key) { ENV['D2L_USER_KEY'] }
+
+    context 'for DELETE an lti link', vcr: {cassette_name: 'request/execute/delete_lti_link'} do
+      let(:http_method) { 'DELETE' }
+      let(:route) { '/d2l/api/le/:version/lti/link/:ltiLinkId' }
+      let(:route_params) { {ltiLinkId: 144931} }
+      let(:query_params) { {} }
+      let(:api_version) { '1.15' }
+      let(:response) { subject.execute }
+
+      before do
+        Timecop.freeze Time.at(1491960880)
+      end
+
+      after { Timecop.return }
+
+      it 'will delete the LTI Link' do
+        expect(response.code).to eq :HTTP_200
+      end
+    end
+  end
+end

data/spec/d2l/valence/request/execute/lti_links/list_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe D2L::Valence::Request, type: :service do
+  include_context :common_context
+
+  subject do
+    described_class.new(
+      user_context: user_context,
+      http_method: http_method,
+      route: route,
+      route_params: route_params,
+      query_params: query_params
+    )
+  end
+
+  context '.execute' do
+    let(:user_id) { ENV['D2L_USER_ID'] }
+    let(:user_key) { ENV['D2L_USER_KEY'] }
+
+    context 'for GET all lti links', vcr: {cassette_name: 'request/execute/get_lti_links'} do
+      let(:http_method) { 'GET' }
+      let(:route) { '/d2l/api/le/:version/lti/link/:orgUnitId/' }
+      let(:route_params) { {orgUnitId: 8041} }
+      let(:query_params) { {} }
+      let(:api_version) { '1.15' }
+      let(:response) { subject.execute }
+
+      before do
+        Timecop.freeze Time.at(1491960964)
+      end
+
+      after { Timecop.return }
+
+      its(:execute) { is_expected.to be_a D2L::Valence::Response }
+      it 'will return all lti links for the associated unit' do
+        expect(response.code).to eq :HTTP_200
+        response.to_hash.each { |lti_record| expect(lti_record['LtiLinkId']).to_not be_nil }
+      end
+    end
+  end
+end

data/spec/d2l/valence/request/execute/lti_links/update_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe D2L::Valence::Request, type: :service do
+  include_context :common_context
+
+  subject do
+    described_class.new(
+      user_context: user_context,
+      http_method: http_method,
+      route: route,
+      route_params: route_params,
+      query_params: query_params
+    )
+  end
+
+  context '.execute' do
+    let(:user_id) { ENV['D2L_USER_ID'] }
+    let(:user_key) { ENV['D2L_USER_KEY'] }
+
+    context 'for PUT with an lti link', vcr: {cassette_name: 'request/execute/put_lti_link'} do
+      let(:incorrect_details) { query_params.dup.merge(Title: 'The wrong title') }
+      let!(:existing_lit_link) do
+        Timecop.freeze Time.at(1491961066) do
+          D2L::Valence::Request.new(
+            user_context: user_context,
+            http_method: 'POST',
+            route: '/d2l/api/le/:version/lti/link/:orgUnitId',
+            route_params: {orgUnitId: 8041},
+            query_params: incorrect_details
+          ).execute.to_hash
+        end
+      end
+      let(:http_method) { 'PUT' }
+      let(:route) { '/d2l/api/le/:version/lti/link/:ltiLinkId' }
+      let(:route_params) { {ltiLinkId: existing_lit_link['LtiLinkId']} }
+      let(:query_params) do
+        {
+          Title: 'LTI Link',
+          Url: 'http://myapplication.com/tool/launch',
+          Description: 'Link for external tool',
+          Key: '2015141297208',
+          PlainSecret: 'a30be7c3550149b7a7daac3065f0e5e5',
+          IsVisible: false,
+          SignMessage: true,
+          SignWithTc: true,
+          SendTcInfo: true,
+          SendContextInfo: true,
+          SendUserId: true,
+          SendUserName: true,
+          SendUserEmail: true,
+          SendLinkTitle: true,
+          SendLinkDescription: true,
+          SendD2LUserName: true,
+          SendD2LOrgDefinedId: true,
+          SendD2LOrgRoleId: true,
+          UseToolProviderSecuritySettings: true,
+          CustomParameters: nil
+        }
+      end
+      let(:api_version) { '1.15' }
+      let(:response) do
+        Timecop.freeze Time.at(1491961067) do
+          subject.execute
+        end
+      end
+
+      it 'will update the LTI Link' do
+        expect(response.code).to eq :HTTP_200
+        expect(response.to_hash['Title']).to eq query_params[:Title]
+      end
+    end
+  end
+end