orcid 0.0.4 → 0.1.0

data/spec/models/orcid/profile_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module Orcid
+  describe Profile do
+    let(:orcid_profile_id) { '0001-0002-0003-0004' }
+    let(:remote_service) { double('Service') }
+    let(:mapper) { double("Mapper") }
+    let(:non_orcid_work) { double("A non-ORCID Work") }
+    let(:orcid_work) { double("Orcid::Work") }
+    let(:xml_renderer) { double("Renderer") }
+    let(:xml_parser) { double("Parser") }
+    let(:xml) { double("XML Payload")}
+
+    subject {
+      described_class.new(
+        orcid_profile_id,
+        mapper: mapper,
+        remote_service: remote_service,
+        xml_renderer: xml_renderer,
+        xml_parser: xml_parser
+      )
+    }
+
+    def should_map(source, target)
+      mapper.should_receive(:map).with(source, target: 'orcid/work').and_return(target)
+    end
+
+    context '#remote_works' do
+      let(:parsed_object) { double("Parsed Object")}
+      let(:response_body) { double("XML Response") }
+      it 'should parse the response body' do
+        xml_parser.should_receive(:call).with(response_body).and_return(parsed_object)
+        remote_service.should_receive(:call).with(orcid_profile_id, request_method: :get).and_return(response_body)
+
+        expect(subject.remote_works).to eq(parsed_object)
+      end
+    end
+
+
+    context '#append_new_work' do
+      it 'should transform the input work to xml and deliver to the remote_service' do
+        xml_renderer.should_receive(:call).with([orcid_work]).and_return(xml)
+        remote_service.should_receive(:call).with(orcid_profile_id, body: xml, request_method: :post)
+
+        should_map(non_orcid_work, orcid_work)
+
+        subject.append_new_work(non_orcid_work)
+      end
+    end
+
+    context '#replace_works_with' do
+      it 'should transform the input work to xml and deliver to the remote_service' do
+        xml_renderer.should_receive(:call).with([orcid_work]).and_return(xml)
+        remote_service.should_receive(:call).with(orcid_profile_id, body: xml, request_method: :put)
+
+        should_map(non_orcid_work, orcid_work)
+
+        subject.replace_works_with(non_orcid_work)
+      end
+    end
+
+    context '#verified_authentication' do
+      it 'should not be authorized' do
+        subject.verified_authentication?.should eq false
+      end
+    end
+
+    context '#verified_authentication' do
+      it 'should be authorized' do
+        Orcid.stub(:access_token_for).and_return(Object.new())
+
+        subject.verified_authentication?.should eq true
+      end
+    end
+  end
+end

data/spec/models/orcid/work/xml_parser_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Orcid
+  describe Work::XmlParser do
+    let(:xml) { fixture_file('orcid_works.xml').read }
+
+    context '.call' do
+      subject { described_class.call(xml) }
+      its(:size) { should eq 2 }
+      its(:first) { should be_an_instance_of Orcid::Work }
+      its(:last) { should be_an_instance_of Orcid::Work }
+
+      context 'first element' do
+        subject { described_class.call(xml).first }
+
+        its(:title) { should eq "Another Test Drive" }
+        its(:put_code) { should eq "303475" }
+        its(:work_type) { should eq "test" }
+        its(:journal_title) { should_not be_present }
+        its(:short_description) { should_not be_present }
+        its(:citation_type) { should_not be_present }
+        its(:citation) { should_not be_present }
+        its(:publication_month) { should_not be_present }
+        its(:publication_year) { should_not be_present }
+        its(:url) { should_not be_present }
+        its(:language_code) { should_not be_present }
+        its(:country) { should_not be_present }
+      end
+
+      context 'last element' do
+        subject { described_class.call(xml).last }
+
+        its(:title) { should eq "Test Driven Orcid Integration" }
+        its(:put_code) { should eq "303474" }
+        its(:work_type) { should eq "test" }
+      end
+    end
+  end
+
+end

