curation_concerns 0.1.0

data/spec/support/features/session_helpers.rb

@@ -0,0 +1,41 @@
+module Features
+  module SessionHelpers
+    # Regular login
+    def login_as(user)
+      user.reload # because the user isn't re-queried via Warden
+      super(user, scope: :user, run_callbacks: false)
+    end
+    # Regular logout
+    def logout(user=:user)
+      super(user)
+    end
+
+    # Poltergeist-friendly sign-up
+    # Use this in feature tests
+    def sign_up_with(email, password)
+      Capybara.exact = true
+      visit new_user_registration_path
+      fill_in 'Email', with: email
+      fill_in 'Password', with: password
+      fill_in 'Password confirmation', with: password
+      click_button 'Sign up'
+    end
+
+    # Poltergeist-friendly sign-in
+    # Use this in feature tests
+    def sign_in(who = :user)
+      user = if who.instance_of?(User)
+               who
+             else
+               FactoryGirl.build(:user).tap do |u|
+                 u.save!
+               end
+             end
+      visit new_user_session_path
+      fill_in 'Email', with: user.email
+      fill_in 'Password', with: user.password
+      click_button 'Log in'
+      expect(page).to_not have_text 'Invalid email or password.'
+    end
+  end
+end

data/spec/support/features.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../features/session_helpers', __FILE__)
+require File.expand_path('../features/fixture_file_upload', __FILE__)
+
+RSpec.configure do |config|
+  config.include Warden::Test::Helpers, type: :feature
+  config.include Features::SessionHelpers, type: :feature
+  config.include Features::FixtureFileUpload
+  
+  config.before(:each, type: :feature) do
+    Warden.test_mode!
+    @old_resque_inline_value = Resque.inline
+    Resque.inline = true
+  end
+
+  config.after(:each, type: :feature) do
+    Warden.test_reset!
+    Resque.inline = @old_resque_inline_value
+  end
+end

data/spec/support/shared/shared_examples_has_dc_metadata.rb

@@ -0,0 +1,17 @@
+shared_examples 'has_dc_metadata' do
+
+  # Single-valued fields
+  it { should have_unique_field(:created) }
+  it { should have_unique_field(:date_uploaded) }
+  it { should have_unique_field(:date_modified) }
+
+  # Multivalued fields
+  it { should have_multivalue_field(:content_format) }
+  it { should have_multivalue_field(:description) }
+  it { should have_multivalue_field(:identifier) }
+  it { should have_multivalue_field(:publisher) }
+  it { should have_multivalue_field(:source) }
+  it { should have_multivalue_field(:language) }
+  it { should have_multivalue_field(:subject) }
+
+end

data/spec/support/shared/shared_examples_is_embargoable.rb

@@ -0,0 +1,8 @@
+shared_examples 'is_embargoable' do
+
+  it "has an embargo_release_date attribute" do
+    expect(subject).to respond_to(:embargo_release_date)
+    expect(subject).to respond_to(:embargo_release_date=)
+  end
+
+end

data/spec/support/shared/shared_examples_with_access_rights.rb

@@ -0,0 +1,63 @@
+shared_examples 'with_access_rights' do
+
+  def prepare_subject_for_access_rights_visibility_test!
+    # I am doing this because the actual persistence of the objects requires
+    # so much more and I don't know for certain if it has happened.
+    allow(subject).to receive(:persisted?).and_return(true)
+  end
+
+  it "has an under_embargo?" do
+    expect {
+      subject.under_embargo?
+    }.to_not raise_error
+  end
+
+  it "has a visibility attribute" do
+    expect(subject).to respond_to(:visibility)
+    expect(subject).to respond_to(:visibility=)
+  end
+
+  describe 'open access' do
+    it "has an open_access?" do
+      expect {
+        subject.open_access?
+      }.to_not raise_error
+    end
+
+    it 'sets visibility' do
+      prepare_subject_for_access_rights_visibility_test!
+      subject.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      expect(subject).to be_open_access
+    end
+  end
+
+  describe 'authenticated access' do
+    it 'sets visibility' do
+      prepare_subject_for_access_rights_visibility_test!
+      subject.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
+      expect(subject).to be_authenticated_only_access
+    end
+
+    it "has an authenticated_only_access?" do
+      expect {
+        subject.authenticated_only_access?
+      }.to_not raise_error
+    end
+  end
+
+  describe 'private access' do
+    it 'sets visibility' do
+      prepare_subject_for_access_rights_visibility_test!
+      subject.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+      expect(subject).to be_private_access
+    end
+
+
+    it "has an private_access?" do
+      expect {
+        subject.private_access?
+      }.to_not raise_error
+    end
+  end
+
+end

