orcid 0.0.4 → 0.1.0

data/spec/features/public_api_query_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe 'public api query', requires_net_connect: true do
+  around(:each) do |example|
+    WebMock.allow_net_connect!
+    example.run
+    WebMock.disable_net_connect!
+  end
+
+  Given(:runner) {
+    Orcid::Remote::ProfileQueryService.new
+  }
+  context 'with simple query' do
+    Given(:parameters) { { email: 'jeremy.n.friesen@gmail.com' } }
+    When(:result) { runner.call(parameters) }
+    Then { expect(result.size).to eq(1) }
+  end
+
+  context 'with bad query' do
+    Given(:parameters) { { hobomancer: 'jeremy.n.friesen@gmail.com' } }
+    When(:result) { runner.call(parameters) }
+    Then { expect(result).to have_failed(OAuth2::Error) }
+  end
+
+  context 'with a text query' do
+    Given(:parameters) { { text: '"Jeremy Friesen"' } }
+    When(:result) { runner.call(parameters) }
+    Then { expect(result.size).to be > 0 }
+  end
+
+  context 'with a compound text query' do
+    Given(:parameters) { { email: "nobody@gmail.com", text: '"Jeremy+Friesen"' } }
+    When(:result) { runner.call(parameters) }
+    Then { expect(result.size).to eq 0 }
+  end
+end

data/spec/fixtures/orcid_works.xml

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<orcid-message xmlns="http://www.orcid.org/ns/orcid">
+    <message-version>1.1</message-version>
+    <orcid-profile type="user">
+        <orcid-identifier>
+            <uri>http://sandbox.orcid.org/0000-0002-1117-8571</uri>
+            <path>0000-0002-1117-8571</path>
+            <host>sandbox.orcid.org</host>
+        </orcid-identifier>
+        <orcid-preferences>
+            <locale>en</locale>
+        </orcid-preferences>
+        <orcid-history>
+            <creation-method>API</creation-method>
+            <completion-date>2014-02-14T15:32:15.453Z</completion-date>
+            <submission-date>2014-02-14T15:31:12.816Z</submission-date>
+            <last-modified-date>2014-02-18T20:23:40.472Z</last-modified-date>
+            <claimed>true</claimed>
+            <source>
+                <source-orcid>
+                    <uri>http://sandbox.orcid.org/0000-0002-6683-6607</uri>
+                    <path>0000-0002-6683-6607</path>
+                    <host>sandbox.orcid.org</host>
+                </source-orcid>
+                <source-name>Hydra ORCID Integrator</source-name>
+            </source>
+        </orcid-history>
+        <orcid-activities>
+            <orcid-works>
+                <orcid-work put-code="303475" visibility="public">
+                    <work-title>
+                        <title>Another Test Drive</title>
+                    </work-title>
+                    <work-type>test</work-type>
+                    <work-source>
+                        <uri>http://sandbox.orcid.org/0000-0002-6683-6607</uri>
+                        <path>0000-0002-6683-6607</path>
+                        <host>sandbox.orcid.org</host>
+                    </work-source>
+                </orcid-work>
+                <orcid-work put-code="303474" visibility="public">
+                    <work-title>
+                        <title>Test Driven Orcid Integration</title>
+                    </work-title>
+                    <work-type>test</work-type>
+                    <work-source>
+                        <uri>http://sandbox.orcid.org/0000-0002-6683-6607</uri>
+                        <path>0000-0002-6683-6607</path>
+                        <host>sandbox.orcid.org</host>
+                    </work-source>
+                </orcid-work>
+            </orcid-works>
+        </orcid-activities>
+    </orcid-profile>
+</orcid-message>

data/spec/lib/orcid/configuration/provider_spec.rb

