hydra-head 4.0.3 → 4.1.0

data/lib/uva/mods_index_methods.rb

@@ -1,30 +0,0 @@
-# @deprecated  Leftover from Hydrangea; will be removed in release 5.x
-module Uva
-  module ModsIndexMethods
-
-  def self.included(base)
-    ActiveSupport::Deprecation.warn("Uva::ModsIndexMethods has been deprecated and its functionality has been encorporated into Hydra::Datastream::ModsArticle")
-  end
-
-  # extracts the last_name##full_name##computing_id to be used by home view
-  def extract_person_full_names_and_computing_ids
-    names = {}
-    self.find_by_terms(:person).each do |person|
-      name_parts = person.children.inject({}) do |hash,child|
-        hash[child.get_attribute(:type)] = child.text if ["family","given"].include? child.get_attribute(:type)
-        hash["computing_id"] = child.text if child.name == 'computing_id'
-        hash
-      end
-      if name_parts.length == 3 and person.search(:roleTerm).children.text.include?("Author")
-        if name_parts["family"].blank? && name_parts["given"].blank? && name_parts["computing_id"].blank?
-          value = "Unknown Author"
-        else
-          value = "#{name_parts["family"]}, #{name_parts["given"]} (#{name_parts["computing_id"]})"
-        end
-        ::Solrizer::Extractor.insert_solr_field_value(names, "person_full_name_cid_facet", value) if name_parts.length == 3        
-      end      
-    end
-    names
-  end
-  end
-end

data/test_support/spec/lib/common_mods_index_methods_spec.rb

@@ -1,26 +0,0 @@
-# Need way to find way to stub current_user and RoleMapper in order to run these tests
-require File.expand_path( File.join( File.dirname(__FILE__),'..','spec_helper') )
-
-
-describe Hydra::Datastream::CommonModsIndexMethods do
-  describe "extract_person_full_names" do
-    it "should return an array of Solr::Field objects for :person_full_name_facet" do
-      ma = ModsAsset.find("hydrangea:fixture_mods_article1")
-      full_names = ma.datastreams["descMetadata"].extract_person_full_names
-      full_names.should be_kind_of Hash
-      full_names["person_full_name_facet"].should == ["FAMILY NAME, GIVEN NAMES", "Lacks, Henrietta"]
-    end
-  end
-  describe "extract_person_organizations" do 
-    it "should return an array of Solr::Field objects for :mods_organization_facet" do
-      orgs = ModsAsset.find("hydrangea:fixture_mods_article1").datastreams["descMetadata"].extract_person_organizations
-      orgs.should be_kind_of Hash
-      orgs["mods_organization_facet"].should be_kind_of Array
-      orgs["mods_organization_facet"].length.should == 2
-      orgs["mods_organization_facet"].first.should == "FACULTY, UNIVERSITY"
-      orgs["mods_organization_facet"].last.should == "Baltimore"
-    end
-  end
-end
-
-

data/test_support/spec/models/ability_spec.rb

@@ -1,40 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ability do
-  it "should call custom_permissions" do
-    Ability.any_instance.expects(:custom_permissions)
-    subject = Ability.new(nil) 
-    subject.can?(:delete, 7)
-  end
-
-  context "for a not-signed in user" do
-    subject { Ability.new(nil) }
-    it "should be able to read objects that are public" do
-      public_object = ModsAsset.new
-      public_object.rightsMetadata.update_permissions("group"=>{'public'=>'read'}) 
-      public_object.save
-      subject.can?(:read, public_object).should be_true
-    end
-    it "should not be able to read objects that are registered" do
-      registered_object = ModsAsset.new
-      registered_object.rightsMetadata.update_permissions("group"=>{'registered'=>'read'}) 
-      registered_object.save
-      subject.can?(:read, registered_object).should_not be_true
-    end
-  end
-  context "for a signed in user" do
-    subject { Ability.new(FactoryGirl.create(:user)) }
-    it "should be able to read objects that are public" do
-      public_object = ModsAsset.new
-      public_object.rightsMetadata.update_permissions("group"=>{'public'=>'read'}) 
-      public_object.save
-      subject.can?(:read, public_object).should be_true
-    end
-    it "should be able to read objects that are registered" do
-      registered_object = ModsAsset.new
-      registered_object.rightsMetadata.update_permissions("group"=>{'registered'=>'read'}) 
-      registered_object.save
-      subject.can?(:read, registered_object).should be_true
-    end
-  end
-end

