orcid 0.0.4 → 0.1.0

data/script/fast_specs

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby -w
+
+require 'rake'
+
+# A helper function for answering: Does this spec run fast?
+module Fast
+  module_function
+  def spec?(fn)
+    open(fn) { |f| f.gets =~ /fast_helper/ }
+  end
+end
+
+fast_specs = FileList['spec/**/*_spec.rb'].select do |fn|
+  Fast.spec?(fn)
+end
+
+if fast_specs.any?
+  system "rspec #{fast_specs}"
+else
+  puts 'Unable to find any fast specs'
+  exit(-1)
+end

data/spec/controllers/orcid/profile_connections_controller_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+module Orcid
+  describe ProfileConnectionsController do
+    def self.it_prompts_unauthenticated_users_for_signin(method, action)
+      context 'unauthenticated user' do
+        it 'should redirect for sign in' do
+          send(method, action, use_route: :orcid)
+          expect(response).to redirect_to(main_app.new_user_session_path)
+        end
+      end
+    end
+
+    def self.it_redirects_if_user_has_previously_connected_to_orcid_profile(method, action)
+      context 'user has existing orcid_profile' do
+        it 'should redirect to home_path' do
+          sign_in(user)
+          orcid_profile = double("Orcid::Profile", orcid_profile_id: '1234-5678-0001-0002')
+          Orcid.should_receive(:profile_for).with(user).and_return(orcid_profile)
+
+          send(method, action, use_route: :orcid)
+
+          expect(response).to redirect_to(main_app.root_path)
+          expect(flash[:notice]).to eq(
+            I18n.t("orcid.requests.messages.previously_connected_profile", orcid_profile_id: orcid_profile.orcid_profile_id)
+          )
+        end
+      end
+    end
+
+    let(:user) { mock_model('User') }
+    before(:each) do
+      Orcid.stub(:profile_for).and_return(nil)
+    end
+
+    context 'GET #index' do
+      it_prompts_unauthenticated_users_for_signin(:get, :index)
+      it 'redirects because the user does not have a connected orcid profile' do
+        sign_in(user)
+        Orcid.should_receive(:profile_for).with(user).and_return(nil)
+        get :index, use_route: :orcid
+        expect(flash[:notice]).to eq(I18n.t("orcid.connections.messages.profile_connection_not_found"))
+        expect(response).to redirect_to(orcid.new_profile_connection_path)
+      end
+
+      it 'redirects user has an orcid profile but it is not verified' do
+        sign_in(user)
+        orcid_profile = double("Orcid::Profile", orcid_profile_id: '1234-5678-0001-0002', verified_authentication?: false)
+        Orcid.stub(:profile_for).with(user).and_return(orcid_profile)
+
+        get :index, use_route: :orcid
+        expect(response).to redirect_to(user_omniauth_authorize_url("orcid"))
+        expect(orcid_profile).to have_received(:verified_authentication?)
+      end
+
+      it 'redirects to configured location if user orcid profile is connected and verified' do
+        orcid_profile = double("Orcid::Profile", orcid_profile_id: '1234-5678-0001-0002', verified_authentication?: true)
+        Orcid.stub(:profile_for).with(user).and_return(orcid_profile)
+
+        sign_in(user)
+        get :index, use_route: :orcid
+        expect(response).to redirect_to('/')
+        expect(flash[:notice]).to eq(I18n.t("orcid.connections.messages.verified_profile_connection_exists", orcid_profile_id: orcid_profile.orcid_profile_id))
+      end
+    end
+
+    context 'GET #new' do
+      it_prompts_unauthenticated_users_for_signin(:get, :new)
+      it_redirects_if_user_has_previously_connected_to_orcid_profile(:get, :new)
+
+      context 'authenticated and authorized user' do
+        before { sign_in(user) }
+
+        it 'should render a profile request form' do
+          get :new, use_route: :orcid
+          expect(response).to be_success
+          expect(assigns(:profile_connection)).to be_an_instance_of(Orcid::ProfileConnection)
+          expect(response).to render_template('new')
+        end
+      end
+    end
+
+    context 'POST #create' do
+      it_prompts_unauthenticated_users_for_signin(:post, :create)
+      it_redirects_if_user_has_previously_connected_to_orcid_profile(:post, :create)
+
+      context 'authenticated and authorized user' do
+        let(:orcid_profile_id) {'0000-0001-8025-637X'}
+        before { sign_in(user) }
+
+        it 'should render a profile request form' do
+          Orcid::ProfileConnection.any_instance.should_receive(:save)
+
+          post :create, profile_connection: { orcid_profile_id: orcid_profile_id }, use_route: :orcid
+          expect(assigns(:profile_connection)).to be_an_instance_of(Orcid::ProfileConnection)
+          expect(response).to redirect_to(orcid.profile_connections_path)
+        end
+      end
+    end
+  end
+end