@@ -0,0 +1,40 @@
+require 'fast_helper'
+require 'orcid/configuration/provider'
+
+module Orcid
+  describe Configuration::Provider do
+
+    let(:storage) {
+      {
+        'ORCID_APP_AUTHENTICATION_SCOPE' => '_APP_AUTHENTICATION_SCOPE',
+        'ORCID_SITE_URL' => '_SITE_URL',
+        'ORCID_TOKEN_URL' => '_TOKEN_URL',
+        'ORCID_REMOTE_SIGNIN_URL' => '_REMOTE_SIGNIN_URL',
+        'ORCID_AUTHORIZE_URL' => '_AUTHORIZE_URL',
+        'ORCID_APP_ID' => '_APP_ID',
+        'ORCID_APP_SECRET' => '_APP_SECRET',
+      }
+    }
+
+    subject { described_class.new(storage) }
+
+    its(:authentication_scope) { should eq storage.fetch('ORCID_APP_AUTHENTICATION_SCOPE') }
+    its(:site_url) { should eq storage.fetch('ORCID_SITE_URL') }
+    its(:token_url) { should eq storage.fetch('ORCID_TOKEN_URL') }
+    its(:signin_via_json_url) { should eq storage.fetch('ORCID_REMOTE_SIGNIN_URL') }
+    its(:authorize_url) { should eq storage.fetch('ORCID_AUTHORIZE_URL') }
+    its(:id) { should eq storage.fetch('ORCID_APP_ID') }
+    its(:secret) { should eq storage.fetch('ORCID_APP_SECRET') }
+
+    context 'with an empty ENV' do
+      Given(:provider) { described_class.new({}) }
+      Then { expect(provider.authentication_scope).to be_an_instance_of(String) }
+      And { expect(provider.site_url).to be_an_instance_of(String) }
+      And { expect(provider.token_url).to be_an_instance_of(String) }
+      And { expect(provider.signin_via_json_url).to be_an_instance_of(String) }
+      And { expect(provider.authorize_url).to be_an_instance_of(String) }
+      And { expect { provider.id }.to raise_error Orcid::ConfigurationError }
+      And { expect { provider.secret }.to raise_error Orcid::ConfigurationError }
+    end
+  end
+end

data/spec/lib/orcid/configuration_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Orcid
+  describe Configuration do
+
+    subject { described_class.new }
+
+    its(:parent_controller) { should be_an_instance_of String }
+    its(:provider) { should be_an_instance_of Configuration::Provider }
+    its(:authentication_model) { should eq Devise::MultiAuth::Authentication }
+
+    its(:mapper) { should respond_to :map }
+    its(:mapper) { should respond_to :configure }
+
+    context 'mapping to an Orcid::Work' do
+      let(:legend) {
+        [
+          [:title, :title],
+          [lambda{|*| 'spaghetti'}, :work_type]
+        ]
+      }
+      let(:title) { 'Hello World' }
+      let(:article) { NonOrcid::Article.new(title: title)}
+      before(:each) do
+        subject.register_mapping_to_orcid_work('non_orcid/article', legend)
+      end
+
+      it 'should configure the mapper' do
+        orcid_work = subject.mapper.map(article, target: 'orcid/work')
+        expect(orcid_work.work_type).to eq('spaghetti')
+        expect(orcid_work.title).to eq(title)
+        expect(orcid_work).to be_an_instance_of(Orcid::Work)
+      end
+
+    end
+
+  end
+end

data/spec/lib/orcid/named_callbacks_spec.rb

@@ -0,0 +1,28 @@
+require 'fast_helper'
+require './lib/orcid/named_callbacks'
+
+module Orcid
+  describe NamedCallbacks do
+    Given(:named_callback) { NamedCallbacks.new }
+    Given(:context) { [ ] }
+    Given { named_callback.my_named_callback { |*a| context.replace(a) } }
+
+    describe "with a named callback" do
+      Given(:callback_name) { :my_named_callback }
+      When { named_callback.call(callback_name, 'a',:hello) }
+      Then { context == ['a', :hello] }
+    end
+
+    describe "with a named callback called by a string" do
+      Given(:callback_name) { 'my_named_callback' }
+      When { named_callback.call(callback_name, 'a',:hello) }
+      Then { context == ['a', :hello] }
+    end
+
+    describe "with a undeclared callback" do
+      When(:result) { named_callback.call(:undeclared_callback, 1, 2, 3) }
+      Then { result }
+      Then { context == [] }
+    end
+  end
+end

