hyrax 2.9.5 → 3.0.0.pre.beta1

data/spec/indexers/hyrax/file_set_indexer_spec.rb

@@ -0,0 +1,125 @@
+RSpec.describe Hyrax::FileSetIndexer do
+  include Hyrax::FactoryHelpers
+
+  let(:file_set) do
+    FileSet.new(
+      id: 'foo123',
+      contributor: ['Mohammad'],
+      creator: ['Allah'],
+      title: ['The Work'],
+      description: ['The work by Allah'],
+      publisher: ['Vertigo Comics'],
+      date_created: ['1200-01-01'],
+      date_uploaded: Date.parse('2011-01-01'),
+      date_modified: Date.parse('2012-01-01'),
+      subject: ['Theology'],
+      language: ['Arabic'],
+      license: ['Wide open, buddy.'],
+      rights_statement: ['No Known Copyright'],
+      resource_type: ['Book'],
+      identifier: ['urn:isbn:1234567890'],
+      based_near: ['Medina, Saudi Arabia'],
+      related_url: ['http://example.org/TheWork/']
+    )
+  end
+
+  let(:mock_file) do
+    mock_file_factory(
+      content: "asdf",
+      digest: ["urn:sha1:f794b23c0c6fe1083d0ca8b58261a078cd968967"],
+      mime_type: 'image/jpeg',
+      format_label: ['JPEG Image'],
+      height: ['500'],
+      width: ['600'],
+      file_size: ['12'],
+      page_count: ['1'],
+      file_title: ['title'],
+      duration: ['0:1'],
+      sample_rate: ['sample rate']
+    )
+  end
+
+  let(:mock_text) do
+    mock_file_factory(content: "abcxyz")
+  end
+
+  let(:indexer) { described_class.new(file_set) }
+
+  describe '#generate_solr_document' do
+    before do
+      # https://github.com/samvera/active_fedora/issues/1251
+      allow(file_set).to receive(:persisted?).and_return(true)
+      allow(file_set).to receive(:label).and_return('CastoriaAd.tiff')
+      allow(Hyrax::ThumbnailPathService).to receive(:call).and_return('/downloads/foo123?file=thumbnail')
+      allow(file_set).to receive(:original_file).and_return(mock_file)
+      allow(file_set).to receive(:extracted_text).and_return(mock_text)
+    end
+    subject { indexer.generate_solr_document }
+
+    it 'has fields' do
+      expect(subject['hasRelatedMediaFragment_ssim']).to eq 'foo123'
+      expect(subject['hasRelatedImage_ssim']).to eq 'foo123'
+      expect(subject['date_uploaded_tesim']).to be_nil
+      expect(subject['date_modified_tesim']).to be_nil
+      expect(subject['date_uploaded_dtsi']).to eq '2011-01-01T00:00:00Z'
+      expect(subject['date_modified_dtsi']).to eq '2012-01-01T00:00:00Z'
+      expect(subject['license_tesim']).to eq ['Wide open, buddy.']
+      expect(subject['rights_statement_tesim']).to eq ['No Known Copyright']
+      expect(subject['related_url_tesim']).to eq ['http://example.org/TheWork/']
+      expect(subject['contributor_tesim']).to eq ['Mohammad']
+      expect(subject['creator_tesim']).to eq ['Allah']
+      expect(subject['title_tesim']).to eq ['The Work']
+      expect(subject['title_sim']).to eq ['The Work']
+      expect(subject['label_tesim']).to eq 'CastoriaAd.tiff'
+      expect(subject['label_ssi']).to eq 'CastoriaAd.tiff'
+      expect(subject['description_tesim']).to eq ['The work by Allah']
+      expect(subject['publisher_tesim']).to eq ['Vertigo Comics']
+      expect(subject['subject_tesim']).to eq ['Theology']
+      expect(subject['language_tesim']).to eq ['Arabic']
+      expect(subject['date_created_tesim']).to eq ['1200-01-01']
+      expect(subject['resource_type_tesim']).to eq ['Book']
+      expect(subject['file_format_tesim']).to eq 'jpeg (JPEG Image)'
+      expect(subject['identifier_tesim']).to eq ['urn:isbn:1234567890']
+      expect(subject['based_near_tesim']).to eq ['Medina, Saudi Arabia']
+      expect(subject['mime_type_ssi']).to eq 'image/jpeg'
+      expect(subject['thumbnail_path_ss']).to eq '/downloads/foo123?file=thumbnail'
+      expect(subject['all_text_timv']).to eq('abcxyz')
+      expect(subject['height_is']).to eq 500
+      expect(subject['width_is']).to eq 600
+      expect(subject['digest_ssim']).to eq 'urn:sha1:f794b23c0c6fe1083d0ca8b58261a078cd968967'
+      expect(subject['visibility_ssi']).to eq 'restricted'
+      expect(subject['page_count_tesim']).to eq ['1']
+      expect(subject['file_title_tesim']).to eq ['title']
+      expect(subject['duration_tesim']).to eq ['0:1']
+      expect(subject['sample_rate_tesim']).to eq ['sample rate']
+    end
+  end
+
+  describe '#file_format' do
+    subject { indexer.send(:file_format) }
+
+    context 'when both mime and format_label are present' do
+      before do
+        allow(file_set).to receive(:mime_type).and_return('image/png')
+        allow(file_set).to receive(:format_label).and_return(['Portable Network Graphics'])
+      end
+      it { is_expected.to eq 'png (Portable Network Graphics)' }
+    end
+
+    context 'when just mime type is present' do
+      before do
+        allow(file_set).to receive(:mime_type).and_return('image/png')
+        allow(file_set).to receive(:format_label).and_return([])
+      end
+      it { is_expected.to eq 'png' }
+    end
+
+    context 'when just format_label is present' do
+      before do
+        allow(file_set).to receive(:mime_type).and_return('')
+        allow(file_set).to receive(:format_label).and_return(['Portable Network Graphics'])
+      end
+      it { is_expected.to eq ['Portable Network Graphics'] }
+    end
+  end
+end