data/spec/models/orcid/work/xml_renderer_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module Orcid
+  describe Work::XmlRenderer do
+    let(:work) { Work.new(title: 'Hello', work_type: 'journal-article') }
+    subject { described_class.new(work) }
+
+    context '#call' do
+      it 'should return an XML document' do
+        rendered = subject.call
+        expect(rendered).to have_tag('orcid-profile orcid-activities orcid-works orcid-work') do
+          with_tag('work-title title', text: work.title)
+          with_tag('work-type', text: work.work_type)
+        end
+      end
+    end
+  end
+end

data/spec/models/orcid/work_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module Orcid
+  describe Work do
+    let(:attributes) {
+      {
+        title: 'Hello',
+        work_type: 'journal-article',
+        put_code: '1234',
+        external_identifiers: [ {type: 'doi', identifier: 'abc-123' }]
+      }
+    }
+    subject { described_class.new(attributes) }
+
+    its(:title) { should eq attributes[:title] }
+    its(:subtitle) { should eq nil }
+    its(:work_type) { should eq attributes[:work_type] }
+    its(:put_code) { should eq attributes[:put_code] }
+    its(:external_identifiers) { should be_an_instance_of(Array) }
+    its(:valid?) { should eq true }
+
+    context '#id' do
+      context 'with put_code' do
+        subject { described_class.new(put_code: '123') }
+        its(:id) { should eq subject.put_code}
+      end
+      context 'with title and work type' do
+        subject { described_class.new(title: 'Title', work_type: 'journal-article') }
+        its(:id) { should eq [subject.title, subject.work_type]}
+      end
+
+      context 'without title, work type, and put_code' do
+        subject { described_class.new }
+        its(:id) { should eq nil }
+      end
+    end
+
+    context '#to_xml' do
+      it 'should return an XML document' do
+        rendered = subject.to_xml
+        expect(rendered).to have_tag('orcid-profile orcid-activities orcid-works orcid-work') do
+          with_tag('work-title title', text: subject.title)
+          with_tag('work-type', text: subject.work_type)
+          with_tag('work-external-identifiers work-external-identifier', count: 1) do
+            with_tag('work-external-identifier-type', text: 'doi')
+            with_tag('work-external-identifier-id', text: 'abc-123')
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/services/orcid/remote/profile_creation_service_spec.rb

@@ -0,0 +1,40 @@
+require 'fast_helper'
+require 'orcid/remote/profile_creation_service'
+
+module Orcid::Remote
+  describe ProfileCreationService do
+    Given(:payload) { %(<?xml version="1.0" encoding="UTF-8"?>) }
+    Given(:config) { {token: token, headers: request_headers, path: 'path/to/somewhere' } }
+    Given(:token) { double("Token", post: response) }
+    Given(:minted_orcid) { '0000-0001-8025-637X' }
+    Given(:request_headers) {
+      { 'Content-Type' => 'application/vdn.orcid+xml', 'Accept' => 'application/xml' }
+    }
+    Given(:callback) { StubCallback.new }
+    Given(:callback_config) { callback.configure }
+
+    Given(:response) {
+      double("Response", headers: { location: File.join("/", minted_orcid, "orcid-profile") })
+    }
+
+    When(:returned_value) { described_class.call(payload, config, &callback_config) }
+
+    context 'with orcid created' do
+      Given(:response) {
+        double("Response", headers: { location: File.join("/", minted_orcid, "orcid-profile") })
+      }
+      Then { returned_value.should eq(minted_orcid)}
+      And { expect(callback.invoked).to eq [:success, minted_orcid] }
+      And { token.should have_received(:post).with(config.fetch(:path), body: payload, headers: request_headers)}
+    end
+
+    context 'with orcid created' do
+      Given(:response) {
+        double("Response", headers: { location: "" })
+      }
+      Then { returned_value.should eq(false)}
+      And { expect(callback.invoked).to eq [:failure] }
+      And { token.should have_received(:post).with(config.fetch(:path), body: payload, headers: request_headers)}
+    end
+  end
+end

data/spec/services/orcid/remote/profile_query_service/query_parameter_builder_spec.rb

