test_hyrax 0.0.1.alpha

data/spec/lib/hyrax/resource_sync/capability_list_writer_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::ResourceSync::CapabilityListWriter do
+  let(:sitemap) { 'http://www.sitemaps.org/schemas/sitemap/0.9' }
+  let(:rs) { 'http://www.openarchives.org/rs/terms/' }
+
+  let(:resource_list) { 'http://example.com/resourcelist.xml' }
+  let(:change_list) { 'http://example.com/changelist.xml' }
+  let(:description) { 'http://example.com/resourcesync_description.xml' }
+
+  subject do
+    described_class.new(resource_list_url: resource_list,
+                        change_list_url: change_list,
+                        description_url: description).write
+  end
+  let(:xml) { Nokogiri::XML.parse(subject) }
+
+  it "has url to the capability list" do
+    description_href = xml.xpath('/x:urlset/rs:ln[@rel="up"]/@href', 'x' => sitemap, 'rs' => rs).map(&:value)
+    expect(description_href).to eq [description]
+
+    capability = xml.xpath('/x:urlset/rs:md/@capability', 'x' => sitemap, 'rs' => rs).map(&:value)
+    expect(capability).to eq ["capabilitylist"]
+
+    url = xml.xpath('//x:url[1]/x:loc', 'x' => sitemap).text
+    expect(url).to eq resource_list
+    capability = xml.xpath('//x:url[1]/rs:md/@capability', 'x' => sitemap, 'rs' => rs).map(&:value)
+    expect(capability).to eq ["resourcelist"]
+
+    url = xml.xpath('//x:url[2]/x:loc', 'x' => sitemap).text
+    expect(url).to eq change_list
+    capability = xml.xpath('//x:url[2]/rs:md/@capability', 'x' => sitemap, 'rs' => rs).map(&:value)
+    expect(capability).to eq ["changelist"]
+  end
+end

data/spec/lib/hyrax/resource_sync/change_list_writer_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::ResourceSync::ChangeListWriter do
+  let(:sitemap) { 'http://www.sitemaps.org/schemas/sitemap/0.9' }
+
+  let(:public_collection) { create(:public_collection) }
+  let(:public_work) { create(:public_generic_work) }
+  let(:file_set) { create(:file_set, :public) }
+
+  let(:capability_list) { 'http://example.com/capabilityList.xml' }
+  before do
+    # These private items should not show up.
+    create(:private_collection)
+    create(:work)
+
+    # Sleep in between to ensure modified dates are different
+    public_collection
+    sleep(1)
+    public_work
+    sleep(1)
+    file_set
+  end
+
+  subject { described_class.new(resource_host: 'example.com', capability_list_url: capability_list).write }
+  let(:xml) { Nokogiri::XML.parse(subject) }
+
+  it "has a list of resources" do
+    capability = xml.xpath('//rs:ln/@href', 'rs' => "http://www.openarchives.org/rs/terms/").text
+    expect(capability).to eq capability_list
+
+    expect(location(1)).to eq "http://example.com/concern/file_sets/#{file_set.id}"
+    expect(change(1)).to eq "created"
+
+    expect(location(2)).to eq "http://example.com/concern/generic_works/#{public_work.id}"
+    expect(change(2)).to eq "created"
+
+    expect(location(3)).to eq "http://example.com/collections/#{public_collection.id}"
+    expect(change(3)).to eq "created"
+
+    expect(xml.xpath('//x:url', 'x' => sitemap).count).to eq 3
+  end
+
+  def change(n)
+    query(n, 'rs:md/@change', 'rs' => "http://www.openarchives.org/rs/terms/")
+  end
+
+  def location(n)
+    query(n, 'x:loc')
+  end
+
+  def query(n, part, ns = {})
+    xml.xpath("//x:url[#{n}]/#{part}", ns.merge('x' => sitemap)).text
+  end
+end