data/spec/indexers/hyrax/generic_work_indexer_spec.rb

@@ -0,0 +1,123 @@
+RSpec.describe GenericWorkIndexer do
+  subject(:solr_document) { service.generate_solr_document }
+
+  # TODO: file_set_ids returns an empty set unless you persist the work
+  let(:user) { create(:user) }
+  let(:service) { described_class.new(work) }
+  let(:work) { create(:generic_work) }
+
+  context 'without explicit visibility set' do
+    it 'indexes visibility' do
+      expect(solr_document['visibility_ssi']).to eq 'restricted' # tight default
+    end
+  end
+
+  context 'with explicit visibility set' do
+    before { allow(work).to receive(:visibility).and_return('authenticated') }
+    it 'indexes visibility' do
+      expect(solr_document['visibility_ssi']).to eq 'authenticated'
+    end
+  end
+
+  context "with child works" do
+    let!(:work) { create(:work_with_one_file, user: user) }
+    let!(:child_work) { create(:generic_work, user: user) }
+    let(:file) { work.file_sets.first }
+
+    before do
+      work.works << child_work
+      allow(Hyrax::ThumbnailPathService).to receive(:call).and_return("/downloads/#{file.id}?file=thumbnail")
+      work.representative_id = file.id
+      work.thumbnail_id = file.id
+    end
+
+    it 'indexes member work and file_set ids' do
+      expect(solr_document['member_ids_ssim']).to eq work.member_ids
+      expect(solr_document['generic_type_sim']).to eq ['Work']
+      expect(solr_document.fetch('thumbnail_path_ss')).to eq "/downloads/#{file.id}?file=thumbnail"
+      expect(subject.fetch('hasRelatedImage_ssim').first).to eq file.id
+      expect(subject.fetch('hasRelatedMediaFragment_ssim').first).to eq file.id
+    end
+
+    context "when thumbnail_field is configured" do
+      before do
+        service.thumbnail_field = 'thumbnail_url_ss'
+      end
+      it "uses the configured field" do
+        expect(solr_document.fetch('thumbnail_url_ss')).to eq "/downloads/#{file.id}?file=thumbnail"
+      end
+    end
+  end
+
+  context "with an AdminSet" do
+    let(:work) { create(:generic_work, admin_set: admin_set) }
+    let(:admin_set) { create(:admin_set, title: ['Title One']) }
+
+    it "indexes the correct fields" do
+      expect(solr_document.fetch('admin_set_sim')).to eq ["Title One"]
+      expect(solr_document.fetch('admin_set_tesim')).to eq ["Title One"]
+    end
+  end
+
+  context "the object status" do
+    before { allow(work).to receive(:suppressed?).and_return(suppressed) }
+    context "when suppressed" do
+      let(:suppressed) { true }
+
+      it "indexes the suppressed field with a true value" do
+        expect(solr_document.fetch('suppressed_bsi')).to be true
+      end
+    end
+
+    context "when not suppressed" do
+      let(:suppressed) { false }
+
+      it "indexes the suppressed field with a false value" do
+        expect(solr_document.fetch('suppressed_bsi')).to be false
+      end
+    end
+  end
+
+  context "the actionable workflow roles" do
+    let(:sipity_entity) do
+      create(:sipity_entity, proxy_for_global_id: work.to_global_id.to_s)
+    end
+
+    before do
+      allow(PowerConverter).to receive(:convert_to_sipity_entity).with(work).and_return(sipity_entity)
+      allow(Hyrax::Workflow::PermissionQuery).to receive(:scope_roles_associated_with_the_given_entity)
+        .and_return(['approve', 'reject'])
+    end
+    it "indexed the roles and state" do
+      expect(solr_document.fetch('actionable_workflow_roles_ssim')).to eq [
+        "#{sipity_entity.workflow.permission_template.source_id}-#{sipity_entity.workflow.name}-approve",
+        "#{sipity_entity.workflow.permission_template.source_id}-#{sipity_entity.workflow.name}-reject"
+      ]
+      expect(solr_document.fetch('workflow_state_name_ssim')).to eq "initial"
+    end
+  end
+
+  describe "with a remote resource (based near)" do
+    mpls = <<RDFXML.strip_heredoc
+      <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+          <rdf:RDF xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:gn="http://www.geonames.org/ontology#" xmlns:owl="http://www.w3.org/2002/07/owl#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
+          <gn:Feature rdf:about="http://sws.geonames.org/5037649/">
+          <gn:name>Minneapolis</gn:name>
+          </gn:Feature>
+          </rdf:RDF>
+RDFXML
+
+    before do
+      allow(service).to receive(:rdf_service).and_return(Hyrax::DeepIndexingService)
+      work.based_near_attributes = [{ id: 'http://sws.geonames.org/5037649/' }]
+      stub_request(:get, "http://sws.geonames.org/5037649/")
+        .to_return(status: 200, body: mpls,
+                   headers: { 'Content-Type' => 'application/rdf+xml;charset=UTF-8' })
+    end
+
+    it "indexes id and label" do
+      expect(solr_document.fetch('based_near_sim')).to eq ["http://sws.geonames.org/5037649/"]
+      expect(solr_document.fetch('based_near_label_sim')).to eq ["Minneapolis"]
+    end
+  end
+end

