hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/controllers/hyrax/admin/workflow_roles_controller_spec.rb

@@ -0,0 +1,76 @@
+RSpec.describe Hyrax::Admin::WorkflowRolesController do
+  describe '#index' do
+    context "when you have permission" do
+      before do
+        allow(controller).to receive(:authorize!).with(:read, :admin_dashboard).and_return(true)
+      end
+
+      it "is successful" do
+        expect(controller).to receive(:add_breadcrumb).with('Home', root_path(locale: 'en'))
+        expect(controller).to receive(:add_breadcrumb).with('Dashboard', dashboard_path(locale: 'en'))
+        expect(controller).to receive(:add_breadcrumb).with('Workflow Roles', admin_workflow_roles_path(locale: 'en'))
+        get :index
+        expect(response).to be_success
+        expect(assigns[:presenter]).to be_kind_of Hyrax::Admin::WorkflowRolesPresenter
+        expect(response).to render_template('hyrax/dashboard')
+      end
+    end
+
+    context "when they don't have permission" do
+      it "throws a CanCan error" do
+        get :index
+        expect(response).to redirect_to main_app.new_user_session_path(locale: 'en')
+      end
+    end
+  end
+
+  describe '#create' do
+    context 'when you have permission' do
+      let(:form) { instance_double(Hyrax::Forms::WorkflowResponsibilityForm, save!: true) }
+
+      before do
+        allow(controller).to receive(:authorize!).with(:read, :admin_dashboard).and_return(true)
+        allow(controller).to receive(:authorize!).and_return(true)
+        allow(Hyrax::Forms::WorkflowResponsibilityForm).to receive(:new).and_return(form)
+      end
+
+      it 'is successful' do
+        post :create, params: { sipity_workflow_responsibility: {} }
+        expect(controller).to have_received(:authorize!).with(:create, Sipity::WorkflowResponsibility)
+        expect(form).to have_received(:save!)
+        expect(response).to redirect_to admin_workflow_roles_path
+      end
+    end
+
+    context "when they don't have permission" do
+      it 'throws a CanCan error' do
+        post :create, params: { sipity_workflow_responsibility: {} }
+        expect(response).to redirect_to main_app.new_user_session_path(locale: 'en')
+      end
+    end
+  end
+
+  describe '#destroy' do
+    context "when you have permission" do
+      let(:responsibility) { mock_model(Sipity::WorkflowResponsibility) }
+
+      before do
+        allow(controller).to receive(:authorize!).and_return(true)
+        allow(Sipity::WorkflowResponsibility).to receive(:find).with('1').and_return(responsibility)
+      end
+
+      it "is successful" do
+        delete :destroy, params: { id: 1 }
+        expect(controller).to have_received(:authorize!).with(:destroy, Sipity::WorkflowResponsibility)
+        expect(response).to redirect_to admin_workflow_roles_path
+      end
+    end
+
+    context "when they don't have permission" do
+      it "throws a CanCan error" do
+        get :index
+        expect(response).to redirect_to main_app.new_user_session_path(locale: 'en')
+      end
+    end
+  end
+end

data/spec/controllers/hyrax/admin/workflows_controller_spec.rb

@@ -0,0 +1,18 @@
+RSpec.describe Hyrax::Admin::WorkflowsController do
+  describe "#index" do
+    before do
+      expect(controller).to receive(:authorize!).with(:review, :submissions).and_return(true)
+    end
+    it "is successful" do
+      expect(controller).to receive(:add_breadcrumb).with('Home', root_path)
+      expect(controller).to receive(:add_breadcrumb).with('Dashboard', dashboard_path)
+      expect(controller).to receive(:add_breadcrumb).with('Tasks', '#')
+      expect(controller).to receive(:add_breadcrumb).with('Review Submissions', "/admin/workflows")
+
+      get :index
+      expect(response).to be_successful
+      expect(assigns[:status_list]).to be_kind_of Hyrax::Workflow::StatusListService
+      expect(assigns[:published_list]).to be_kind_of Hyrax::Workflow::StatusListService
+    end
+  end
+end

data/spec/controllers/hyrax/api/items_controller_spec.rb