data/test_support/spec/models/hydra_rights_metadata_spec.rb

@@ -1,175 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require "nokogiri"
-
-describe Hydra::Datastream::RightsMetadata do
-  
-  before(:each) do
-    # The way RubyDora loads objects prevents us from stubbing the fedora connection :(
-    # ActiveFedora::RubydoraConnection.stubs(:instance).returns(stub_everything())
-    obj = ActiveFedora::Base.new
-    @sample = Hydra::Datastream::RightsMetadata.new(obj.inner_object, nil)
-    @sample.stubs(:content).returns('')
-  end
-  
-  describe "permissions" do
-    describe "setter" do
-      it "should create/update/delete permissions for the given user/group" do
-        @sample.class.terminology.xpath_for(:access, :person, "person_123").should == '//oxns:access/oxns:machine/oxns:person[contains(., "person_123")]'
-        
-        person_123_perms_xpath = @sample.class.terminology.xpath_for(:access, :person, "person_123")
-        group_zzz_perms_xpath = @sample.class.terminology.xpath_for(:access, :group, "group_zzz")
-        
-        @sample.find_by_terms(person_123_perms_xpath).should be_empty 
-        @sample.permissions({"person"=>"person_123"}, "edit").should == "edit"
-        @sample.permissions({"group"=>"group_zzz"}, "edit").should == "edit"      
-        
-        @sample.find_by_terms(person_123_perms_xpath).first.ancestors("access").first.attributes["type"].text.should == "edit"
-        @sample.find_by_terms(group_zzz_perms_xpath).first.ancestors("access").first.attributes["type"].text.should == "edit"
-        
-        @sample.permissions({"person"=>"person_123"}, "read")
-        @sample.permissions({"group"=>"group_zzz"}, "read")
-        @sample.find_by_terms(person_123_perms_xpath).length.should == 1
-        
-        @sample.find_by_terms(person_123_perms_xpath).first.ancestors("access").first.attributes["type"].text.should == "read"
-        @sample.find_by_terms(group_zzz_perms_xpath).first.ancestors("access").first.attributes["type"].text.should == "read"
-      
-        @sample.permissions({"person"=>"person_123"}, "none").should == "none"
-        @sample.permissions({"group"=>"group_zzz"}, "none").should == "none"
-        @sample.find_by_terms(person_123_perms_xpath).should be_empty 
-        @sample.find_by_terms(person_123_perms_xpath).should be_empty 
-      end
-      it "should remove existing permissions (leaving only one permission level per user/group)" do
-        person_123_perms_xpath = @sample.class.terminology.xpath_for(:access, :person, "person_123")
-        group_zzz_perms_xpath = @sample.class.terminology.xpath_for(:access, :group, "group_zzz")
-                        
-        @sample.find_by_terms(person_123_perms_xpath).length.should == 0
-        @sample.find_by_terms(group_zzz_perms_xpath).length.should == 0
-        @sample.permissions({"person"=>"person_123"}, "read")
-        @sample.permissions({"group"=>"group_zzz"}, "read")
-        @sample.find_by_terms(person_123_perms_xpath).length.should == 1
-        @sample.find_by_terms(group_zzz_perms_xpath).length.should == 1
-        
-        @sample.permissions({"person"=>"person_123"}, "edit")
-        @sample.permissions({"group"=>"group_zzz"}, "edit")
-        @sample.find_by_terms(person_123_perms_xpath).length.should == 1
-        @sample.find_by_terms(group_zzz_perms_xpath).length.should == 1
-      end
-      it "should not impact other users permissions" do
-        @sample.permissions({"person"=>"person_123"}, "read")
-        @sample.permissions({"person"=>"person_789"}, "edit")
-        
-        @sample.permissions({"person"=>"person_123"}).should == "read"
-        @sample.permissions({"person"=>"person_456"}, "read")
-        @sample.permissions({"person"=>"person_123"}).should == "read"
-        @sample.permissions({"person"=>"person_456"}).should == "read"
-        @sample.permissions({"person"=>"person_789"}).should == "edit"
-        
-        
-      end
-    end
-    describe "getter" do
-      it "should return permissions level for the given user/group" do
-        @sample.permissions({"person"=>"person_123"}, "edit")
-        @sample.permissions({"group"=>"group_zzz"}, "discover")
-        @sample.permissions({"person"=>"person_123"}).should == "edit"
-        @sample.permissions({"group"=>"group_zzz"}).should == "discover"
-        @sample.permissions({"group"=>"foo_people"}).should == "none"
-      end
-    end
-  end
-  describe "groups" do
-    it "should return a hash of all groups with permissions set, along with their permission levels" do
-      @sample.permissions({"group"=>"group_zzz"}, "edit")
-      @sample.permissions({"group"=>"public"}, "discover")
-
-      #@sample.groups.should == {"group_zzz"=>"edit", "public"=>"discover"}
-      @sample.groups.should == {"public"=>"discover", "group_zzz"=>"edit"}
-    end
-  end
-  describe "individuals" do
-    it "should return a hash of all individuals with permissions set, along with their permission levels" do
-      @sample.permissions({"person"=>"person_123"}, "read")
-      @sample.permissions({"person"=>"person_456"}, "edit")
-      @sample.individuals.should == {"person_123"=>"read", "person_456"=>"edit"}
-    end
-  end
-  
-  describe "update_permissions" do
-    it "should accept a hash of groups and persons, updating their permissions accordingly" do
-      @sample.expects(:permissions).with({"group" => "group1"}, "discover")
-      @sample.expects(:permissions).with({"group" => "group2"}, "edit")
-      @sample.expects(:permissions).with({"person" => "person1"}, "read")
-      @sample.expects(:permissions).with({"person" => "person2"}, "discover")
-      
-      @sample.update_permissions( {"group"=>{"group1"=>"discover","group2"=>"edit"}, "person"=>{"person1"=>"read","person2"=>"discover"}} )
-    end
-  end
-  
-  describe "update_indexed_attributes" do
-    it "should update the declared properties" do
-      @sample.find_by_terms(*[:edit_access, :person]).length.should == 0
-      @sample.update_values([:edit_access, :person]=>"user id").should == {"edit_access_person"=>{"0"=>"user id"}}
-      @sample.find_by_terms(*[:edit_access, :person]).length.should == 1
-      @sample.find_by_terms(*[:edit_access, :person]).first.text.should == "user id"
-    end
-  end
-  describe "to_solr" do
-    it "should populate solr doc with the correct fields" do
-      params = {[:edit_access, :person]=>"Lil Kim", [:edit_access, :group]=>["group1","group2"], [:discover_access, :group]=>["public"],[:discover_access, :person]=>["Joe Schmoe"]}
-      @sample.update_values(params)
-      solr_doc = @sample.to_solr
-      
-      solr_doc["edit_access_person_t"].should == ["Lil Kim"]
-      solr_doc["edit_access_group_t"].sort.should == ["group1", "group2"]
-      solr_doc["discover_access_person_t"].should == ["Joe Schmoe"]
-      solr_doc["discover_access_group_t"].should == ["public"]
-    end
-    it "should solrize fixture content correctly" do
-      fixture_xml = Nokogiri::XML::Document.parse( File.new(File.join( File.dirname(__FILE__), "../../fixtures/hydrangea_fixture_mods_article1.foxml.xml") ))
-      fixture_rights = fixture_xml.xpath("//foxml:datastream[@ID='rightsMetadata']/foxml:datastreamVersion[last()]/foxml:xmlContent", {'foxml'=>"info:fedora/fedora-system:def/foxml#"}).first.to_xml
-      lsample = Hydra::Datastream::RightsMetadata.new(nil, nil)
-      lsample.content = fixture_rights
-#      lsample.expects(:content).returns('')
-      lsample = Hydra::Datastream::RightsMetadata.from_xml(fixture_rights, lsample)
-      solr_doc = lsample.to_solr
-      solr_doc["edit_access_person_t"].should == ["researcher1"]
-      solr_doc["edit_access_group_t"].should == ["archivist"]
-      solr_doc["read_access_group_t"].should == ["public"]
-      solr_doc["discover_access_group_t"].should == ["public"]
-    end
-  end
-  describe "embargo_release_date=" do
-    it "should update the appropriate node with the value passed" do
-      @sample.embargo_release_date=("2010-12-01")
-      @sample.embargo_release_date.should == "2010-12-01"
-    end
-    it "should only accept valid date values" do
-      
-    end
-  end
-  describe "embargo_release_date" do
-    it "should return solr formatted date" do
-      @sample.embargo_release_date=("2010-12-01")
-      @sample.embargo_release_date(:format=>:solr_date).should == "2010-12-01T23:59:59Z"
-    end
-    
-    # this test was returning '' under 1.9 and returning nil under ree and 1.8.7
-    it "should not return anything if the date is empty string" do
-      @sample.update_values({[:embargo,:machine,:date]=>''})
-      @sample.embargo_release_date(:format=>:solr_date).should be_blank
-    end
-  end
-  describe "under_embargo?" do
-    it "should return true if the current date is before the embargo release date" do
-      @sample.embargo_release_date=Date.today+1.month
-      @sample.under_embargo?.should be_true
-    end
-    it "should return false if the current date is after the embargo release date" do
-      @sample.embargo_release_date=Date.today-1.month
-      @sample.under_embargo?.should be_false
-    end
-    it "should return false if there is no embargo date" do
-      @sample.under_embargo?.should be_false
-    end
-  end
-end