data/spec/indexers/hyrax/repository_reindexer_spec.rb

@@ -0,0 +1,8 @@
+RSpec.describe Hyrax::RepositoryReindexer do
+  let(:subject) { Samvera::NestingIndexer }
+
+  it 'overrides ActiveFedora#reindex_everything' do
+    expect(subject).to receive(:reindex_all!).with(extent: Hyrax::Adapters::NestingIndexAdapter::FULL_REINDEX)
+    ActiveFedora::Base.reindex_everything
+  end
+end

data/spec/inputs/controlled_vocabulary_input_spec.rb

@@ -0,0 +1,57 @@
+RSpec.describe 'ControlledVocabularyInput', type: :input do
+  let(:work) { GenericWork.new }
+  let(:builder) { SimpleForm::FormBuilder.new(:generic_work, work, view, {}) }
+  let(:input) { ControlledVocabularyInput.new(builder, :based_near, nil, :multi_value, {}) }
+
+  describe '#input' do
+    before { allow(work).to receive(:[]).with(:based_near).and_return([item1, item2]) }
+    let(:item1) { double('value 1', rdf_label: ['Item 1'], rdf_subject: 'http://example.org/1', node?: false) }
+    let(:item2) { double('value 2', rdf_label: ['Item 2'], rdf_subject: 'http://example.org/2') }
+
+    it 'renders multi-value' do
+      expect(input).to receive(:build_field).with(item1, 0)
+      expect(input).to receive(:build_field).with(item2, 1)
+      input.input({})
+    end
+  end
+
+  describe '#collection' do
+    let(:work) { GenericWork.new(based_near: [::RDF::URI('http://example.org/1')]) }
+
+    subject { input.send(:collection) }
+
+    it { is_expected.to all(be_an(Hyrax::ControlledVocabularies::Location)) }
+  end
+
+  describe '#build_field' do
+    subject { input.send(:build_field, value, 0) }
+
+    context 'for a resource' do
+      let(:value) { double('value 1', rdf_label: ['Item 1'], rdf_subject: 'http://example.org/1', node?: false) }
+
+      it 'renders multi-value' do
+        expect(subject).to have_selector('input.generic_work_based_near.multi_value')
+        expect(subject).to have_field('generic_work[based_near_attributes][0][hidden_label]', with: 'Item 1')
+        expect(subject).to have_selector('input[name="generic_work[based_near_attributes][0][id]"][value="http://example.org/1"]', visible: false)
+        expect(subject).to have_selector('input[name="generic_work[based_near_attributes][0][_destroy]"][value=""][data-destroy]', visible: false)
+      end
+    end
+  end
+
+  describe "#build_options" do
+    subject { input.send(:build_options, value, index, options) }
+
+    let(:value) { Hyrax::ControlledVocabularies::Location.new }
+    let(:index) { 0 }
+    let(:options) { {} }
+
+    context "when data is passed" do
+      let(:options) { { data: { 'search-url' => '/authorities/search' } } }
+
+      it "preserves passed in data" do
+        subject
+        expect(options).to include(data: { attribute: :based_near, 'search-url' => '/authorities/search' })
+      end
+    end
+  end
+end

