worthwhile 0.0.1.alpha → 0.0.1

data/spec/controllers/catalog_controller_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe CatalogController do
+  before do
+    ActiveFedora::Base.delete_all
+  end
+
+  describe "when logged in" do
+    let(:user) { FactoryGirl.create(:user) }
+    let!(:work1) { FactoryGirl.create(:public_generic_work, user: user) }
+    let!(:work2) { FactoryGirl.create(:public_generic_work) }
+    let!(:linked_resource) { FactoryGirl.create(:linked_resource, user: user, batch:work1) }
+    let!(:collection) { FactoryGirl.create(:collection, user: user) }
+    let!(:file) { FactoryGirl.create(:generic_file, batch:work1) }
+    before do
+      sign_in user
+    end
+
+    context "when there is private content" do
+      let!(:private_work) { FactoryGirl.create(:private_generic_work) }
+      let!(:private_collection) { FactoryGirl.create(:private_collection) }
+
+      it "excludes it" do
+        get 'index'
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to match_array [work1.id, work2.id, collection.id]
+      end
+    end
+
+    context "Searching all content" do
+      it "should exclude linked resources" do
+        get 'index'
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to match_array [work1.id, work2.id, collection.id]
+      end
+    end
+
+    context "Searching all works" do
+      it "should return all the works" do
+        get 'index', 'f' => {'generic_type_sim' => 'Work'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to eq [work1.id, work2.id]
+      end
+    end
+
+    context "Searching all collections" do
+      it "should return all the works" do
+        get 'index', 'f' => {'generic_type_sim' => 'Collection'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to eq [collection.id]
+      end
+    end
+
+    context "searching just my works" do
+      it "should return just my works" do
+        get 'index', works: 'mine', 'f' => {'generic_type_sim' => 'Work'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to eq [work1.id]
+      end
+    end
+
+    context "searching for one kind of work" do
+      it "returns just the specified type" do
+        get 'index', 'f' => {'human_readable_type_sim' => 'Generic Work'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to include(work1.id, work2.id)
+      end
+    end
+
+    context "when json is requested for autosuggest of related works" do
+      let!(:work) { FactoryGirl.create(:generic_work, user: user, title: ["All my #{srand}"]) }
+      it "should return json" do
+        xhr :get, :index, format: :json, q: work.title
+        json = JSON.parse(response.body)
+        # Grab the doc corresponding to work and inspect the json
+        work_json = json["docs"].first
+        expect(work_json).to eq("pid"=>work.pid, "title"=> "#{work.title.first} (#{work.human_readable_type})")
+      end
+    end
+
+  end
+
+  describe "when logged in as a repository manager" do
+    let(:creating_user) { FactoryGirl.create(:user) }
+    let(:manager_user) { FactoryGirl.create(:user) }
+    let!(:work1) { FactoryGirl.create(:private_generic_work, user: creating_user) }
+    let!(:work2) { FactoryGirl.create(:embargoed_work, user: creating_user) }
+    let!(:collection) { FactoryGirl.create(:private_collection, user: creating_user) }
+
+    before do
+      allow_any_instance_of(User).to receive(:groups).and_return(['admin'])
+      sign_in manager_user
+    end
+
+    context "searching all works" do
+      it "should return other users' private works" do
+        get 'index', 'f' => {'generic_type_sim' => 'Work'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to include(work1.id)
+      end
+      it "should return other users' embargoed works" do
+        get 'index', 'f' => {'generic_type_sim' => 'Work'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to include(work2.id)
+      end
+      it "should return other users' private collections" do
+        get 'index', 'f' => {'generic_type_sim' => 'Collection'}
+        expect(response).to be_successful
+        expect(assigns(:document_list).map(&:id)).to include(collection.id)
+      end
+    end
+
+  end
+end

data/spec/controllers/collections_controller_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+
+describe CollectionsController do
+  routes { Hydra::Collections::Engine.routes }
+  before do
+    allow(controller).to receive(:has_access?).and_return(true)
+    allow_any_instance_of(User).to receive(:groups).and_return([])
+  end
+
+  let(:user) { FactoryGirl.create(:admin) }
+  let(:otheruser) { FactoryGirl.create(:user) }
+  let(:work1) { FactoryGirl.create(:generic_work, user:user) }
+  let(:work2) { FactoryGirl.create(:generic_work, user: user) }
+  let(:my_public_generic_work) { FactoryGirl.create(:public_generic_work, user:user) }
+  let(:my_other_public_generic_work) { FactoryGirl.create(:public_generic_work, user:user) }
+  let(:private_asset_not_mine) { FactoryGirl.create(:private_generic_work, user:otheruser) }
+  let(:public_asset_not_mine) { FactoryGirl.create(:public_generic_work, user:otheruser) }
+  let(:collection) { FactoryGirl.create(:collection, user:user) }
+
+  after (:all) do
+    Collection.destroy_all
+    GenericWork.destroy_all
+    User.destroy_all
+  end
+
+  describe '#new' do
+    before do
+      sign_in user
+    end
+
+    it 'should assign collection' do
+      get :new
+      expect(assigns(:collection)).to be_kind_of(Collection)
+    end
+  end
+
+  describe '#create' do
+    before do
+      sign_in user
+    end
+
+    it "should create a Collection" do
+      expect {
+        post :create, collection: {title: "My First Collection ", description: "The Description\r\n\r\nand more"}
+      }.to change {Collection.count}.by 1
+    end
+    it "should create a Collection with files I can access" do
+      expect {
+        post :create, collection: {title: "My own Collection ", description: "The Description\r\n\r\nand more"}, batch_document_ids:[work1.id, work2.id, private_asset_not_mine.id]
+      }.to change {Collection.count}.by 1
+      collection = assigns(:collection)
+      expect(collection.members).to include work1
+      expect(collection.members).to include work2
+      expect(collection.members).to_not include private_asset_not_mine
+      work1.destroy
+      work2.destroy
+      my_public_generic_work.destroy
+    end
+
+    it "should add docs to collection if batch ids provided and add the collection id to the documents int he colledction" do
+      post :create, batch_document_ids: [work1.id], collection: {title: "My Secong Collection ", description: "The Description\r\n\r\nand more"}
+      expect(assigns[:collection].members).to eq [work1]
+      asset_results = ActiveFedora::SolrService.instance.conn.get "select", params:{fq:["id:\"#{work1.id}\""],fl:['id',Solrizer.solr_name(:collection)]}
+      expect(asset_results["response"]["numFound"]).to eq 1
+      doc = asset_results["response"]["docs"].first
+      expect(doc["id"]).to eq work1.id
+      afterupdate = GenericFile.find(work1.pid)
+      expect(doc[Solrizer.solr_name(:collection)]).to eq afterupdate.to_solr[Solrizer.solr_name(:collection)]
+    end
+
+  end
+
+  describe "#update" do
+    before do
+      sign_in user
+    end
+    after do
+      collection.destroy
+      work1.destroy
+      work2.destroy
+      my_public_generic_work.destroy
+    end
+
+    it "should set collection on members" do
+      put :update, id: collection.id, collection: {members:"add"}, batch_document_ids:[my_public_generic_work.pid,work1.pid, work2.pid]
+      expect(response).to redirect_to collection_path(collection)
+      expect(assigns[:collection].members.map(&:pid)).to match_array([work2, my_public_generic_work, work1].map(&:pid))
+      asset_results = ActiveFedora::SolrService.instance.conn.get "select", params:{fq:["id:\"#{work2.pid}\""],fl:['id',Solrizer.solr_name(:collection)]}
+      expect(asset_results["response"]["numFound"]).to eq 1
+      doc = asset_results["response"]["docs"].first
+      expect(doc["id"]).to eq work2.id
+      afterupdate = GenericFile.find(work2.pid)
+      expect(doc[Solrizer.solr_name(:collection)]).to eq afterupdate.to_solr[Solrizer.solr_name(:collection)]
+      put :update, id: collection.id, collection: {members: "remove"}, batch_document_ids: [work2]
+      asset_results = ActiveFedora::SolrService.instance.conn.get "select", params:{fq:["id:\"#{work2.pid}\""],fl:['id',Solrizer.solr_name(:collection)]}
+      expect(asset_results["response"]["numFound"]).to eq 1
+      doc = asset_results["response"]["docs"].first
+      expect(doc["id"]).to eq work2.id
+      afterupdate = GenericFile.find(work2.pid)
+      expect(doc[Solrizer.solr_name(:collection)]).to be_nil
+    end
+
+    describe "adding members" do
+      it "should add members and update all of the relevant solr documents" do
+        expect(collection.members).to_not include my_other_public_generic_work
+        solr_doc_before_remove = ActiveFedora::SolrInstanceLoader.new(ActiveFedora::Base, my_other_public_generic_work.pid).send(:solr_doc)
+        expect(solr_doc_before_remove[Solrizer.solr_name(:collection)]).to be_nil
+        put :update, id: collection.id, collection: {members:"add"}, batch_document_ids:[my_other_public_generic_work.pid]
+        expect(collection.reload.members).to include my_other_public_generic_work
+        solr_doc_after_add = ActiveFedora::SolrInstanceLoader.new(ActiveFedora::Base, my_other_public_generic_work.pid).send(:solr_doc)
+        expect(solr_doc_after_add[Solrizer.solr_name(:collection)]).to eq [collection.pid]
+      end
+    end
+
+    describe "removing members" do
+      before do
+        collection.members << public_asset_not_mine
+        collection.save
+      end
+      it "should remove members and update all of the relevant solr documents" do
+        # BUG: This is returning inaccurate information
+        #     collection.reload.members.should include public_asset_not_mine
+        solr_doc_before_remove = ActiveFedora::SolrInstanceLoader.new(ActiveFedora::Base, public_asset_not_mine.pid).send(:solr_doc)
+        expect(solr_doc_before_remove[Solrizer.solr_name(:collection)]).to eq [collection.pid]
+        put :update, id: collection.id, collection: {members:"remove"}, batch_document_ids:[public_asset_not_mine.pid]
+        expect(collection.reload.members.count).to eq 0
+        solr_doc_after_remove = ActiveFedora::SolrInstanceLoader.new(ActiveFedora::Base, public_asset_not_mine.pid).send(:solr_doc)
+        expect(solr_doc_after_remove[Solrizer.solr_name(:collection)]).to be_nil
+      end
+    end
+  end
+
+  describe "#show" do
+    before do
+      collection.members = [work1,work2,my_public_generic_work,private_asset_not_mine,public_asset_not_mine]
+      collection.save
+      allow(controller).to receive(:authorize!).and_return(true)
+      allow(controller).to receive(:apply_gated_search)
+    end
+
+    context "when signed in" do
+      before do
+        sign_in user
+      end
+
+      it "should return the collection and its members I have access to" do
+        get :show, id: collection.id
+        expect(response).to be_successful
+        expect(assigns[:collection].title).to eq collection.title
+        ids = assigns[:member_docs].map(&:id)
+        expect(ids).to include work1.pid, work2.pid, my_public_generic_work.pid, public_asset_not_mine.pid
+        expect(ids).to_not include my_other_public_generic_work.pid, private_asset_not_mine.pid
+      end
+
+      context "as an admin" do
+        before { allow_any_instance_of(User).to receive(:groups).and_return(['admin']) }
+        it "shows all the collection members" do
+          get :show, id: collection.id
+          expect(response).to be_successful
+          expect(assigns[:collection].title).to eq collection.title
+          ids = assigns[:member_docs].map(&:id)
+          expect(ids).to include work1.pid, work2.pid, my_public_generic_work.pid, public_asset_not_mine.pid, private_asset_not_mine.pid
+          expect(ids).to_not include my_other_public_generic_work.pid
+        end
+      end
+
+      context "when query limited to 'mine'" do
+        it "should return only the collection members that I own" do
+          get :show, id: collection.id, owner:'mine'
+          expect(response).to be_successful
+          expect(assigns[:collection].title).to eq collection.title
+          ids = assigns[:member_docs].map(&:id)
+          expect(ids).to include work1.pid, work2.pid, my_public_generic_work.pid
+          expect(ids).to_not include my_other_public_generic_work.pid, private_asset_not_mine.pid, public_asset_not_mine.pid
+        end
+      end
+
+      context "when items have been added and removed" do
+        it "should return the items that are in the collection and not return items that have been removed" do
+          put :update, id: collection.id, collection: {members:"remove"}, batch_document_ids:[public_asset_not_mine.pid]
+          panm_solr_doc = ActiveFedora::SolrInstanceLoader.new(ActiveFedora::Base, public_asset_not_mine.pid).send(:solr_doc)
+          expect(panm_solr_doc[Solrizer.solr_name(:collection)]).to be_nil
+          controller.batch = nil
+          put :update, id: collection.id, collection: {members:"add"}, batch_document_ids:[my_other_public_generic_work.pid]
+          get :show, id: collection.id
+          ids = assigns[:member_docs].map(&:id)
+          expect(ids).to include work1.pid, work2.pid, my_public_generic_work.pid, my_other_public_generic_work.pid
+          expect(ids).to_not include public_asset_not_mine.pid
+        end
+      end
+    end
+
+    context "not signed in" do
+      it "should only show me public access files in the collection" do
+        get :show, id: collection.id
+        expect(assigns[:member_docs].count).to eq 2
+        ids = assigns[:member_docs].map(&:id)
+        expect(ids).to include my_public_generic_work.pid, public_asset_not_mine.pid
+      end
+    end
+  end
+
+  describe "#edit" do
+    before do
+      collection = Collection.new(title: "My collection", description: "My incredibly detailed description of the collection")
+      collection.apply_depositor_metadata(user.user_key)
+      collection.save
+      sign_in user
+    end
+
+    it "should not show flash" do
+      get :edit, id: collection.id
+      expect(flash[:notice]).to be_nil
+    end
+  end
+end

data/spec/controllers/curation_concern/generic_files_controller_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+
+describe CurationConcern::GenericFilesController do
+  let(:user) { FactoryGirl.create(:user) }
+  let(:file) { fixture_file_upload('files/image.png','image/png') }
+  let(:parent) { FactoryGirl.create(:generic_work, edit_users: [user.user_key], visibility:Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC) }
+
+  context "when signed in" do
+    before { sign_in user }
+
+    describe "#create" do
+      before do
+        Worthwhile::GenericFile.destroy_all
+        allow(Worthwhile::GenericFile).to receive(:new).and_return(Worthwhile::GenericFile.new(pid: 'test:123'))
+      end
+
+      context "on the happy path" do
+        let(:date_today) { Date.today }
+
+        before do
+          allow(Date).to receive(:today).and_return(date_today)
+        end
+
+        it "spawns a CharacterizeJob" do
+          s2 = double('one')
+          expect(CharacterizeJob).to receive(:new).with('test:123').and_return(s2)
+          expect(Sufia.queue).to receive(:push).with(s2).once
+          expect {
+            xhr :post, :create, files: [file], parent_id: parent,
+              generic_file: { "title"=>[""], visibility_during_embargo: "restricted",
+                              embargo_release_date: "2014-08-23",
+                              visibility_after_embargo: "open", visibility_during_lease: "open",
+                              lease_expiration_date: "2014-08-23",
+                              visibility_after_lease: "restricted",
+                              visibility: "restricted"}
+            expect(response).to be_success
+          }.to change { Worthwhile::GenericFile.count }.by(1)
+          expect(flash[:error]).to be_nil
+          saved_file = assigns[:generic_file].reload
+
+          expect(saved_file.label).to eq 'image.png'
+          expect(saved_file.batch).to eq parent
+
+          # Confirming that date_uploaded and date_modified were set
+          expect(saved_file.date_uploaded).to eq date_today
+          expect(saved_file.date_modified).to eq date_today
+          expect(saved_file.depositor).to eq user.email
+          version = saved_file.content.latest_version
+          expect(version.versionID).to eq "content.0"
+          expect(saved_file.content.version_committer(version)).to eq user.email
+
+          # Confirm that embargo/lease are not set.
+          expect(saved_file).to_not be_under_embargo
+          expect(saved_file).to_not be_active_lease
+          # Presently it's coping from the parent and disregarding what is on the form.
+          # expect(saved_file.visibility).to eq 'restricted'
+          expect(saved_file.visibility).to eq 'open'
+        end
+
+        it "copies visibility from the parent" do
+          s2 = double('one')
+          expect(CharacterizeJob).to receive(:new).with('test:123').and_return(s2)
+          expect(Sufia.queue).to receive(:push).with(s2).once
+          xhr :post, :create, files: [file], parent_id: parent
+          expect(assigns[:generic_file]).to be_persisted
+          saved_file = assigns[:generic_file].reload
+          expect(saved_file.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+        end
+      end
+
+      context "on something that isn't a file" do
+        it "should render error" do
+          xhr :post, :create, files: ['hello'], parent_id: parent,
+               permission: { group: { 'public' => 'read' } }, terms_of_service: '1'
+          expect(response.status).to eq 422
+          err = JSON.parse(response.body).first['error']
+          expect(err).to match(/no file for upload/i)
+        end
+      end
+
+      context "when the file has a virus" do
+        it "displays a flash error" do
+          skip
+          expect(Sufia::GenericFile::Actions).to receive(:virus_check).with(file.path).and_raise(Sufia::VirusFoundError.new('A virus was found'))
+          xhr :post, :create, files: [file], parent_id: parent,
+               permission: { group: { 'public' => 'read' } }, terms_of_service: '1'
+          expect(flash[:error]).to include('A virus was found')
+        end
+      end
+
+      context "when solr is down" do
+        it "should error out of create and save after on continuos rsolr error" do
+          allow_any_instance_of(Worthwhile::GenericFile).to receive(:save).and_raise(RSolr::Error::Http.new({},{}))
+
+          xhr :post, :create, files: [file], parent_id: parent,
+               permission: { group: { 'public' => 'read' } }, terms_of_service: '1'
+          expect(response.body).to include("Error occurred while creating generic file.")
+        end
+      end
+
+    end
+
+    describe "destroy" do
+      let(:generic_file) do
+        Worthwhile::GenericFile.new.tap do |gf|
+          gf.apply_depositor_metadata(user)
+          gf.batch = parent
+          gf.save!
+        end
+      end
+
+      it "should delete the file" do
+        expect(Worthwhile::GenericFile.find(generic_file.pid)).to be_kind_of Worthwhile::GenericFile
+        delete :destroy, id: generic_file
+        expect { Worthwhile::GenericFile.find(generic_file.pid) }.to raise_error ActiveFedora::ObjectNotFoundError
+        expect(response).to redirect_to [:curation_concern, parent]
+      end
+    end
+
+    describe "update" do
+      let!(:generic_file) do
+        Worthwhile::GenericFile.new.tap do |gf|
+          gf.apply_depositor_metadata(user)
+          gf.batch = parent
+          gf.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+          gf.save!
+        end
+      end
+
+      after do
+        generic_file.destroy
+      end
+
+      context "updating metadata" do
+        it "should be successful" do
+          post :update, id: generic_file, generic_file:
+            {title: 'new_title', tag: [''], permissions: { new_user_name: {'archivist1'=>'edit'}}}
+          expect(response).to redirect_to [:curation_concern, generic_file]
+        end
+
+        it "should go back to edit on an error" do
+          allow_any_instance_of(Worthwhile::GenericFile).to receive(:valid?).and_return(false)
+          post :update, id: generic_file, generic_file:
+            {title: 'new_title', tag: [''], permissions: { new_user_name: {'archivist1'=>'edit'}}}
+          expect(response).to be_successful
+          expect(response).to render_template('edit')
+          expect(assigns[:generic_file]).to eq generic_file
+        end
+
+        it "should add a new groups and users" do
+          skip
+          post :update, id: generic_file, generic_file:
+            { title: 'new_title', tag: [''], permissions: { new_group_name: {'group1'=>'read'}, new_user_name: {'user1'=>'edit'}}}
+
+          expect(assigns[:generic_file].read_groups).to eq ["group1"]
+          expect(assigns[:generic_file].edit_users).to include("user1", @user.user_key)
+        end
+
+        it "should update existing groups and users" do
+          skip
+          generic_file.read_groups = ['group3']
+          generic_file.save! # TODO slow test, more than one save.
+          post :update, id: generic_file, generic_file:
+            { title: 'new_title', tag: [''], permissions: { new_group_name: '', new_user_name: '', group: {'group3' => 'read' }}}
+          expect(assigns[:generic_file].read_groups).to eq ["group3"]
+        end
+
+        context "updating visibility" do
+          it "should apply public" do
+            new_visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+            post :update, id: generic_file, generic_file: {visibility: new_visibility, embargo_release_date:""}
+            expect(generic_file.reload.visibility).to eq new_visibility
+          end
+
+          it "should apply embargo" do
+            post :update, id: generic_file, generic_file: {
+              visibility: 'embargo',
+              visibility_during_embargo: "restricted",
+              embargo_release_date: "2099-09-05",
+              visibility_after_embargo: "open",
+              visibility_during_lease: "open",
+              lease_expiration_date: "2099-09-05",
+              visibility_after_lease: "restricted"
+            }
+            generic_file.reload
+            expect(generic_file).to be_under_embargo
+            expect(generic_file).to_not be_active_lease
+          end
+        end
+      end
+
+      context "updating file content" do
+        it "should be successful" do
+          s2 = double('one')
+          expect(CharacterizeJob).to receive(:new).with(generic_file.pid).and_return(s2)
+          expect(Sufia.queue).to receive(:push).with(s2).once
+          post :update, id: generic_file, files: [file]
+          expect(response).to redirect_to [:curation_concern, generic_file]
+          expect(generic_file.reload.label).to eq 'image.png'
+        end
+      end
+
+      context "restoring an old version" do
+        before do
+          allow(Sufia.queue).to receive(:push) # don't run characterization jobs
+          # Create version 0
+          generic_file.add_file('test123', 'content', 'file.txt')
+          generic_file.save!
+
+          # Create version 1
+          generic_file.add_file('<xml>This is version 2</xml>', 'content', 'md.xml')
+          generic_file.save!
+        end
+
+        it "should be successful" do
+          post :update, id: generic_file, revision: 'content.0'
+          expect(response).to redirect_to [:curation_concern, generic_file]
+          reloaded = generic_file.reload.content
+          expect(reloaded.latest_version.versionID).to eq 'content.2'
+          expect(reloaded.content).to eq 'test123'
+          expect(reloaded.mimeType).to eq 'text/plain'
+        end
+      end
+    end
+  end
+
+  context "someone elses files" do
+    let(:generic_file) do
+      Worthwhile::GenericFile.new.tap do |gf|
+        gf.apply_depositor_metadata('archivist1@example.com')
+        gf.read_groups = ['public']
+        gf.batch = parent
+        gf.save!
+      end
+    end
+    after do
+      # GenericFile.find('sufia:test5').destroy
+    end
+    describe "edit" do
+      it "should give me a flash error" do
+        get :edit, id: generic_file
+        expect(response.code).to eq '401'
+        expect(response).to render_template(:unauthorized)
+      end
+    end
+    describe "view" do
+      it "should show me the file" do
+        get :show, id: generic_file
+        expect(response).to be_success
+      end
+    end
+    it "should not let the user submit if they logout" do
+      get :new, parent_id: parent
+      expect(response).to redirect_to root_path
+      expect(flash[:alert]).to eq "You are not authorized to access this page."
+    end
+  end
+end