@@ -0,0 +1,44 @@
+require 'fast_helper'
+require 'orcid/remote/profile_query_service/query_parameter_builder'
+
+module Orcid::Remote
+
+  describe ProfileQueryService::QueryParameterBuilder do
+    When(:response) { described_class.call(input) }
+    context 'single word input' do
+      Given(:input) {
+        { text: "Hello", email: 'jeremy.n.friesen@gmail.com' }
+      }
+      Then { expect(response).to eq(q: "email:#{input[:email]} AND text:#{input[:text]}") }
+    end
+
+    context 'empty string and nil' do
+      Given(:input) {
+        { text: "" , email: nil}
+      }
+      Then { expect(response).to eq(q: "") }
+    end
+
+    context 'multi-word named input' do
+      Given(:input) {
+        { other_names: %("Tim O'Connor" -"Oak"), email: 'jeremy.n.friesen@gmail.com' }
+      }
+      Then { expect(response).to eq(q: "other-names:#{input[:other_names]} AND email:#{input[:email]}") }
+    end
+
+    context 'q is provided along with other params' do
+      Given(:input) {
+        { q: %("Tim O'Connor" -"Oak"), email: 'jeremy.n.friesen@gmail.com' }
+      }
+      Then { expect(response).to eq(q: "email:#{input[:email]} AND text:#{input[:q]}") }
+    end
+
+    context 'q is provided with text params' do
+      Given(:input) {
+        { q: %("Tim O'Connor" -"Oak"), text: 'jeremy.n.friesen@gmail.com' }
+      }
+      Then { expect(response).to eq(q: "text:((#{input[:q]}) AND (#{input[:text]}))") }
+    end
+
+  end
+end

data/spec/services/orcid/remote/profile_query_service/search_response_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'orcid/remote/profile_query_service/search_response'
+
+module Orcid::Remote
+  describe ProfileQueryService::SearchResponse do
+    Given(:attributes) { {id: 'Hello', label: 'World', junk: 'JUNK!', biography: "Extended Biography"} }
+    Given(:search_response) { described_class.new(attributes) }
+    Then { expect(search_response.id).to eq(attributes[:id]) }
+    And { expect(search_response.biography).to eq(attributes[:biography]) }
+    And { expect(search_response.label).to eq(attributes[:label]) }
+    And { expect(search_response.orcid_profile_id).to eq(attributes[:id]) }
+    And { expect{search_response.junk }.to raise_error }
+  end
+end

data/spec/services/orcid/remote/profile_query_service_spec.rb

@@ -0,0 +1,118 @@
+require 'fast_helper'
+require 'orcid/remote/profile_query_service'
+require 'ostruct'
+
+module Orcid::Remote
+  describe ProfileQueryService do
+    Given(:email) { 'corwin@amber.gov' }
+    Given(:biography) { 'King of Amber' }
+    Given(:orcid_profile_id) { '0001-0002' }
+    Given(:config) {
+      {
+        token: token,
+        path: 'somehwere',
+        headers: 'headers',
+        response_builder: OpenStruct,
+        query_parameter_builder: query_parameter_builder
+      }
+    }
+    Given(:query_parameter_builder) { double('Query Builder')}
+    Given(:response) { double("Response", body: response_body)} # See below
+    Given(:token) { double("Token") }
+    Given(:json_response) {
+      [
+        OpenStruct.new({ 'id' => orcid_profile_id, 'label' => "Corwin Amber (#{email}) [ORCID: #{orcid_profile_id}]", 'biography' => biography })
+      ]
+    }
+    Given(:parameters) { double("Parameters") }
+    Given(:normalized_parameters) { double("Normalized Parameters") }
+    Given(:callback) { StubCallback.new }
+    Given(:callback_config) { callback.configure(:found, :not_found) }
+
+    context '.call' do
+      before(:each) do
+        query_parameter_builder.should_receive(:call).with(parameters).and_return(normalized_parameters)
+        token.should_receive(:get).with(config[:path], headers: config[:headers], params: normalized_parameters).and_return(response)
+      end
+      When(:result) { described_class.call(parameters, config, &callback_config) }
+      Then { expect(result).to eq(json_response) }
+      And { expect(callback.invoked).to eq [:found, json_response] }
+    end
+
+    Given(:response_body) {
+      %(
+        {
+          "message-version": "1.1",
+          "orcid-search-results": {
+            "orcid-search-result": [
+              {
+                "relevancy-score": {
+                  "value": 14.298138
+                },
+                "orcid-profile": {
+                  "orcid": null,
+                  "orcid-identifier": {
+                    "value": null,
+                    "uri": "http://orcid.org/#{orcid_profile_id}",
+                    "path": "#{orcid_profile_id}",
+                    "host": "orcid.org"
+                  },
+                  "orcid-bio": {
+                    "personal-details": {
+                      "given-names": {
+                        "value": "Corwin"
+                      },
+                      "family-name": {
+                        "value": "Amber"
+                      }
+                    },
+                    "biography": {
+                      "value": "#{biography}",
+                      "visibility": null
+                    },
+                    "contact-details": {
+                      "email": [
+                        {
+                          "value": "#{email}",
+                          "primary": true,
+                          "current": true,
+                          "verified": true,
+                          "visibility": null,
+                          "source": null
+                        }
+                      ],
+                      "address": {
+                        "country": {
+                          "value": "US",
+                          "visibility": null
+                        }
+                      }
+                    },
+                    "keywords": {
+                      "keyword": [
+                        {
+                          "value": "Lord of Amber"
+                        }
+                      ],
+                      "visibility": null
+                    },
+                    "delegation": null,
+                    "applications": null,
+                    "scope": null
+                  },
+                  "orcid-activities": {
+                    "affiliations": null
+                  },
+                  "type": null,
+                  "group-type": null,
+                  "client-type": null
+                }
+              }
+            ],
+            "num-found": 1
+          }
+        }
+      )
+    }
+  end
+end