data/spec/lib/hyrax/resource_sync/resource_list_writer_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::ResourceSync::ResourceListWriter do
+  let(:sitemap) { 'http://www.sitemaps.org/schemas/sitemap/0.9' }
+  let!(:private_collection) { create(:private_collection) }
+  let!(:public_collection) { create(:public_collection) }
+  let!(:public_work) { create(:public_generic_work) }
+  let!(:private_work) { create(:work) }
+  let!(:file_set) { create(:file_set, :public) }
+  let(:capability_list) { 'http://example.com/capabilityList.xml' }
+
+  subject { described_class.new(resource_host: 'example.com', capability_list_url: capability_list).write }
+  let(:xml) { Nokogiri::XML.parse(subject) }
+
+  it "has a list of resources" do
+    capability = xml.xpath('//rs:ln/@href', 'rs' => "http://www.openarchives.org/rs/terms/").text
+    expect(capability).to eq capability_list
+    expect(query(1)).to eq "http://example.com/collections/#{public_collection.id}"
+    expect(query(2)).to eq "http://example.com/concern/generic_works/#{public_work.id}"
+    expect(query(3)).to eq "http://example.com/concern/file_sets/#{file_set.id}"
+    expect(xml.xpath('//x:url', 'x' => sitemap).count).to eq 3
+  end
+
+  def query(n)
+    xml.xpath("//x:url[#{n}]/x:loc", 'x' => sitemap).text
+  end
+end

data/spec/lib/hyrax/resource_sync/source_description_writer_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::ResourceSync::SourceDescriptionWriter do
+  let(:sitemap) { 'http://www.sitemaps.org/schemas/sitemap/0.9' }
+  let(:rs) { 'http://www.openarchives.org/rs/terms/' }
+
+  let(:capability_list) { 'http://example.com/capabilityList.xml' }
+
+  subject { described_class.new(capability_list_url: capability_list).write }
+  let(:xml) { Nokogiri::XML.parse(subject) }
+
+  it "has url to the capability list" do
+    capability = xml.xpath('/x:urlset/rs:md/@capability', 'x' => sitemap, 'rs' => rs).map(&:value)
+    expect(capability).to eq ["description"]
+
+    url = xml.xpath('//x:url[1]/x:loc', 'x' => sitemap).text
+    expect(url).to eq capability_list
+    capability = xml.xpath('//x:url[1]/rs:md/@capability', 'x' => sitemap, 'rs' => rs).map(&:value)
+    expect(capability).to eq ["capabilitylist"]
+  end
+end

data/spec/lib/hyrax/search_state_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::SearchState do
+  let(:context) { double(params: {}, blacklight_config: config, url_options: {}) }
+  let(:config) { Blacklight::Configuration.new }
+  let(:state) { described_class.new(context) }
+
+  describe "url_for_document" do
+    subject { state.url_for_document(document) }
+    context "with a collection" do
+      let(:document) { SolrDocument.new(id: '9999', has_model_ssim: ['Collection']) }
+      it "returns an array with the route set and doc" do
+        expect(subject.first).to be_kind_of ActionDispatch::Routing::RoutesProxy
+        expect(subject.last).to eq document
+      end
+    end
+    context "with a work" do
+      let(:document) { SolrDocument.new(id: '9999', has_model_ssim: ['GenericWork']) }
+      it "returns an array with the route set and doc" do
+        expect(subject.first).to be_kind_of ActionDispatch::Routing::RoutesProxy
+        expect(subject.last).to eq document
+      end
+    end
+  end
+end

data/spec/lib/hyrax/zotero/config_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Hyrax::Zotero do
+  it { is_expected.to respond_to(:config) }
+
+  describe 'configuration' do
+    subject { described_class.reload_config! }
+
+    let(:client_key) { 'abc123' }
+    let(:client_secret) { '789xyz' }
+
+    before do
+      stub_const('ENV',           'ZOTERO_CLIENT_KEY' => client_key,
+                                  'ZOTERO_CLIENT_SECRET' => client_secret)
+    end
+
+    # Reload the config so other tests don't see the stub_const values
+    after(:context) { described_class.reload_config! }
+
+    it 'has a client key' do
+      expect(subject['client_key']).to eq(client_key)
+    end
+
+    it 'has a client secret' do
+      expect(subject['client_secret']).to eq(client_secret)
+    end
+  end
+end

data/spec/lib/hyrax/zotero_spec.rb

@@ -0,0 +1,8 @@
+describe Hyrax::Zotero do
+  describe '.publications_url' do
+    let(:user_id) { 'foobar' }
+    it 'returns a string' do
+      expect(described_class.publications_url(user_id)).to eq "/users/#{user_id}/publications/items"
+    end
+  end
+end