data/spec/controllers/orcid/profile_requests_controller_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+module Orcid
+  describe ProfileRequestsController do
+    def self.it_prompts_unauthenticated_users_for_signin(method, action)
+      context 'unauthenticated user' do
+        it "should redirect for sign in" do
+          send(method, action, use_route: :orcid)
+          expect(response).to redirect_to(main_app.new_user_session_path)
+        end
+      end
+    end
+
+    def self.it_redirects_if_user_has_previously_connected_to_orcid_profile(method, action)
+      context 'user has existing orcid_profile' do
+        it 'should redirect to home_path' do
+          sign_in(user)
+          orcid_profile = double("Orcid::Profile", orcid_profile_id: '1234-5678-0001-0002')
+          Orcid.should_receive(:profile_for).with(user).and_return(orcid_profile)
+
+          send(method, action, use_route: :orcid)
+
+          expect(response).to redirect_to(main_app.root_path)
+          expect(flash[:notice]).to eq(
+            I18n.t("orcid.requests.messages.previously_connected_profile", orcid_profile_id: orcid_profile.orcid_profile_id)
+          )
+        end
+      end
+    end
+    let(:user) { mock_model('User') }
+    let(:profile_request_attributes) { FactoryGirl.attributes_for(:orcid_profile_request) }
+    before(:each) do
+      Orcid.stub(:profile_for).and_return(nil)
+    end
+    context 'GET #show' do
+      it_prompts_unauthenticated_users_for_signin(:get, :show)
+      it_redirects_if_user_has_previously_connected_to_orcid_profile(:get, :show)
+
+      context 'authenticated and authorized user' do
+        before { sign_in(user) }
+        let(:profile_request_id) { '1234' }
+        let(:profile_request) { FactoryGirl.build_stubbed(:orcid_profile_request, user: user)}
+
+        it 'should render the existing profile request' do
+          Orcid::ProfileRequest.should_receive(:find_by_user).
+            with(user).and_return(profile_request)
+
+          get :show, use_route: :orcid
+
+          expect(response).to be_success
+          expect(assigns(:profile_request)).to eq(profile_request)
+          expect(response).to render_template('show')
+        end
+
+        it 'should redirect to the profile request form if none is found' do
+          Orcid::ProfileRequest.should_receive(:find_by_user).
+            with(user).and_return(nil)
+
+          get :show, use_route: :orcid
+
+          expect(flash[:notice]).to eq(I18n.t("orcid.requests.messages.existing_request_not_found"))
+          expect(response).to redirect_to(orcid.new_profile_request_path)
+        end
+      end
+    end
+
+    context 'GET #new' do
+      it_prompts_unauthenticated_users_for_signin(:get, :new)
+      it_redirects_if_user_has_previously_connected_to_orcid_profile(:get, :new)
+
+      context 'authenticated and authorized user' do
+        before { sign_in(user) }
+
+        it 'should render a profile request form' do
+          Orcid::ProfileRequest.should_receive(:find_by_user).with(user).and_return(nil)
+          get :new, use_route: :orcid
+          expect(response).to be_success
+          expect(assigns(:profile_request).user).to eq(user)
+          expect(response).to render_template('new')
+        end
+
+        it 'should guard against duplicate requests' do
+          Orcid::ProfileRequest.should_receive(:find_by_user).with(user).and_return(Orcid::ProfileRequest.new)
+          get :new, use_route: :orcid
+          expect(flash[:notice]).to eq(I18n.t("orcid.requests.messages.existing_request"))
+          expect(response).to redirect_to(orcid.profile_request_path)
+        end
+      end
+    end
+
+    context 'POST #create' do
+      it_prompts_unauthenticated_users_for_signin(:post, :create)
+      it_redirects_if_user_has_previously_connected_to_orcid_profile(:post, :create)
+      context 'authenticated and authorized user' do
+        before { sign_in(user) }
+
+        it 'should render a profile request form' do
+          Orcid::ProfileRequest.should_receive(:find_by_user).with(user).and_return(nil)
+          Orcid.should_receive(:enqueue).with(an_instance_of(Orcid::ProfileRequest))
+
+          post :create, profile_request: profile_request_attributes, use_route: :orcid
+          expect(response).to be_redirect
+        end
+
+        it 'should guard against duplicate requests' do
+          Orcid::ProfileRequest.should_receive(:find_by_user).with(user).and_return(Orcid::ProfileRequest.new)
+          post :create, profile_request: profile_request_attributes, use_route: :orcid
+
+          expect(flash[:notice]).to eq(I18n.t("orcid.requests.messages.existing_request"))
+          expect(response).to redirect_to(orcid.profile_request_path)
+        end
+
+      end
+    end
+  end
+end