data/spec/tasks/rake_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'rake'
+
+describe "Rake tasks" do
+
+  describe "curation_concerns:migrate" do
+    let(:namespaced_id) { "curation_concerns:123" }
+    let(:corrected_id)  { "123" }
+    before do
+      load File.expand_path("../../../curation_concerns-models/lib/tasks/migrate.rake", __FILE__)
+      Rake::Task.define_task(:environment)
+    end
+
+    describe "deleting the namespace from ChecksumAuditLog#generic_file_id" do
+      before do
+        ChecksumAuditLog.create(generic_file_id: namespaced_id)
+        Rake::Task["curation_concerns:migrate:audit_logs"].invoke
+      end
+      subject { ChecksumAuditLog.first.generic_file_id }
+      it { is_expected.to eql corrected_id }
+    end
+  end
+
+end

data/spec/test_app_templates/Gemfile.extra

@@ -0,0 +1 @@
+# placeholder to use for pinning against specific gem commit references

data/spec/test_app_templates/lib/generators/test_app_generator.rb

@@ -0,0 +1,55 @@
+require 'rails/generators'
+
+class TestAppGenerator < Rails::Generators::Base
+  source_root "../../spec/test_app_templates"
+
+  def install_engine
+    generate 'curation_concerns:install'
+  end
+
+  def run_migrations
+    rake "db:migrate"
+  end
+
+  def generate_generic_work
+    generate 'curation_concerns:work GenericWork'
+  end
+
+  def remove_generic_work_specs
+    remove_file 'spec/models/generic_work_spec.rb'
+    remove_file 'spec/controllers/curation_concerns/generic_works_controller_spec.rb'
+    remove_file 'spec/actors/curation_concerns/generic_work_actor_spec.rb'
+  end
+
+  def enable_av_transcoding
+    file_path = "app/models/generic_file.rb"
+      inject_into_file file_path, after: /include ::CurationConcerns::GenericFileBehavior/ do
+      %q(
+  directly_contains_one :ogg, through: :files, type: ::RDF::URI("http://pcdm.org/use#ServiceFile"), class_name: "Hydra::PCDM::File"
+  directly_contains_one :mp3, through: :files, type: ::RDF::URI("http://pcdm.org/use#File"), class_name: "Hydra::PCDM::File"    
+  directly_contains_one :mp4, through: :files, type: ::RDF::URI("http://pcdm.org/use#ServiceFile"), class_name: "Hydra::PCDM::File"
+  directly_contains_one :webm, through: :files, type: ::RDF::URI("http://pcdm.org/use#File"), class_name: "Hydra::PCDM::File"
+
+
+  # This was taken directly from Sufia's GenericFile::Derivative.
+  makes_derivatives do |obj|
+    case obj.original_file.mime_type
+    when *pdf_mime_types
+      obj.transform_file :original_file, thumbnail: { format: 'jpg', size: '338x493' }
+    when *office_document_mime_types
+      obj.transform_file :original_file, { thumbnail: { format: 'jpg', size: '200x150>' } }, processor: :document
+     when *audio_mime_types
+      obj.transform_file :original_file, { mp3: { format: 'mp3' }, ogg: { format: 'ogg' } }, processor: :audio
+    when *video_mime_types
+      obj.transform_file :original_file, { webm: { format: 'webm' }, mp4: { format: 'mp4' }, thumbnail: { format: 'jpg' } }, processor: :video
+    when *image_mime_types
+      obj.transform_file :original_file, thumbnail: { format: 'jpg', size: '200x150>' }
+    end
+  end
+    )
+    end
+
+
+  end
+
+end