data/spec/models/admin_set_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+RSpec.describe AdminSet, type: :model do
+  let(:gf1) { create(:generic_work, user: user) }
+  let(:gf2) { create(:generic_work, user: user) }
+  let(:gf3) { create(:generic_work, user: user) }
+
+  let(:user) { create(:user) }
+
+  before do
+    subject.title = ['Some title']
+  end
+
+  describe '#permission_template' do
+    it 'queries for a Hyrax::PermissionTemplate with a matching admin_set_id' do
+      admin_set = build(:admin_set, id: '123')
+      permission_template = build(:permission_template)
+      expect(Hyrax::PermissionTemplate).to receive(:find_by!).with(admin_set_id: '123').and_return(permission_template)
+      expect(admin_set.permission_template).to eq(permission_template)
+    end
+  end
+
+  describe "#to_solr" do
+    let(:admin_set) do
+      build(:admin_set, title: ['A good title'],
+                        creator: ['jcoyne@justincoyne.com'])
+    end
+    let(:solr_document) { admin_set.to_solr }
+
+    it "has title and creator information" do
+      expect(solr_document).to include 'title_tesim' => ['A good title'],
+                                       'title_sim' => ['A good title'],
+                                       'creator_ssim' => ['jcoyne@justincoyne.com']
+    end
+  end
+
+  describe "#members" do
+    it "is empty by default" do
+      expect(subject.members).to be_empty
+    end
+
+    context "adding members" do
+      context "using assignment" do
+        subject { described_class.create!(title: ['Some title'], members: [gf1, gf2]) }
+
+        it "has many files" do
+          expect(subject.reload.members).to match_array [gf1, gf2]
+        end
+      end
+
+      context "using append" do
+        before do
+          subject.members = [gf1]
+          subject.save
+        end
+        it "allows new files to be added" do
+          subject.reload
+          subject.members << gf2
+          subject.save
+          expect(subject.reload.members).to match_array [gf1, gf2]
+        end
+      end
+    end
+  end
+
+  it "has a title" do
+    subject.title = ["title"]
+    subject.save
+    expect(subject.reload.title).to eq ["title"]
+  end
+
+  it "has a description" do
+    subject.title = ["title"]
+    subject.description = ["description"]
+    subject.save
+    expect(subject.reload.description).to eq ["description"]
+  end
+
+  describe "#destroy" do
+    before do
+      subject.members = [gf1, gf2]
+      subject.save
+      subject.destroy
+    end
+
+    it "does not delete member files when deleted" do
+      expect(GenericWork.exists?(gf1.id)).to be true
+      expect(GenericWork.exists?(gf2.id)).to be true
+    end
+  end
+end

data/spec/models/checksum_audit_log_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe ChecksumAuditLog do
+  let(:f) do
+    file = FileSet.create do |gf|
+      gf.apply_depositor_metadata('mjg36')
+    end
+    # TODO: Mock addition of file to fileset to avoid calls to .save.
+    # This will speed up tests and avoid uneccesary integration testing for fedora funcationality.
+    Hydra::Works::AddFileToFileSet.call(file, File.open(fixture_path + '/world.png'), :original_file)
+    file
+  end
+
+  let(:version_uri) do
+    Hyrax::VersioningService.create(f.original_file)
+    f.original_file.versions.first.uri
+  end
+  let(:content_id) { f.original_file.id }
+  let(:old) { described_class.create(file_set_id: f.id, file_id: content_id, version: version_uri, pass: 1, created_at: 2.minutes.ago) }
+  let(:new) { described_class.create(file_set_id: f.id, file_id: content_id, version: version_uri, pass: 0, created_at: 1.minute.ago) }
+
+  context 'a file with multiple checksums audits' do
+    it 'returns a list of logs for this FileSet sorted by date descending' do
+      logs = described_class.logs_for(f.id, content_id)
+      expect(logs).to eq([new, old])
+    end
+  end
+
+  context 'after multiple checksum audits where the checksum does not change' do
+    specify 'only one of them should be kept' do
+      success1 = described_class.create(file_set_id: f.id, file_id: content_id, version: version_uri, pass: 1)
+      described_class.prune_history(f.id, content_id)
+      success2 = described_class.create(file_set_id: f.id, file_id: content_id, version: version_uri, pass: 1)
+      described_class.prune_history(f.id, content_id)
+      success3 = described_class.create(file_set_id: f.id, file_id: content_id, version: version_uri, pass: 1)
+      described_class.prune_history(f.id, content_id)
+
+      expect { described_class.find(success2.id) }.to raise_exception ActiveRecord::RecordNotFound
+      expect { described_class.find(success3.id) }.to raise_exception ActiveRecord::RecordNotFound
+      expect(described_class.find(success1.id)).not_to be_nil
+      logs = described_class.logs_for(f.id, content_id)
+      expect(logs).to eq([success1, new, old])
+    end
+  end
+
+  context 'should have an audit log history' do
+    before do
+      described_class.create(file_set_id: f.id, file_id: content_id, version: 'v2', pass: 1)
+      described_class.create(file_set_id: f.id, file_id: 'thumbnail', version: 'v1', pass: 1)
+    end
+
+    it "has an audit log history" do
+      audit = described_class.get_audit_log(f.id, content_id, version_uri)
+      expect(audit.file_set_id).to eq(f.id)
+      expect(audit.version).to eq(version_uri)
+
+      audit = described_class.get_audit_log(f.id, content_id, 'v2')
+      expect(audit.file_set_id).to eq(f.id)
+      expect(audit.version).to eq('v2')
+
+      audit = described_class.get_audit_log(f.id, 'thumbnail', 'v1')
+      expect(audit.file_set_id).to eq(f.id)
+      expect(audit.version).to eq('v1')
+    end
+  end
+end