data/spec/lib/orcid_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Orcid do
+  let(:user) { FactoryGirl.build_stubbed(:user) }
+  let(:orcid_profile_id) { '0001-0002-0003-0004' }
+  subject { described_class }
+  its(:provider) { should respond_to :id }
+  its(:provider) { should respond_to :secret }
+  its(:mapper) { should respond_to :map }
+  its(:use_relative_model_naming?) { should eq true }
+
+  context '.authentication_model' do
+    subject { Orcid.authentication_model }
+    it { should respond_to :to_access_token }
+    it { should respond_to :create! }
+    it { should respond_to :count }
+    it { should respond_to :where }
+  end
+
+  context '.oauth_client' do
+    subject { Orcid.oauth_client }
+    its(:client_credentials) { should respond_to :get_token }
+  end
+
+  context '.configure' do
+    it 'should yield a configuration' do
+      expect{|b| Orcid.configure(&b) }.to yield_with_args(Orcid::Configuration)
+    end
+  end
+
+  context '.profile_for' do
+    it 'should return nil if none is found' do
+      expect(Orcid.profile_for(user)).to eq(nil)
+    end
+
+    it 'should return an Orcid::Profile if the user has an orcid authentication' do
+      Orcid.connect_user_and_orcid_profile(user,orcid_profile_id)
+      expect(Orcid.profile_for(user).orcid_profile_id).to eq(orcid_profile_id)
+    end
+  end
+
+  context '.client_credentials_token' do
+    let(:tokenizer) { double('Tokenizer') }
+    let(:scope) { '/my-scope' }
+    let(:token) { double('Token') }
+
+    it 'should request the scoped token from the tokenizer' do
+      tokenizer.should_receive(:get_token).with(scope: scope).and_return(token)
+      expect(Orcid.client_credentials_token(scope, tokenizer: tokenizer)).to eq(token)
+    end
+  end
+
+  context '.connect_user_and_orcid_profile' do
+
+    it 'changes the authentication count' do
+      expect {
+        Orcid.connect_user_and_orcid_profile(user, orcid_profile_id)
+      }.to change(Orcid.authentication_model, :count).by(1)
+    end
+  end
+
+  context '.access_token_for' do
+    let(:client) { double("Client")}
+    let(:token) { double('Token') }
+    let(:tokenizer) { double("Tokenizer") }
+
+    it 'delegates to .authentication' do
+      tokenizer.should_receive(:to_access_token).with(provider: 'orcid', uid: orcid_profile_id, client: client).and_return(token)
+      expect(Orcid.access_token_for(orcid_profile_id, client: client, tokenizer: tokenizer)).to eq(token)
+    end
+  end
+
+  context '.enqueue' do
+    let(:object) { double }
+
+    it 'should #run the object' do
+      object.should_receive(:run)
+      Orcid.enqueue(object)
+    end
+  end
+
+  context '#authenticated_orcid' do
+    it 'should not be authenticated' do
+      Orcid.authenticated_orcid?(orcid_profile_id).should eq false
+    end
+  end
+
+=begin
+  context '#authenticated_orcid' do
+    it 'should be authenticated' do
+      Orcid.should_receive(:authenticated_orcid).with(orcid_profile_id).and_return(true)
+      Orcid.authenticated_orcid?(orcid_profile_id).should eq true
+    end
+  end
+=end
+
+end

data/spec/models/orcid/profile_connection_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module Orcid
+  describe ProfileConnection do
+    let(:email) { 'test@hello.com'}
+    let(:user) { FactoryGirl.build_stubbed(:user) }
+    let(:profile_query_service) { double("Profile Lookup Service") }
+
+    subject {
+      Orcid::ProfileConnection.new(email: email, user: user).tap { |pc|
+        pc.profile_query_service = profile_query_service
+      }
+    }
+
+    its(:email) { should eq email }
+    its(:user) { should eq user }
+    its(:persisted?) { should eq false }
+    its(:orcid_profile_id) { should be_nil }
+
+    context '.available_query_attribute_names' do
+      subject { Orcid::ProfileConnection.new.available_query_attribute_names }
+      it { should include(:email) }
+      it { should include(:text) }
+    end
+
+    context '#query_attributes' do
+      subject { Orcid::ProfileConnection.new(email: email, user: user)}
+      its(:query_attributes) { should eq(email: email, text: nil) }
+    end
+
+    context '#query_requested?' do
+      context 'with no attributes' do
+        subject { Orcid::ProfileConnection.new }
+        its(:query_requested?) { should eq false }
+      end
+      context 'with attribute set' do
+        subject { Orcid::ProfileConnection.new(email: email, user: user)}
+        its(:query_requested?) { should eq true }
+      end
+    end
+
+    context '#save' do
+      let(:orcid_profile_id) { '1234-5678' }
+      let(:persister) { double("Persister") }
+
+      it 'should call the persister when valid' do
+        subject.orcid_profile_id = orcid_profile_id
+        persister.should_receive(:call).with(user, orcid_profile_id).and_return(:persisted)
+        expect(subject.save(persister: persister)).to eq(:persisted)
+      end
+
+      it 'should NOT call the persister and add errors when not valid' do
+        subject.user = nil
+        subject.orcid_profile_id = nil
+        expect {
+          subject.save(persister: persister)
+        }.to change { subject.errors.count }.by(2)
+      end
+    end
+
+    context '#with_orcid_profile_candidates' do
+      context 'with an email' do
+
+        it 'should yield the query response' do
+          subject.email = email
+          profile_query_service.should_receive(:call).with(subject.query_attributes).and_return(:query_response)
+          expect {|b| subject.with_orcid_profile_candidates(&b) }.to yield_with_args(:query_response)
+        end
+      end
+
+      context 'without an email' do
+        it 'should not yield' do
+          subject.email = nil
+          profile_query_service.stub(:call).and_return(:query_response)
+          expect {|b| subject.with_orcid_profile_candidates(&b) }.to_not yield_control
+        end
+      end
+
+    end
+  end
+end