data/spec/factories/orcid_profile_requests.rb

@@ -0,0 +1,11 @@
+# Read about factories at https://github.com/thoughtbot/factory_girl
+
+FactoryGirl.define do
+  factory :orcid_profile_request, :class => 'Orcid::ProfileRequest' do
+    association :user, strategy: :build_stubbed
+    given_names 'All of the Names'
+    family_name 'Under-the-sun'
+    primary_email 'all-of-the-names@underthesun.com'
+    primary_email_confirmation 'all-of-the-names@underthesun.com'
+  end
+end

data/spec/factories/users.rb

@@ -0,0 +1,9 @@
+# Read about factories at https://github.com/thoughtbot/factory_girl
+
+FactoryGirl.define do
+  factory :user do
+    email 'test@test.com'
+    password '12345678'
+    password_confirmation '12345678'
+  end
+end

data/spec/fast_helper.rb

@@ -0,0 +1,12 @@
+require 'rspec/given'
+Dir[File.expand_path("../../app/*", __FILE__)].each do |dir|
+  $LOAD_PATH << dir
+end
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+require File.expand_path('../support/stub_callback', __FILE__)
+
+unless defined?(require_dependency)
+  def require_dependency(*files)
+    require *files
+  end
+end

data/spec/features/batch_profile_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe 'batch profile behavior', requires_net_connect: true do
+  around(:each) do |example|
+    WebMock.allow_net_connect!
+    example.run
+    WebMock.disable_net_connect!
+  end
+
+  Given(:runner) {
+    lambda { |person|
+      Orcid::Remote::ProfileQueryService.new {|on|
+        on.found {|results| person.found(results) }
+        on.not_found { person.not_found }
+      }.call(email: person.email)
+    }
+  }
+  Given(:person) {
+    double('Person', email: email, found: true, not_found: true)
+  }
+  context 'with existing email' do
+    Given(:email) { 'jeremy.n.friesen@gmail.com' }
+    When { runner.call(person) }
+    Then { person.should have_received(:found) }
+  end
+  context 'without an existing email' do
+    Given(:email) { 'nobody@nowhere.zorg' }
+    When { runner.call(person) }
+    Then { person.should have_received(:not_found) }
+  end
+end