data/spec/models/collection_spec.rb

@@ -0,0 +1,116 @@
+describe Collection do
+  let(:collection) { create(:public_collection) }
+
+  it "has open visibility" do
+    expect(collection.read_groups).to eq ['public']
+  end
+
+  describe "#validates_with" do
+    before { collection.title = nil }
+    it "ensures the collection has a title" do
+      expect(collection).not_to be_valid
+      expect(collection.errors.messages[:title]).to eq(["You must provide a title"])
+    end
+  end
+
+  describe "#to_solr" do
+    let(:user) { create(:user) }
+    let(:collection) { build(:collection, user: user, title: ['A good title']) }
+
+    let(:solr_document) { collection.to_solr }
+
+    it "has title information" do
+      expect(solr_document).to include 'title_tesim' => ['A good title'],
+                                       'title_sim' => ['A good title']
+    end
+
+    it "has depositor information" do
+      expect(solr_document).to include 'depositor_tesim' => [user.user_key],
+                                       'depositor_ssim' => [user.user_key]
+    end
+  end
+
+  describe "#depositor" do
+    let(:user) { build(:user) }
+    before do
+      subject.apply_depositor_metadata(user)
+    end
+
+    it "has a depositor" do
+      expect(subject.depositor).to eq(user.user_key)
+    end
+  end
+
+  describe "#members_objects" do
+    let(:collection) { create(:collection) }
+    it "is empty by default" do
+      expect(collection.member_objects).to match_array []
+    end
+
+    context "adding members" do
+      let(:work1) { create(:work) }
+      let(:work2) { create(:work) }
+      let(:work3) { create(:work) }
+
+      it "allows multiple files to be added" do
+        collection.add_member_objects [work1.id, work2.id, work3.id]
+        collection.save!
+        expect(collection.reload.member_objects).to match_array [work1, work2, work3]
+      end
+    end
+  end
+
+  it "has a title" do
+    subject.title = ["title"]
+    subject.save!
+    expect(subject.reload.title).to eq ["title"]
+  end
+
+  it "has a description" do
+    subject.title = ["title"]
+    subject.description = ["description"]
+    subject.save!
+    expect(subject.reload.description).to eq ["description"]
+  end
+
+  describe "#destroy" do
+    let(:collection) { build(:collection) }
+    let(:work1) { create(:work) }
+    let(:work2) { create(:work) }
+    before do
+      collection.add_member_objects [work1.id, work2.id]
+      collection.save!
+      collection.destroy
+    end
+
+    it "does not delete member files when deleted" do
+      expect(GenericWork.exists?(work1.id)).to be true
+      expect(GenericWork.exists?(work2.id)).to be true
+    end
+  end
+
+  describe "Collection by another name" do
+    before do
+      class OtherCollection < ActiveFedora::Base
+        include Hyrax::CollectionBehavior
+      end
+
+      class Member < ActiveFedora::Base
+        include Hydra::Works::WorkBehavior
+      end
+      collection.add_member_objects member.id
+    end
+    after do
+      Object.send(:remove_const, :OtherCollection)
+      Object.send(:remove_const, :Member)
+    end
+
+    let(:member) { Member.create }
+    let(:collection) { OtherCollection.create(title: ['test title']) }
+
+    it "have members that know about the collection" do
+      member.reload
+      expect(member.member_of_collections).to eq [collection]
+    end
+  end
+end