data/spec/views/catalog/index.html.erb_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe 'catalog/index.html.erb' do
+  let(:collection) { stub_model(Collection, title: 'collection1', id: 'abc123') }
+  let(:doc) { SolrDocument.new(collection.to_solr) }
+
+  before do
+    view.extend CurationConcerns::CollectionsHelper
+    view.extend CurationConcerns::CatalogHelper
+    allow(view).to receive(:search_action_path).and_return('/catalog')
+    allow(view).to receive(:has_search_parameters?).and_return(true)
+
+
+    allow(view).to receive(:current_users_collections).and_return([])
+    allow(view).to receive(:blacklight_config).and_return(CatalogController.blacklight_config)
+    stub_template 'catalog/_search_sidebar.html.erb' => ''
+    stub_template 'catalog/_search_header.html.erb' => ''
+    allow(view).to receive(:render_opensearch_response_metadata).and_return('')
+    allow(view).to receive(:render_grouped_response?).and_return(false)
+    allow(view).to receive(:search_session).and_return({})
+    allow(view).to receive(:current_search_session).and_return(nil)
+    allow(view).to receive(:document_counter_with_offset).and_return(5)
+
+    params[:view] = 'gallery'
+
+    resp = []
+    assign(:response, resp )
+    allow(resp).to receive(:total_pages).and_return(1)
+    allow(resp).to receive(:current_page).and_return(1)
+    allow(resp).to receive(:limit_value).and_return(10)
+    allow(resp).to receive(:empty?).and_return(false)
+
+    # This stubs out the SolrDocument#to_model
+    allow(ActiveFedora::Base).to receive(:load_instance_from_solr).with('abc123', doc).and_return(collection)
+
+    assign(:document_list, [doc])
+  end
+
+  context "when user does not have permissions" do
+    before  { allow(view).to receive(:can?).and_return(false) }
+    it 'appears on page without error' do
+      render
+      page = Capybara::Node::Simple.new(rendered)
+      expect(page).to have_link(collection.title)
+      expect(page).to have_content "List of files deposited"
+    end
+  end
+  context "when user has all the permissions" do
+    before  { allow(view).to receive(:can?).and_return(true) }
+    it 'appears on page without error' do
+      render
+      page = Capybara::Node::Simple.new(rendered)
+      expect(page).to have_link(collection.title)
+      expect(page).to have_content "List of files deposited"
+    end
+  end
+
+
+end

data/spec/views/curation_concerns/base/_attributes.html.erb_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'curation_concerns/base/_attributes.html.erb' do
+
+  let(:creator)     { 'Bilbo' }
+  let(:contributor) { 'Frodo' }
+  let(:subject)     { 'history' }
+
+  let(:curation_concern) { double(creator: [creator],
+                                  contributor: [contributor],
+                                  subject: [subject]) }
+
+  before do
+    allow(view).to receive(:dom_class) { '' }
+    allow(view).to receive(:permission_badge_for) { '' }
+
+    render partial: 'attributes', locals: { curation_concern: curation_concern }
+  end
+
+  it 'has links to search for other objects with the same metadata' do
+    expect(rendered).to have_link(creator, href: catalog_index_path(search_field: 'creator', q: creator))
+    expect(rendered).to have_link(contributor, href: catalog_index_path(search_field: 'contributor', q: contributor))
+    expect(rendered).to have_link(subject, href: catalog_index_path(search_field: 'subject', q: subject))
+  end
+end