data/spec/features/non_ui_based_interactions_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe 'non-UI based interactions' , requires_net_connect: true do
+  around(:each) do |example|
+    Mappy.configure {|b|}
+    WebMock.allow_net_connect!
+
+    example.run
+    WebMock.disable_net_connect!
+    Mappy.reset!
+  end
+  let(:work) { Orcid::Work.new(title: "Test Driven Orcid Integration", work_type: 'test') }
+  let(:user) { FactoryGirl.create(:user) }
+  let(:orcid_profile_password) { 'password1A' }
+
+  context 'issue a profile request', api_abusive: true do
+
+    # Because either ORCID or Mailinator are blocking some emails.
+    let(:random_valid_email_prefix) { (0...24).map { (65 + rand(26)).chr }.join.downcase }
+    let(:email) {  "#{random_valid_email_prefix}@mailinator.com" }
+    let(:profile_request) {
+      FactoryGirl.create(:orcid_profile_request, user: user, primary_email: email, primary_email_confirmation: email)
+    }
+
+    before(:each) do
+      # Making sure things are properly setup
+      expect(profile_request.orcid_profile_id).to be_nil
+    end
+
+    it 'creates a profile' do
+      profile_request.run
+
+      orcid_profile_id = profile_request.orcid_profile_id
+
+      expect(orcid_profile_id).to match(/\w{4}-\w{4}-\w{4}-\w{4}/)
+
+      claim_the_orcid!(random_valid_email_prefix)
+
+      authenticate_the_orcid!(orcid_profile_id, orcid_profile_password)
+
+      orcid_profile = Orcid::Profile.new(orcid_profile_id)
+
+      orcid_profile.append_new_work(work)
+
+      expect(orcid_profile.remote_works(force: true).count).to eq(1)
+    end
+
+  end
+
+  context 'appending a work to an already claimed and authorize orcid', requires_net_connect: true do
+    let(:orcid_profile_id) { ENV.fetch('ORCID_CLAIMED_PROFILE_ID')}
+    let(:orcid_profile_password) { ENV.fetch('ORCID_CLAIMED_PROFILE_PASSWORD')}
+
+    before(:each) do
+      expect(work).to be_valid
+      authenticate_the_orcid!(orcid_profile_id, orcid_profile_password)
+    end
+
+    subject { Orcid::Profile.new(orcid_profile_id) }
+    it 'should increment orcid works' do
+      replacement_work = Orcid::Work.new(title: "Test Driven Orcid Integration", work_type: 'test')
+      appended_work = Orcid::Work.new(title: "Another Test Drive", work_type: 'test')
+
+      subject.replace_works_with(replacement_work)
+
+      expect {
+        subject.append_new_work(appended_work)
+      }.to change { subject.remote_works(force: true).count }.by(1)
+
+    end
+  end
+
+  # Extract this method as a proper helper
+  def authenticate_the_orcid!(orcid_profile_id, orcid_profile_password)
+    code = RequestSandboxAuthorizationCode.call(orcid_profile_id: orcid_profile_id, password: orcid_profile_password)
+    token = Orcid.oauth_client.auth_code.get_token(code)
+    normalized_token = {provider: 'orcid', uid: orcid_profile_id, credentials: {token: token.token, refresh_token: token.refresh_token }}
+    Devise::MultiAuth::CaptureSuccessfulExternalAuthentication.call(user, normalized_token)
+  end
+
+  # Achtung, this is going to be fragile
+  def claim_the_orcid!(email_prefix)
+    Capybara.current_driver = :webkit
+    Capybara.app_host = 'http://mailinator.com'
+    Capybara.run_server = false
+
+    sleep(2) # Because Orcid may not have delivered the mail just yet
+
+    visit("/inbox.jsp?to=#{email_prefix}")
+    sleep(2) # Because mailinator might be slow
+    begin
+      page.find('#mailcontainer a').click
+    rescue Capybara::ElementNotFound => e
+      filename = Rails.root.join('tmp/claim_orcid_failure.png')
+      page.save_screenshot(filename, full: true)
+      `open #{filename}`
+      raise e
+    end
+
+    sleep(2) # Because mailinator might be slow
+    href = page.all('.mailview a').collect { |a| a[:href] }.find {|href| href = /\/claim\//}
+
+    uri = URI.parse(href)
+    Capybara.app_host = "#{uri.scheme}://#{uri.host}"
+
+    visit(uri.path)
+    page.all('input').each do |input|
+      case input[:name]
+      when 'password' then input.set(orcid_profile_password)
+      when 'confirmPassword' then input.set(orcid_profile_password)
+      when 'acceptTermsAndConditions' then input.click
+      end
+    end
+    page.all('button').find {|i| i.text == 'Claim' }.click
+    sleep(2) # Because claiming your orcid could be slowe
+  end
+end

data/spec/features/profile_connection_feature_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Orcid
+  describe 'connect to a publicly visible profile', requires_net_connect: true do
+    around(:each) do |example|
+      WebMock.allow_net_connect!
+      example.run
+      WebMock.disable_net_connect!
+    end
+
+    Given(:user) { FactoryGirl.create(:user) }
+    Given(:text) { '"Jeremy Friesen"' }
+    Given(:profile_connect) { ProfileConnection.new(user: user, text: text) }
+
+    When(:profile_candidates) { profile_connect.orcid_profile_candidates }
+
+    Then { expect(profile_candidates.count).to be > 1 }
+  end
+end