data/spec/models/orcid/profile_request_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+module Orcid
+  describe ProfileRequest do
+    let(:orcid_profile_id) { '0000-0001-8025-637X'}
+    let(:user) { mock_model('User') }
+    let(:attributes) {
+      {
+        user: user,
+        given_names: 'Daffy',
+        family_name: 'Duck',
+        primary_email: 'daffy@duck.com'
+      }
+    }
+    subject { described_class.new(attributes) }
+
+    context '#find_by_user' do
+      let!(:profile_request) { FactoryGirl.create(:orcid_profile_request) }
+      it 'returns the profile request' do
+        expect(described_class.find_by_user(profile_request.user)).to eq(profile_request)
+      end
+
+      it 'to return nil' do
+        other_user = FactoryGirl.build_stubbed(:user)
+        expect(described_class.find_by_user(other_user)).to be_nil
+      end
+
+    end
+
+    context '#handle_profile_creation_response' do
+      it 'should update local' do
+        # Don't want to hit the database
+        subject.should_receive(:update_column).with(:orcid_profile_id, orcid_profile_id)
+        Orcid.should_receive(:connect_user_and_orcid_profile).with(user, orcid_profile_id)
+
+        subject.handle_profile_creation_response(orcid_profile_id)
+      end
+    end
+
+    context '#xml_payload' do
+      it 'should be a parsable XML document' do
+        expect {
+          ActiveSupport::XmlMini.parse(subject.xml_payload)
+        }.to_not raise_error
+      end
+    end
+
+    context '#validate_before_run' do
+      let(:orcid_profile) { double('Orcid Profile', to_param: orcid_profile_id) }
+
+      context 'when no orcid profile has been assigned' do
+        before { Orcid.should_receive(:profile_for).with(user).and_return(nil) }
+        it 'should return true' do
+          expect(subject.validate_before_run).to eq(true)
+        end
+      end
+
+      context 'orcid_profile_id is set' do
+        before { subject.orcid_profile_id = orcid_profile_id }
+
+        it 'should return false' do
+          expect(subject.validate_before_run).to eq(false)
+        end
+
+        it 'should set an error' do
+          expect {
+            subject.validate_before_run
+          }.to change { subject.errors.full_messages.count }.by(1)
+        end
+
+      end
+
+      context 'user has an orcid_profile' do
+        before { Orcid.should_receive(:profile_for).with(user).and_return(orcid_profile) }
+
+        it 'should return false' do
+          expect(subject.validate_before_run).to eq(false)
+        end
+
+        it 'should set an error' do
+          expect {
+            subject.validate_before_run
+          }.to change { subject.errors.full_messages.count }.by(1)
+        end
+
+      end
+    end
+
+    context '#run' do
+      let(:profile_creation_service) { double('Profile Creation Service') }
+      let(:payload_xml_builder) { double('Payload Xml Builder') }
+      let(:validator) { double('Submission Guardian') }
+      let(:xml_payload) { double('Xml Payload') }
+
+      context 'with the submission guardian permitting the request' do
+        before(:each) do
+          validator.should_receive(:call).with(subject).
+            and_return(true)
+          payload_xml_builder.should_receive(:call).with(subject.attributes).
+            and_return(xml_payload)
+          profile_creation_service.should_receive(:call).with(xml_payload).
+            and_return(orcid_profile_id)
+        end
+
+        it 'should run a request and handle the response' do
+          subject.run(
+            payload_xml_builder: payload_xml_builder,
+            profile_creation_service: profile_creation_service,
+            validator: validator
+          )
+        end
+      end
+
+      context 'with the submission guardian returning false' do
+        before(:each) do
+          validator.should_receive(:call).with(subject).
+            and_return(false)
+          payload_xml_builder.should_not_receive(:call)
+        end
+
+        it 'should raise an exception' do
+          subject.run(
+            payload_xml_builder: payload_xml_builder,
+            profile_creation_service: profile_creation_service,
+            validator: validator
+          )
+        end
+      end
+    end
+  end
+end