data/spec/inputs/multifile_input_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe 'MultifileInput', type: :input do
+  class Foo
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
+
+    def persisted?
+      false
+    end
+
+    attr_accessor :bar
+
+    def [](val)
+      raise "Unknown attribute" unless val == :bar
+      bar
+    end
+  end
+
+  let(:foo) { Foo.new }
+  let(:bar) { ["bar1", "bar2"] }
+
+  subject do
+    foo.bar = bar
+    input_for(foo, :files, as: :multifile)
+  end
+
+  it 'renders multifile' do
+    expect(subject).to have_selector('.form-group.multifile label[for=foo_files]', text: 'Upload a file')
+    expect(subject).to have_selector('.form-group.foo_files.multifile input[name="foo[files][]"]')
+  end
+end

data/spec/javascripts/authority_select_spec.js

@@ -0,0 +1,22 @@
+describe('authority select', () => {
+    var AuthoritySelect = require('hyrax/authority_select')
+    var Editor = require('hyrax/editor')
+
+    var editor;
+
+    beforeEach(() =>  {
+    	setFixtures(`
+        <form>
+        <input class="string multi_value required form-control generic_work_creator form-control multi-text-field ui-autocomplete-input" data-autocomplete-url="/authorities/search/loc/names" data-autocomplete="creator" required="required" aria-required="true" name="generic_work[creator][]" value="" id="generic_work_creator" aria-labelledby="generic_work_creator_label" type="text" autocomplete="off">
+        <select class="form-control select required generic_work_creator" data-authority-select="generic_work_creator" required="required" aria-required="Select an authority" name="generic_work[creator]" id="generic_work_creator"><option value="/authorities/search/loc/names">LOC Names</option>
+        <option value="/authorities/search/assign_fast/all">FAST</option></select></form>
+        `)
+      editor = new Editor($('form'))
+    })
+
+    it('should change the data-autocomplete-url when you select an authority', () => {
+	      new AuthoritySelect({ selectBox : "select.generic_work_creator", inputField : "input.generic_work_creator" })
+	      $('select.generic_work_creator').val('/authorities/search/assign_fast/all').change()
+	      expect($('input.generic_work_creator').data('autocomplete-url')).toEqual('/authorities/search/assign_fast/all')
+    })
+})