@@ -0,0 +1,404 @@
+RSpec.describe Hyrax::API::ItemsController, type: :controller do
+  let(:arkivo_actor) { double Hyrax::Arkivo::Actor }
+  let!(:user) { create(:user) }
+  let!(:default_work) do
+    create(:work,
+           title: ['Foo Bar'],
+           user: user,
+           arkivo_checksum: '6872d21557992f6ad1d07375f19fbfaf')
+  end
+
+  before do
+    # Mock Arkivo Actor
+    allow(controller).to receive(:actor).and_return(arkivo_actor)
+    # Don't test characterization on these items; it breaks TravisCI and it's slow
+    allow(CharacterizeJob).to receive(:perform_later)
+  end
+
+  subject { response }
+
+  context 'with an HTTP GET or HEAD' do
+    let(:token) { user.arkivo_token }
+    let(:item) { FactoryBot.json(:post_item, token: token) }
+    let(:item_hash) { JSON.parse(item) }
+
+    context 'with a missing token' do
+      before { get :show, params: { format: :json, id: default_work.id } }
+
+      it "is unauthorized" do
+        expect(subject).to have_http_status(401)
+        expect(subject.body).to include('invalid user token:')
+      end
+    end
+
+    context 'with an unfamiliar token' do
+      before { get :show, params: { format: :json, id: default_work.id, token: get_token } }
+      let(:get_token) { 'foobar' }
+
+      it "is unauthorized" do
+        expect(subject).to have_http_status(401)
+        expect(subject.body).to include("invalid user token: #{get_token}")
+      end
+    end
+
+    context 'with an unauthorized resource' do
+      before do
+        allow_any_instance_of(User).to receive(:can?).with(:edit, default_work) { false }
+        get :show, params: { format: :json, id: default_work.id, token: token }
+      end
+
+      it 'is unauthorized' do
+        expect(subject).to have_http_status(401)
+        expect(assigns[:work]).to eq default_work
+        expect(subject.body).to include("#{user} lacks access to #{default_work}")
+      end
+    end
+
+    context 'with a resource not deposited via Arkivo' do
+      before do
+        allow_any_instance_of(GenericWork).to receive(:arkivo_checksum) { nil }
+        get :show, params: { format: :json, id: default_work.id, token: token }
+      end
+
+      it "is forbidden" do
+        expect(subject).to have_http_status(403)
+        expect(subject.body).to include("Forbidden: #{default_work} not deposited via Arkivo")
+      end
+    end
+
+    context 'with a resource not found in the repository' do
+      let(:relation) { double }
+
+      before do
+        allow(Hyrax::WorkRelation).to receive(:new).and_return(relation)
+        allow(relation).to receive(:find).with(default_work.id).and_raise(ActiveFedora::ObjectNotFoundError)
+        get :show, params: { format: :json, id: default_work.id, token: token }
+      end
+
+      it "is not found" do
+        expect(subject).to have_http_status(404)
+        expect(subject.body).to include("id '#{default_work.id}' not found")
+      end
+    end
+
+    context 'with an authorized Arkivo-deposited resource' do
+      before { get :show, params: { format: :json, id: default_work.id, token: token } }
+
+      specify do
+        expect(subject).to have_http_status(204)
+        expect(subject.body).to be_blank
+      end
+    end
+  end
+
+  context 'with an HTTP POST' do
+    context 'without an item' do
+      before { post :create, params: { format: :json } }
+
+      it "is an bad request" do
+        expect(subject).to have_http_status(400)
+        expect(subject.body).to include('no item parameter')
+      end
+    end
+
+    context 'with an invalid item' do
+      before { post :create, body: item, params: { format: :json } }
+      let(:item) { { foo: 'bar' }.to_json }
+
+      it "is a bad request" do
+        expect(subject).to have_http_status(400)
+        expect(subject.body).to include('The property \'#/\' did not contain a required property of \'token\'')
+      end
+    end
+
+    context 'post with a valid item and matching token' do
+      let(:deposited_file) { FileSet.where(label: item_hash['file']['filename']).take }
+      let(:a_work) { build :generic_work, id: '123' }
+      let!(:token) { user.arkivo_token }
+      let(:item) { FactoryBot.json(:post_item, token: token) }
+      let(:item_hash) { JSON.parse(item) }
+
+      before do
+        # Mock arkivo actor functions
+        allow(arkivo_actor).to receive(:create_work_from_item).and_return(a_work)
+        # https://github.com/samvera/active_fedora/issues/1251
+        allow(a_work).to receive(:persisted?).and_return(true)
+      end
+
+      it "delegates creating the work to the actor" do
+        expect(arkivo_actor).to receive(:create_work_from_item)
+        post :create, body: item, params: { format: :json }
+      end
+
+      # TODO: This test belongs in the Actor test as an integration test.
+      specify do
+        pending 'move test to arkivo actor spec as integration test.'
+        expect(response).to be_success
+        expect(response.status).to eq 201
+        expect(response.headers['Location']).to match %r{/api/items/.{9}}
+        expect(deposited_file).not_to be_nil
+        expect(deposited_work.arkivo_checksum).to eq item_hash['file']['md5']
+        expect(deposited_file.original_file.content).to eq "arkivo\n"
+        expect(deposited_work.resource_type).to eq [item_hash['metadata']['resourceType']]
+        expect(deposited_work.title).to eq [item_hash['metadata']['title']]
+        expect(deposited_work.description).to eq [item_hash['metadata']['description']]
+        expect(deposited_work.publisher).to eq [item_hash['metadata']['publisher']]
+        expect(deposited_work.date_created).to eq [item_hash['metadata']['dateCreated']]
+        expect(deposited_work.based_near).to eq [item_hash['metadata']['basedNear']]
+        expect(deposited_work.identifier).to eq [item_hash['metadata']['identifier']]
+        expect(deposited_work.related_url).to eq [item_hash['metadata']['url']]
+        expect(deposited_work.language).to eq [item_hash['metadata']['language']]
+        expect(deposited_work.rights).to eq [item_hash['metadata']['rights']]
+        expect(deposited_work.keyword).to match_array item_hash['metadata']['tags']
+        expect(deposited_work.creator).to match_array ['Doe, John', 'Babs McGee']
+        expect(deposited_work.contributor).to match_array ['Nadal, Rafael', 'Jane Doeski']
+      end
+    end
+
+    context 'with a valid item and unfamiliar token' do
+      before { post :create, body: item, params: { format: :json } }
+
+      let(:token) { 'unfamiliar_token' }
+      let(:item) { FactoryBot.json(:post_item, token: token) }
+
+      it "is unathorized" do
+        expect(response).not_to be_success
+        expect(subject.status).to eq 401
+        expect(subject.body).to include("invalid user token: #{token}")
+      end
+    end
+  end
+
+  context 'with an HTTP PUT' do
+    let(:put_item) { FactoryBot.json(:put_item, token: token) }
+    let(:token) { user.arkivo_token }
+    let(:gw) { build :generic_work, id: '123' }
+    let(:relation) { double }
+
+    before do
+      # Mock ActiveFedora
+      allow(Hyrax::WorkRelation).to receive(:new).and_return(relation)
+      allow(relation).to receive(:find).with(gw.id).and_return(gw)
+      # Mock Arkivo Actor
+      allow(arkivo_actor).to receive(:update_work_from_item)
+    end
+
+    context 'put update with a valid item, matching token, and authorized resource' do
+      let(:put_item_hash) { JSON.parse(put_item) }
+
+      let(:validator) { double Hyrax::Arkivo::SchemaValidator }
+
+      before do
+        # Mock Arkivo Validator and Actor
+        allow(Hyrax::Arkivo::SchemaValidator).to receive(:new).and_return(validator)
+        allow(validator).to receive(:call).and_return(true)
+        # Mock loading and authorizing
+        allow(controller).to receive(:my_load_and_authorize_resource).and_return(gw)
+      end
+
+      it 'calls the arkivo actor to update the work' do
+        expect(arkivo_actor).to receive(:update_work_from_item)
+        request.env['RAW_POST_DATA'] = put_item
+        put :update, params: { id: gw.id, format: :json }
+      end
+    end
+
+    context 'with a valid item, matching token, authorized resource, but not Arkivo-deposited' do
+      let(:non_arkivo_gw) { create :generic_work, id: 'abc123xyz', arkivo_checksum: nil }
+      let(:relation) { double }
+
+      before do
+        # Mock user authorization
+        allow(controller).to receive(:user).and_return(user)
+        allow(user).to receive(:can?).and_return(true)
+        # Mock ActiveFedora for non_arkivo_work
+        allow(Hyrax::WorkRelation).to receive(:new).and_return(relation)
+        allow(relation).to receive(:find).with(non_arkivo_gw.id).and_return(non_arkivo_gw)
+
+        # Post an update to a work with a nil arkivo_checksum
+        request.env['RAW_POST_DATA'] = put_item
+        put :update, params: { id: non_arkivo_gw.id, format: :json }
+      end
+
+      it "is forbidden" do
+        expect(subject).not_to be_success
+        expect(subject.status).to eq 403
+        expect(subject.body).to include("Forbidden: #{non_arkivo_gw} not deposited via Arkivo")
+      end
+    end
+
+    context 'with a valid item, matching token, missing resource' do
+      let(:relation) { double }
+
+      before do
+        allow(Hyrax::WorkRelation).to receive(:new).and_return(relation)
+        allow(relation).to receive(:find).with(gw.id) do
+          raise(ActiveFedora::ObjectNotFoundError)
+        end
+        request.env['RAW_POST_DATA'] = put_item
+        put :update, params: { id: gw.id, format: :json }
+      end
+
+      it "is not found" do
+        expect(subject).to have_http_status(404)
+        expect(subject.body).to include("id '#{gw.id}' not found")
+      end
+    end
+
+    context 'with a valid item, matching token, and unauthorized resource' do
+      before do
+        # Mock user authorization
+        allow(controller).to receive(:user).and_return(user)
+        allow(user).to receive(:can?).and_return(false)
+        # Post an update with an resource unauthorized for the user
+        request.env['RAW_POST_DATA'] = put_item
+        put :update, params: { id: gw.id, format: :json }
+      end
+
+      it "is unauthorized" do
+        expect(subject).not_to be_success
+        expect(assigns[:work]).to eq gw
+        expect(subject.status).to eq 401
+        expect(subject.body).to include("#{user} lacks access to #{gw}")
+      end
+    end
+
+    context 'with a valid item and unfamiliar token' do
+      let(:bad_token) { 'unfamiliar_token' }
+      let(:bad_token_item) { FactoryBot.json(:put_item, token: bad_token) }
+
+      before do
+        request.env['RAW_POST_DATA'] = bad_token_item
+        put :update, params: { id: gw.id, format: :json }
+      end
+
+      it "is unauthorized" do
+        expect(subject).not_to be_success
+        expect(subject.status).to eq 401
+        expect(subject.body).to include("invalid user token: #{bad_token}")
+      end
+    end
+
+    context 'with an invalid item' do
+      let(:invalid_item) { { foo: 'bar' }.to_json }
+
+      before do
+        request.env['RAW_POST_DATA'] = invalid_item
+        put :update, params: { id: gw.id, format: :json }
+      end
+
+      it "is a bad request" do
+        expect(subject).to have_http_status(400)
+        expect(subject.body).to include('The property \'#/\' did not contain a required property of \'token\'')
+      end
+    end
+  end
+
+  context 'with an HTTP DELETE' do
+    let(:token) { user.arkivo_token }
+    let(:item) { FactoryBot.json(:post_item, token: token) }
+    let(:item_hash) { JSON.parse(item) }
+    let(:gw) { build :generic_work, id: '123' }
+    let(:relation) { double }
+
+    before do
+      # Mock ActiveFedora
+      allow(Hyrax::WorkRelation).to receive(:new).and_return(relation)
+      allow(relation).to receive(:find).with(gw.id).and_return(gw)
+      # Mock ArkivoActor destroy work
+      allow(arkivo_actor).to receive(:destroy_work)
+    end
+
+    context 'with a missing token' do
+      before { delete :destroy, params: { format: :json, id: gw.id } }
+
+      it "is unauthorized." do
+        expect(subject).to have_http_status(401)
+        expect(subject.body).to include('invalid user token:')
+      end
+    end
+
+    context 'with an unfamiliar token' do
+      let(:bad_token) { 'foobar' }
+
+      before do
+        # Mock not being able to find the user due to bad token
+        allow(controller).to receive(:user).and_return(nil)
+        delete :destroy, params: { format: :json, id: gw.id, token: bad_token }
+      end
+
+      specify do
+        expect(subject).to have_http_status(401)
+        expect(subject.body).to include("invalid user token: #{bad_token}")
+      end
+    end
+
+    context 'with an unauthorized resource' do
+      before do
+        # Mock user being unauthorized
+        allow(controller).to receive(:user).and_return(user)
+        allow(user).to receive(:can?).with(:edit, gw) { false }
+        delete :destroy, params: { format: :json, id: gw.id, token: token }
+      end
+
+      it 'is unauthorized' do
+        expect(subject).to have_http_status(401)
+        expect(assigns[:work]).to eq gw
+        expect(subject.body).to include("#{user} lacks access to #{gw}")
+      end
+    end
+
+    context 'with a resource not deposited via Arkivo' do
+      let(:non_arkivo_gw) { create :generic_work, id: 'xyz789abc', arkivo_checksum: nil }
+
+      before do
+        # Mock user authorization
+        allow(controller).to receive(:user).and_return(user)
+        allow(user).to receive(:can?).and_return(true)
+        # Mock ActiveFedora for non_arkivo_work
+        allow(Hyrax::WorkRelation).to receive(:new).and_return(relation)
+        allow(relation).to receive(:find).with(non_arkivo_gw.id).and_return(non_arkivo_gw)
+        # Make call to destroy
+        delete :destroy, params: { format: :json, id: non_arkivo_gw.id, token: token }
+      end
+
+      it "is forbidden" do
+        expect(subject).to have_http_status(403)
+        expect(subject.body).to include("Forbidden: #{gw} not deposited via Arkivo")
+      end
+    end
+
+    context 'with a resource not found in the repository' do
+      let(:not_found_id) { '409' }
+
+      before do
+        # Mock ActiveFedora
+        allow(Hyrax::WorkRelation).to receive(:new).and_return(relation)
+        allow(relation).to receive(:find).with(not_found_id).and_raise(ActiveFedora::ObjectNotFoundError)
+        delete :destroy, params: { format: :json, id: not_found_id, token: token }
+      end
+
+      it "is not found" do
+        expect(subject).to have_http_status(404)
+        expect(subject.body).to include("id '#{not_found_id}' not found")
+      end
+    end
+
+    context 'with an authorized Arkivo-deposited resource' do
+      before do
+        # Mock user authorization
+        allow(controller).to receive(:user).and_return(user)
+        allow(user).to receive(:can?).and_return(true)
+        # Mock loading and authorizing
+        allow(controller).to receive(:my_load_and_authorize_resource).and_return(gw)
+      end
+
+      it "calls the actor to destroy the work" do
+        expect(arkivo_actor).to receive(:destroy_work)
+        delete :destroy, params: { format: :json, id: gw.id, token: token }
+        expect(subject).to have_http_status(204)
+        expect(subject.body).to be_blank
+      end
+    end
+  end
+end