data/spec/views/curation_concerns/base/show.html.erb_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'curation_concerns/base/show.html.erb' do
+
+  let!(:curation_concern) { FactoryGirl.create(:private_generic_work) }
+
+  context "for editors" do
+    before do
+      allow(view).to receive(:can?).and_return(true)
+    end
+
+    it 'has links to edit' do # and add to collections' do
+      render file: 'curation_concerns/base/show', locals: { curation_concern: curation_concern }
+      expect(rendered).to have_link("Edit This Generic Work", href: edit_polymorphic_path([:curation_concerns, curation_concern]))
+      # expect(rendered).to have_selector "a[data-toggle='modal'][data-target='##{curation_concern.to_param}-modal']", text: "Add to a Collection"
+      # expect(rendered).to have_selector("div.modal##{curation_concern.to_param}-modal form[action='#{collections.collections_path}'] input[value='Add to collection']")
+    end
+  end
+
+  context "for non-editors" do
+    it 'does not have links to edit' do #, but has add to collection' do
+      render file: 'curation_concerns/base/show', locals: { curation_concern: curation_concern }
+      expect(rendered).not_to have_content("Edit this Generic Work")
+
+      # expect(rendered).to have_selector "a[data-toggle='modal'][data-target='##{curation_concern.to_param}-modal']", text: "Add to a Collection"
+      # expect(rendered).to have_selector("div.modal##{curation_concern.to_param}-modal form[action='#{collections.collections_path}'] input[value='Add to collection']")
+    end
+  end
+end

data/spec/views/curation_concerns/permissions/confirm.html.erb_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'curation_concerns/permissions/confirm.html.erb' do
+  before do
+    allow(curation_concern).to receive(:to_param).and_return('test:123')
+    allow(view).to receive(:curation_concern).and_return(curation_concern)
+    render
+  end
+
+  context "when the work is embargoed" do
+    let(:curation_concern) { build(:embargoed_work, embargo_date: '2099-09-26'.to_date) }
+
+    it "should have a message about embargos" do
+      expect(rendered).to have_content "You've applied an embargo to this Generic Work, Test title, changing its visibility to Private until September 26th, 2099. Would you like to apply the same embargo to all of the files within the Generic Work as well?"
+    end
+  end
+
+  context "when the work is leased" do
+    let(:curation_concern) { build(:leased_work, embargo_date: '2099-09-26'.to_date) }
+
+    it "should have a message about leases" do
+      expect(rendered).to have_content "You've applied a lease to this Generic Work, Test title, changing its visibility to Open Access until September 26th, 2099. Would you like to apply the same lease to all of the files within the Generic Work as well?"
+    end
+  end
+
+  context "when the work is not embargoed" do
+    let(:curation_concern) { build(:work) }
+
+    it "should have a message about visibility" do
+      expect(rendered).to have_content "You've changed the permissions on this Generic Work, Test title, making it visible to Private. Would you like change all of the files within the Generic Work to Private as well?"
+    end
+  end
+end

data/spec/views/shared/_add_content.html.erb_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'shared/_add_content.html.erb' do
+
+  context "for people who can create Works and Collections" do
+    it 'has links to create works and collections' do
+      allow(view).to receive(:current_user).and_return(FactoryGirl.create(:admin))
+      allow(view).to receive(:can?).and_return(true)
+      render partial: 'shared/add_content'
+      CurationConcerns.configuration.curation_concerns.each do |curation_concern_type|
+        expect(rendered).to have_link("New #{curation_concern_type.human_readable_type}", href: new_polymorphic_path([:curation_concerns, curation_concern_type]))
+      end
+      expect(rendered).to have_link("Add a Collection", href: collections.new_collection_path)
+    end
+  end
+  context "for people who can only create Collections" do
+    it 'has links to add collections but not to add works' do
+      allow(view).to receive(:current_user).and_return(FactoryGirl.create(:admin))
+      allow(view).to receive(:can?).and_return(true)
+      allow(view).to receive(:can_ever_create_works?).and_return(false)
+      render partial: 'shared/add_content'
+      CurationConcerns.configuration.curation_concerns.each do |curation_concern_type|
+        expect(rendered).not_to have_link("New #{curation_concern_type.human_readable_type}", href: new_polymorphic_path([:curation_concerns, curation_concern_type]))
+      end
+      expect(rendered).to have_link("Add a Collection", href: collections.new_collection_path)
+    end
+  end
+
+  context "for people who cannot create anything" do
+    it 'does not have links to add works or collections' do
+      allow(view).to receive(:current_user).and_return(FactoryGirl.create(:user))
+      allow(view).to receive(:can?).and_return(false)
+      render partial: 'shared/add_content'
+      expect(rendered).not_to have_text("Add")
+      expect(rendered).not_to have_text("Admin")
+      CurationConcerns.configuration.curation_concerns.each do |curation_concern_type|
+        expect(rendered).not_to have_link("New #{curation_concern_type.human_readable_type}", href: new_polymorphic_path([:curation_concerns, curation_concern_type]))
+      end
+      expect(rendered).not_to have_link("Add a Collection", href: collections.new_collection_path)
+    end
+  end
+end