data/spec/javascripts/autocomplete_spec.js.coffee

@@ -0,0 +1,199 @@
+describe "auto complete", ->
+  beforeEach ->
+    # set up the spy to see in the autocomplete is called
+    resp = [{"uri":"http://lexvo.org/id/iso639-3/fra","label":"French"},{"uri":"http://lexvo.org/id/iso639-3/fsl","label":"French Sign Language"}]
+    @spy_on_json = spyOn($, 'getJSON').and.returnValue resp
+
+    #set up a key down event to trigger the auto complete
+    @typeEvent = $.Event('keydown')
+    @typeEvent.keyCode = 70 # lower case f
+
+    #define the jasmine clock so we can control time
+    jasmine.clock().install()
+
+  afterEach ->
+    #undefine the jasmine clock so time goes back to normal
+    jasmine.clock().uninstall()
+
+  describe "title", ->
+    beforeEach ->
+      # setup two inputs for us to attach auto complete to
+      setFixtures  '<form data-behavior="work-form">
+                    <input class="generic_work_title"  value="" id="generic_work_title" type="text">
+                    <input class="generic_work_title"  value="" type="text">
+                    </form>'
+
+      # run all Blacklight.onload functions
+      Blacklight.activate()
+
+    describe "first input", ->
+      # field doesn't trigger auto complete
+      it "does not auto complete on typing", ->
+        # send a key stroke to the target input to activate the auto complete
+        target = $($("input.generic_work_title")[0])
+        target.val('fre')
+        target.trigger(@typeEvent)
+
+        # move time along so that events have a chance to happen
+        jasmine.clock().tick(800)
+
+        # verify that the ajax call was made
+        expect(@spy_on_json).not.toHaveBeenCalled()
+
+    describe "second input", ->
+      # field doesn't trigger auto complete
+      it "does not auto complete on typing", ->
+        # send a key stroke to the target input to activate the auto complete
+        target = $($("input.generic_work_title")[1])
+        target.val('fre')
+        target.trigger(@typeEvent)
+
+        # move time along so that events have a chance to happen
+        jasmine.clock().tick(800)
+
+        # verify that the ajax call was not made
+        expect(@spy_on_json).not.toHaveBeenCalled()
+
+  describe "language", ->
+    beforeEach ->
+      # setup two inputs for us to attach  auto complete to
+      setFixtures  '<form data-behavior="work-form">
+                    <input class="generic_work_language"  value="" id="generic_work_language" type="text" data-autocomplete="language" data-autocomplete-url="foo">
+                    <input class="generic_work_language"  value="" type="text" data-autocomplete="language" data-autocomplete-url="foo">
+                    </form>'
+
+      # run all Blacklight.onload functions
+      Blacklight.activate()
+
+    describe "first input", ->
+
+      # field triggers auto complete
+      it "auto completes on typing", ->
+        # send a key stroke to the target input to activate the auto complete
+        target = $($("input.generic_work_language")[0])
+        target.val('fre')
+        target.trigger(@typeEvent)
+
+        # move time along so that events have a chance to happen
+        jasmine.clock().tick(800)
+
+        # verify that the ajax call was made
+        expect(@spy_on_json).toHaveBeenCalled()
+
+    describe "second input", ->
+
+      # field triggers auto complete
+      it "auto completes on typing", ->
+        # send a key stroke to the target input to activate the auto complete
+        target = $($("input.generic_work_language")[1])
+        target.val('fre')
+        target.trigger(@typeEvent)
+
+        # move time along so that events have a chance to happen
+        jasmine.clock().tick(800)
+
+        # verify that the ajax call was made
+        expect(@spy_on_json).toHaveBeenCalled()
+
+  describe "subject", ->
+    beforeEach ->
+      # setup two inputs for us to attach  auto complete to
+      setFixtures  '<form data-behavior="work-form">
+                    <input class="generic_work_subject"  value="" id="generic_work_subject" type="text" data-autocomplete="subject" data-autocomplete-url="foo">
+                    <input class="generic_work_subject"  value="" type="text" data-autocomplete="subject" data-autocomplete-url="foo">
+                    </form>'
+
+      # run all Blacklight.onload functions
+      Blacklight.activate()
+
+    describe "first input", ->
+
+      # field triggers auto complete
+      it "auto completes on typing", ->
+        # send a key stroke to the target input to activate the auto complete
+        target = $($("input.generic_work_subject")[0])
+        target.val('fre')
+        target.trigger(@typeEvent)
+
+        # move time along so that events have a chance to happen
+        jasmine.clock().tick(800)
+
+        # verify that the ajax call was made
+        expect(@spy_on_json).toHaveBeenCalled()
+
+    describe "second input", ->
+
+      # field triggers auto complete
+      it "auto completes on typing", ->
+        # send a key stroke to the target input to activate the auto complete
+        target = $($("input.generic_work_subject")[1])
+        target.val('fre')
+        target.trigger(@typeEvent)
+
+        # move time along so that events have a chance to happen
+        jasmine.clock().tick(800)
+
+        # verify that the ajax call was made
+        expect(@spy_on_json).toHaveBeenCalled()
+
+  describe "location", ->
+    beforeEach ->
+      # setup two inputs for us to attach  auto complete to
+      setFixtures  '<form data-behavior="work-form">
+                    <input class="generic_work_based_near" value="" id="generic_work_based_near" type="text" data-autocomplete="based_near" data-autocomplete-url="foo">
+                    <input class="generic_work_based_near" value="" type="text" data-autocomplete="based_near" data-autocomplete-url="foo">
+                    </form>'
+
+      # run all Blacklight.onload functions
+      Blacklight.activate()
+
+    describe "first input", ->
+
+      # field triggers auto complete
+      it "auto completes on typing", ->
+        # send a key stroke to the target input to activate the auto complete
+        target = $($("input.generic_work_based_near")[0])
+        target.val('fre')
+        target.trigger(@typeEvent)
+
+        # move time along so that events have a chance to happen
+        jasmine.clock().tick(800)
+
+        # verify that the ajax call was made
+        expect(@spy_on_json).toHaveBeenCalled()
+
+    describe "second input", ->
+
+      # field triggers auto complete
+      it "auto completes on typing", ->
+        # send a key stroke to the target input to activate the auto complete
+        target = $($("input.generic_work_based_near")[1])
+        target.val('fre')
+        target.trigger(@typeEvent)
+
+        # move time along so that events have a chance to happen
+        jasmine.clock().tick(800)
+
+        # verify that the ajax call was made
+        expect(@spy_on_json).toHaveBeenCalled()
+
+  describe "for works", ->
+    beforeEach ->
+      # setup two inputs for us to attach auto complete to
+      setFixtures  '<form data-behavior="work-form">
+                    <input class="generic_work_work" value="" id="generic_work_based_near" type="text" data-autocomplete="work" data-autocomplete-url="foo">
+                    <input class="generic_work_work" value="" type="text" data-autocomplete="work" data-autocomplete-url="foo">
+                    </form>'
+
+      # run all Blacklight.onload functions
+      Blacklight.activate()
+
+    describe "the first input", ->
+      it "initializes using select2", ->
+        target = $($("input.generic_work_work")[0])
+        expect(target.select2('open')).toBe(true)
+
+    describe "the second input", ->
+      it "initializes using select2", ->
+        target = $($("input.generic_work_work")[1])
+        expect(target.select2('open')).toBe(true)