data/spec/controllers/hyrax/api/zotero_controller_spec.rb

@@ -0,0 +1,162 @@
+RSpec.describe Hyrax::API::ZoteroController, type: :controller do
+  let(:user) { create(:user) }
+
+  subject { response }
+
+  context 'with an HTTP GET to /api/zotero' do
+    context 'with an unauthenticated client' do
+      before { get :initiate }
+
+      specify do
+        expect(subject).to have_http_status(302)
+        expect(flash[:alert]).to eq 'You need to sign in or sign up before continuing.'
+      end
+    end
+
+    context 'with an unregistered user' do
+      before do
+        allow_any_instance_of(Ability).to receive(:can?).with(:create, GenericWork).and_return(false)
+        sign_in user
+        get :initiate
+      end
+
+      specify do
+        expect(subject).to have_http_status(302)
+        expect(subject).to redirect_to(root_path)
+        expect(flash[:alert]).to eq 'You are not authorized to perform this operation'
+      end
+    end
+
+    context 'with an invalid key/secret combo' do
+      before do
+        allow(Hyrax::Zotero).to receive(:config) { broken_config }
+        sign_in user
+
+        stub_request(:get,
+                     %r{https://www.zotero.org/oauth/request\?oauth_callback=http://test\.host/api/zotero/callback&oauth_consumer_key=%7B:client_key=%3E%22foo%22,%20:client_secret=%3E%22bar%22%7D})
+          .to_return(status: 401, body: "oauth_problem=consumer_key_unknown")
+        get :initiate
+      end
+
+      let(:broken_config) { Hash.new(client_key: 'foo', client_secret: 'bar') }
+
+      specify do
+        expect(subject).to have_http_status(302)
+        expect(subject).to redirect_to(root_path)
+        expect(flash[:alert]).to eq 'Invalid Zotero client key pair'
+      end
+    end
+
+    describe 'redirects to Zotero' do
+      before do
+        allow(controller).to receive(:client) { client }
+        allow(client).to receive(:get_request_token) { token }
+        allow_any_instance_of(User).to receive(:zotero_token=)
+        sign_in user
+        get :initiate
+      end
+
+      let(:token) do
+        object_double(OAuth::RequestToken.new(client),
+                      authorize_url: 'https://www.zotero.org/oauth/authorize?identity=1&oauth_callback=http%3A%2F%2Ftest.host%2Fapi%2Fzotero%2Fcallback&oauth_token=bc2502f2750983c57224')
+      end
+      let(:client) do
+        OAuth::Consumer.new(Hyrax::Zotero.config['client_key'],
+                            Hyrax::Zotero.config['client_secret'],
+                            site: 'https://www.zotero.org',
+                            scheme: :query_string,
+                            http_method: :get,
+                            request_token_path: '/oauth/request',
+                            access_token_path: '/oauth/access',
+                            authorize_path: '/oauth/authorize')
+      end
+
+      specify do
+        expect(subject).to have_http_status(302)
+        expect(flash[:alert]).to be_nil
+        expect(subject.headers['Location']).to include('oauth_callback=http%3A%2F%2Ftest.host%2Fapi%2Fzotero%2Fcallback')
+      end
+    end
+  end
+
+  context 'with an HTTP POST/GET to /api/zotero/callback' do
+    context 'with an unauthenticated user' do
+      before { get :callback }
+
+      specify do
+        expect(subject).to have_http_status(302)
+        expect(flash[:alert]).to eq 'You need to sign in or sign up before continuing.'
+      end
+    end
+
+    context 'with a user who is not permitted to make works' do
+      before do
+        allow_any_instance_of(Ability).to receive(:can?).with(:create, GenericWork).and_return(false)
+        sign_in user
+        get :callback
+      end
+
+      specify do
+        expect(subject).to have_http_status(302)
+        expect(subject).to redirect_to(root_path)
+        expect(flash[:alert]).to eq 'You are not authorized to perform this operation'
+      end
+    end
+
+    context 'with a request lacking an oauth_token' do
+      before do
+        sign_in user
+        get :callback
+      end
+
+      specify do
+        expect(subject).to have_http_status(302)
+        expect(subject).to redirect_to(routes.url_helpers.edit_dashboard_profile_path(user, locale: 'en'))
+        expect(flash[:alert]).to eq 'Malformed request from Zotero'
+      end
+    end
+
+    context 'with a non-matching token' do
+      before do
+        sign_in user
+        get :callback, params: { oauth_token: 'woohoo', oauth_verifier: '12345' }
+      end
+
+      specify do
+        expect(subject).to have_http_status(302)
+        expect(subject).to redirect_to(routes.url_helpers.edit_dashboard_profile_path(user, locale: 'en'))
+        expect(flash[:alert]).to eq 'You have not yet connected to Zotero'
+      end
+    end
+
+    context 'with a signed-in, valid user' do
+      before do
+        allow_any_instance_of(User).to receive(:zotero_token) { user_token }
+        allow(Hyrax::Arkivo::CreateSubscriptionJob).to receive(:perform_later)
+        sign_in user
+        get :callback, params: { oauth_token: token_string, oauth_verifier: pin }
+      end
+
+      let(:token_string) { 'woohoo' }
+      let(:pin) { '12345' }
+      let(:user_token) do
+        double('token',
+               params: { oauth_token: token_string },
+               get_access_token: access_token)
+      end
+      let(:zuserid) { 'myzuser' }
+      let(:access_token) do
+        double('access', params: { userID: zuserid })
+      end
+
+      specify do
+        expect(subject).to have_http_status(302)
+        expect(Hyrax::Arkivo::CreateSubscriptionJob).to have_received(:perform_later)
+        expect(subject).to redirect_to(routes.url_helpers.dashboard_profile_path(user, locale: 'en'))
+        expect(flash[:alert]).to be_nil
+        expect(flash[:notice]).to eq 'Successfully connected to Zotero!'
+        expect(user.reload.zotero_userid).to eq zuserid
+      end
+    end
+  end
+end