data/test_support/spec/models/role_mapper_spec.rb

@@ -1,22 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe RoleMapper do
-  
- it "should define the 4 roles" do
-   RoleMapper.role_names.sort.should == %w(admin_policy_object_editor archivist donor patron researcher) 
- end
- it "should quer[iy]able for roles for a given user" do
-   RoleMapper.roles('leland_himself@example.com').sort.should == ['archivist', 'donor', 'patron']
-   RoleMapper.roles('archivist2@example.com').should == ['archivist']
- end
-
- it "should return an empty array if there are no roles" do
-   RoleMapper.roles('zeus@olympus.mt').empty?.should == true
- end
- it "should know who is what" do
-   RoleMapper.whois('archivist').sort.should == %w(archivist1@example.com archivist2@example.com leland_himself@example.com)
-   RoleMapper.whois('salesman').empty?.should == true
-   RoleMapper.whois('admin_policy_object_editor').sort.should == %w(archivist1@example.com)
- end
-
-end

data/test_support/spec/unit/rights_metadata_spec.rb

@@ -1,80 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Hydra::ModelMixins::RightsMetadata do
-  subject { ModsAsset.new }
-  it "should have a set of permissions" do
-    subject.discover_groups=['group1', 'group2']
-    subject.edit_users=['user1']
-    subject.read_users=['user2', 'user3']
-    subject.permissions.should include({:type=>"group", :access=>"discover", :name=>"group1"},
-        {:type=>"group", :access=>"discover", :name=>"group2"},
-        {:type=>"user", :access=>"read", :name=>"user2"},
-        {:type=>"user", :access=>"read", :name=>"user3"},
-        {:type=>"user", :access=>"edit", :name=>"user1"})
-  end
-
-  describe "updating permissions" do
-    it "should create new group permissions" do
-      subject.permissions = [{:name=>'group1', :access=>'discover', :type=>'group'}]
-      subject.permissions.should == [{:type=>'group', :access=>'discover', :name=>'group1'}]
-    end
-    it "should create new user permissions" do
-      subject.permissions = [{:name=>'user1', :access=>'discover', :type=>'user'}]
-      subject.permissions.should == [{:type=>'user', :access=>'discover', :name=>'user1'}]
-    end
-    it "should not replace existing groups" do
-      subject.permissions = [{:name=>'group1', :access=>'discover', :type=>'group'}]
-      subject.permissions = [{:name=>'group2', :access=>'discover', :type=>'group'}]
-      subject.permissions.should == [{:type=>'group', :access=>'discover', :name=>'group1'},
-                                   {:type=>'group', :access=>'discover', :name=>'group2'}]
-    end
-    it "should not replace existing users" do
-      subject.permissions = [{:name=>'user1', :access=>'discover', :type=>'user'}]
-      subject.permissions = [{:name=>'user2', :access=>'discover', :type=>'user'}]
-      subject.permissions.should == [{:type=>'user', :access=>'discover', :name=>'user1'},
-                                   {:type=>'user', :access=>'discover', :name=>'user2'}]
-    end
-    it "should update permissions on existing users" do
-      subject.permissions = [{:name=>'user1', :access=>'discover', :type=>'user'}]
-      subject.permissions = [{:name=>'user1', :access=>'edit', :type=>'user'}]
-      subject.permissions.should == [{:type=>'user', :access=>'edit', :name=>'user1'}]
-    end
-    it "should update permissions on existing groups" do
-      subject.permissions = [{:name=>'group1', :access=>'discover', :type=>'group'}]
-      subject.permissions = [{:name=>'group1', :access=>'edit', :type=>'group'}]
-      subject.permissions.should == [{:type=>'group', :access=>'edit', :name=>'group1'}]
-    end
-
-  end
-
-  context "with rightsMetadata" do
-    before do
-      subject.rightsMetadata.update_permissions("person"=>{"person1"=>"read","person2"=>"discover"}, "group"=>{'group-6' => 'read', "group-7"=>'read', 'group-8'=>'edit'})
-      subject.save
-    end
-    it "should have read groups accessor" do
-      subject.read_groups.should == ['group-6', 'group-7']
-    end
-    it "should have read groups string accessor" do
-      subject.read_groups_string.should == 'group-6, group-7'
-    end
-    it "should have read groups writer" do
-      subject.read_groups = ['group-2', 'group-3']
-      subject.rightsMetadata.groups.should == {'group-2' => 'read', 'group-3'=>'read', 'group-8' => 'edit'}
-      subject.rightsMetadata.individuals.should == {"person1"=>"read","person2"=>"discover"}
-    end
-
-    it "should have read groups string writer" do
-      subject.read_groups_string = 'umg/up.dlt.staff, group-3'
-      subject.rightsMetadata.groups.should == {'umg/up.dlt.staff' => 'read', 'group-3'=>'read', 'group-8' => 'edit'}
-      subject.rightsMetadata.individuals.should == {"person1"=>"read","person2"=>"discover"}
-    end
-    it "should only revoke eligible groups" do
-      subject.set_read_groups(['group-2', 'group-3'], ['group-6'])
-      # 'group-7' is not eligible to be revoked
-      subject.rightsMetadata.groups.should == {'group-2' => 'read', 'group-3'=>'read', 'group-7' => 'read', 'group-8' => 'edit'}
-      subject.rightsMetadata.individuals.should == {"person1"=>"read","person2"=>"discover"}
-    end
-  end
-
-end