data/spec/views/shared/_my_actions.html.erb_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe 'shared/_my_actions.html.erb' do
+  include CurationConcerns::SearchPathsHelper
+  context "for admins" do
+    it 'has links to edit and add to collections' do
+      allow(view).to receive(:current_user).and_return(FactoryGirl.create(:user))
+      allow(view).to receive(:can?).and_return(true)
+      render partial: 'shared/my_actions'
+      expect(rendered).to have_link("My Works", href: search_path_for_my_works)
+      expect(rendered).to have_link("My Collections", href: search_path_for_my_collections)
+    end
+  end
+  context "for non-admins" do
+    it 'does not have links to edit' do
+      allow(view).to receive(:current_user).and_return(FactoryGirl.create(:user))
+      allow(view).to receive(:can?).and_return(false)
+      render partial: 'shared/my_actions'
+      expect(rendered).not_to have_text("My Works")
+      expect(rendered).not_to have_text("My Collections")
+    end
+  end
+end

data/spec/workers/visibility_copy_worker_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe VisibilityCopyWorker do
+
+  describe "an open access work" do
+    let(:work) { FactoryGirl.create(:work_with_files) }
+    subject { VisibilityCopyWorker.new(work.id) }
+
+    it "should have no content at the outset" do
+      expect(work.generic_files.first.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+    end
+
+    it "should copy visibility to its contained files" do
+      work.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      work.save
+      subject.run
+      work.reload.generic_files.each do |file|
+        expect(file.visibility).to eq 'open'
+      end
+    end
+  end
+
+  describe "an embargoed work" do
+    let(:work) { FactoryGirl.create(:embargoed_work_with_files) }
+    subject { VisibilityCopyWorker.new(work.id) }
+
+    before do
+      expect(work.visibility).to eq 'restricted'
+      expect(work).to be_under_embargo
+      expect(work.generic_files.first).to_not be_under_embargo
+    end
+
+    context "when run" do
+      before do
+        subject.run
+        work.reload
+      end
+      let(:file) { work.generic_files.first }
+
+      it "should copy visibility to its contained files and apply a copy of the embargo to the files" do
+        expect(file).to be_under_embargo
+        expect(file.embargo.id).to_not eq work.embargo.id
+      end
+    end
+  end
+
+  describe "an leased work" do
+    let(:work) { FactoryGirl.create(:leased_work_with_files) }
+    subject { VisibilityCopyWorker.new(work.id) }
+
+    before do
+      expect(work.visibility).to eq 'open'
+      expect(work).to be_active_lease
+      expect(work.generic_files.first).to_not be_active_lease
+    end
+
+    context "when run" do
+      before do
+        subject.run
+        work.reload
+      end
+      let(:file) { work.generic_files.first }
+
+      it "should copy visibility to its contained files and apply a copy of the lease to the files" do
+        expect(file).to be_active_lease
+        expect(file.lease.id).to_not eq work.lease.id
+      end
+    end
+  end
+end

data/tasks/jetty.rake

@@ -0,0 +1,15 @@
+namespace :jetty do
+  desc "Copies the default Solr & Fedora configs into the bundled Hydra Testing Server"
+  task :config do
+    Rake::Task['curation_concerns:jetty:download_jars'].invoke
+    Rake::Task["jetty:config_solr"].invoke
+  end
+
+  desc "Copies the contents of solr_conf into the Solr development-core and test-core of Testing Server"
+  task :config_solr do
+    FileList['solr_conf/conf/*'].each do |f|
+      cp("#{f}", 'jetty/solr/development-core/conf/', verbose: true)
+      cp("#{f}", 'jetty/solr/test-core/conf/', verbose: true)
+    end
+  end
+end

data/tasks/release.rake

@@ -0,0 +1,93 @@
+root    = File.expand_path('../../', __FILE__)
+version = File.read("#{root}/VERSION").strip
+tag     = "v#{version}"
+
+directory 'pkg'
+
+['curation_concerns-models', 'curation_concerns'].each do |framework|
+  namespace framework do
+    gem     = "pkg/#{framework}-#{version}.gem"
+    gemspec = "#{framework}.gemspec"
+
+    task :clean do
+      rm_f gem
+    end
+
+    task :update_version_rb do
+      glob = root.dup
+      if framework == "curation_concerns"
+        glob << "/lib/*"
+      else
+        glob << "/#{framework}/lib/**"
+      end
+      glob << "/version.rb"
+
+      file = Dir[glob].first
+      if file
+        ruby = File.read(file)
+
+        major, minor, tiny, pre = version.split('.')
+        pre = pre ? pre.inspect : "nil"
+
+        ruby.gsub!(/^(\s*)VERSION = ".*?"$/, "\\1VERSION = \"#{version}\"")
+        raise "Could not insert VERSION in #{file}" unless $1
+        File.open(file, 'w') { |f| f.write ruby }
+      end
+    end
+    task gem => %w(update_version_rb pkg) do
+      cmd = ""
+      cmd << "cd #{framework} && " unless framework == "curation_concerns"
+      cmd << "gem build #{gemspec} && mv #{framework}-#{version}.gem #{root}/pkg/"
+      sh cmd
+    end
+
+    task build: [:clean, gem]
+    task install: :build do
+      sh "gem install #{gem}"
+    end
+
+    task prep_release: [:ensure_clean_state, :build]
+
+    task push: :build do
+      sh "gem push #{gem}"
+    end
+  end
+end
+
+
+namespace :all do
+  task build: ['curation_concerns-models:build', 'curation_concerns:build']
+  task install: ['curation_concerns-models:install', 'curation_concerns:install']
+  task push: ['curation_concerns-models:push', 'curation_concerns:push']
+
+  task :ensure_clean_state do
+    unless `git status -s | grep -v VERSION | grep -v History.md`.strip.empty?
+      abort "[ABORTING] `git status` reports a dirty tree. Make sure all changes are committed"
+    end
+
+    unless ENV['SKIP_TAG'] || `git tag | grep "#{tag}$"`.strip.empty?
+      abort "[ABORTING] `git tag` shows that #{tag} already exists. Has this version already\n"\
+            "           been released? Git tagging can be skipped by setting SKIP_TAG=1"
+    end
+  end
+
+  task :commit do
+    File.open('pkg/commit_message.txt', 'w') do |f|
+      f.puts "# Preparing for #{version} release\n"
+      f.puts
+      f.puts "# UNCOMMENT THE LINE ABOVE TO APPROVE THIS COMMIT"
+    end
+
+    sh "git add . && git commit --verbose --template=pkg/commit_message.txt"
+    rm_f "pkg/commit_message.txt"
+  end
+
+  task :tag do
+    sh "git tag #{tag}"
+    sh "git push --tags"
+  end
+
+  desc "Release both curation_concerns and curation_concerns-models and update the version to #{version} in all locations"
+  task release: %w(ensure_clean_state build commit tag push)
+end
+