data/spec/services/orcid/remote/service_spec.rb

@@ -0,0 +1,26 @@
+require 'fast_helper'
+require 'orcid/remote/service'
+
+module Orcid::Remote
+  describe Service do
+    Given(:context) { double(invoked: true) }
+    Given(:runner) {
+      described_class.new { |on|
+        on.found {|a,b| context.invoked("FOUND", a,b) }
+      }
+    }
+
+    describe "calling defined callback" do
+      When(:result) { runner.callback(:found, :first, :second) }
+      Then { context.should have_received(:invoked).with("FOUND", :first, :second) }
+      Then { result == [:first, :second] }
+    end
+
+    describe "calling undefined callback" do
+      When(:result) { runner.callback(:missing, :first, :second) }
+      Then { context.should_not have_received(:invoked) }
+      Then { result == [:first, :second] }
+    end
+
+  end
+end

data/spec/services/orcid/remote/work_service_spec.rb

@@ -0,0 +1,44 @@
+require 'fast_helper'
+require 'oauth2/error'
+require 'orcid/remote/work_service'
+
+module Orcid::Remote
+  describe WorkService do
+    let(:payload) { %(<?xml version="1.0" encoding="UTF-8"?>) }
+    let(:token) { double("Token") }
+    let(:orcid_profile_id) { '0000-0003-1495-7122' }
+    let(:request_headers) { { 'Content-Type' => 'application/orcid+xml', 'Accept' => 'application/xml' } }
+    let(:response) { double("Response", body: 'Body') }
+
+    context '.call' do
+      let(:token) { double('Token', client: client, token: 'access_token', refresh_token: 'refresh_token')}
+      let(:client) { double('Client', id: '123', site: 'URL', options: {})}
+      it 'raises a more helpful message' do
+        response = double("Response", status: '100', body: 'body')
+        response.stub(:error=)
+        response.stub(:parsed)
+        token.should_receive(:request).and_raise(OAuth2::Error.new(response))
+
+        expect {
+          described_class.call(orcid_profile_id, token: token)
+        }.to raise_error(Orcid::RemoteServiceError)
+      end
+      it 'instantiates and calls underlying instance' do
+        token.should_receive(:request).
+          with(:post, "v1.1/#{orcid_profile_id}/orcid-works/", body: payload, headers: request_headers).
+          and_return(response)
+
+        expect(
+          described_class.call(
+            orcid_profile_id,
+            body: payload,
+            request_method: :post,
+            token: token,
+            headers: request_headers
+          )
+        ).to eq(response.body)
+      end
+    end
+
+  end
+end