hydra-access-controls 8.2.0 → 9.0.0.beta1

data/lib/hydra/datastream/rights_metadata.rb

@@ -1,276 +0,0 @@
-require 'active_support/core_ext/string'
-module Hydra
-  module Datastream
-    # Implements Hydra RightsMetadata XML terminology for asserting access permissions
-    class RightsMetadata < ActiveFedora::OmDatastream       
-      
-      set_terminology do |t|
-        t.root(:path=>"rightsMetadata", :xmlns=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", :schema=>"http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd") 
-        t.copyright {
-          ## BEGIN possible delete, justin 2012-06-22
-          t.machine {
-            t.cclicense   
-            t.license     
-          }
-          t.human_readable(:path=>"human")
-          t.license(:proxy=>[:machine, :license ])            
-          t.cclicense(:proxy=>[:machine, :cclicense ])                  
-          ## END possible delete
-
-          t.title(:path=>'human', :attributes=>{:type=>'title'})
-          t.description(:path=>'human', :attributes=>{:type=>'description'})
-          t.url(:path=>'machine', :attributes=>{:type=>'uri'})
-        }
-        t.access do
-          t.human_readable(:path=>"human")
-          t.machine {
-            t.group
-            t.person
-          }
-          t.person(:proxy=>[:machine, :person])
-          t.group(:proxy=>[:machine, :group])
-          # accessor :access_person, :term=>[:access, :machine, :person]
-        end
-        t.discover_access(:ref=>[:access], :attributes=>{:type=>"discover"})
-        t.read_access(:ref=>[:access], :attributes=>{:type=>"read"})
-        t.edit_access(:ref=>[:access], :attributes=>{:type=>"edit"})
-        # A bug in OM prevnts us from declaring proxy terms at the root of a Terminology
-        # t.access_person(:proxy=>[:access,:machine,:person])
-        # t.access_group(:proxy=>[:access,:machine,:group])
-        
-        t.embargo {
-          t.human_readable(path: "human")
-          t.machine{
-            t.date(type: :time, attributes: {type: "release"})
-            t.date_deactivated(type: "deactivated")
-            t.visibility_during(path: "visibility", attributes: {scope: 'during'})
-            t.visibility_after(path: "visibility", attributes: {scope: 'after'})
-          }
-        }
-
-        t.lease {
-          t.human_readable(path: "human")
-          t.machine{
-            t.date(type: :time, attributes: {type: "expire"})
-            t.date_deactivated(type: :time, attributes: {type: "deactivated"})
-            t.visibility_during(path: "visibility", attributes: {scope: 'during'})
-            t.visibility_after(path: "visibility", attributes: {scope: 'after'})
-          }
-        }
-
-        t.license(:ref=>[:copyright])
-
-        t.visibility_during_embargo proxy: [:embargo, :machine, :visibility_during]
-        t.visibility_after_embargo proxy: [:embargo, :machine, :visibility_after]
-        t.visibility_during_lease proxy: [:lease, :machine, :visibility_during]
-        t.visibility_after_lease proxy: [:lease, :machine, :visibility_after]
-        t.embargo_history proxy: [:embargo, :human_readable]
-        t.lease_history proxy: [:lease, :human_readable]
-        t.embargo_release_date proxy: [:embargo, :machine, :date], type: :time
-        t.embargo_deactivation_date proxy: [:embargo, :machine, :date_deactivated]
-        t.lease_expiration_date proxy: [:lease, :machine, :date], type: :time
-        t.lease_deactivation_date proxy: [:lease, :machine, :date_deactivated]
-
-      end
-
-      # Generates an empty Mods Article (used when you call ModsArticle.new without passing in existing xml)
-      def self.xml_template
-        builder = Nokogiri::XML::Builder.new do |xml|
-          xml.rightsMetadata(:version=>"0.1", "xmlns"=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1") {
-            xml.copyright {
-              xml.human(:type=>'title')
-              xml.human(:type=>'description')
-              xml.machine(:type=>'uri')
-              
-            }
-            xml.access(:type=>"discover") {
-              xml.human
-              xml.machine
-            }
-            xml.access(:type=>"read") {
-              xml.human 
-              xml.machine
-            }
-            xml.access(:type=>"edit") {
-              xml.human
-              xml.machine
-            }
-            xml.embargo{
-              xml.machine
-            }
-            xml.lease{
-              xml.machine
-            }
-          }
-        end
-        return builder.doc
-      end
-        
-      # Returns the permissions for the selected person/group
-      # If new_access_level is provided, updates the selected person/group access_level to the one specified 
-      # A new_access_level of "none" will remove all access_levels for the selected person/group
-      # @param [Hash] selector hash in format {type => identifier}
-      # @param new_access_level (default nil)
-      # @return Hash in format {type => access_level}.  
-      # 
-      # ie. 
-      # permissions({:person=>"person123"})
-      # => {"person123"=>"edit"}
-      # permissions({:person=>"person123"}, "read")
-      # => {"person123"=>"read"}
-      # permissions({:person=>"person123"})
-      # => {"person123"=>"read"}
-      def permissions(selector, new_access_level=nil)
-        type = selector.keys.first.to_sym
-        actor = selector.values.first
-        if new_access_level.nil?
-          xpath = xpath(type, actor)
-          nodeset = self.find_by_terms(xpath)
-          if nodeset.empty?
-            return "none"
-          else
-            return nodeset.first.ancestors("access").first.attributes["type"].text
-          end
-        else
-          remove_all_permissions(selector)
-          if new_access_level == "none" 
-            self.content = self.to_xml
-          else
-            access_type_symbol = "#{new_access_level}_access".to_sym
-            current_values = term_values(access_type_symbol, type)
-            self.update_values([access_type_symbol, type] => current_values + [actor] )
-          end
-          return new_access_level
-        end
-          
-      end
-      
-      # Reports on which groups have which permissions
-      # @return Hash in format {group_name => group_permissions, group_name => group_permissions}
-      def groups
-        return quick_search_by_type(:group)
-      end
-      
-      # Reports on which users have which permissions
-      # @return Hash in format {user_name => user_permissions, user_name => user_permissions}
-      def users
-        return quick_search_by_type(:person)
-      end
-      
-      # Updates permissions for all of the persons and groups in a hash
-      # @param params ex. {"group"=>{"group1"=>"discover","group2"=>"edit"}, "person"=>{"person1"=>"read","person2"=>"discover"}}
-      # Currently restricts actor type to group or person.  Any others will be ignored
-      def update_permissions(params)
-        params.fetch("group", {}).each_pair {|group_id, access_level| self.permissions({"group"=>group_id}, access_level)}
-        params.fetch("person", {}).each_pair {|person_id, access_level| self.permissions({"person"=>person_id}, access_level)}
-      end
-
-      # Updates all permissions
-      # @param params ex. {"group"=>{"group1"=>"discover","group2"=>"edit"}, "person"=>{"person1"=>"read","person2"=>"discover"}}
-      # Restricts actor type to group or person.  Any others will be ignored
-      def permissions= (params)
-        groups_for_update = params['group'] ? params['group'].keys : []
-        group_ids = groups.keys | groups_for_update
-        group_ids.each {|group_id| self.permissions({"group"=>group_id}, params['group'].fetch(group_id, 'none'))}
-        users_for_update = params['person'] ? params['person'].keys : []
-        user_ids = users.keys | users_for_update
-        user_ids.each {|person_id| self.permissions({"person"=>person_id}, params['person'].fetch(person_id, 'none'))}
-      end
-      
-      # @param [Symbol] type (either :group or :person)
-      # @return 
-      # This method limits the response to known access levels.  Probably runs a bit faster than .permissions().
-      def quick_search_by_type(type)
-        result = {}
-        [{:discover_access=>"discover"},{:read_access=>"read"},{:edit_access=>"edit"}].each do |access_levels_hash|
-          access_level = access_levels_hash.keys.first
-          access_level_name = access_levels_hash.values.first
-          self.find_by_terms(*[access_level, type]).each do |entry|
-            result[entry.text] = access_level_name
-          end
-        end
-        return result
-      end
-
-      def under_embargo?
-        (embargo_release_date.present? && Date.today < embargo_release_date.first) ? true : false
-      end
-
-      def active_lease?
-        lease_expiration_date.present? && Date.today < lease_expiration_date.first
-      end
-
-      def to_solr(solr_doc=Hash.new)
-        [:discover, :read, :edit].each do |access|
-          vals = send("#{access}_access").machine.group
-          solr_doc[Hydra.config.permissions[access].group] = vals unless vals.empty?
-          vals = send("#{access}_access").machine.person
-          solr_doc[Hydra.config.permissions[access].individual] = vals unless vals.empty?
-        end
-        if embargo_release_date.present?
-          key = Hydra.config.permissions.embargo.release_date.sub(/_[^_]+$/, '') #Strip off the suffix
-          ::Solrizer.insert_field(solr_doc, key, embargo_release_date, :stored_sortable)
-        end
-        if lease_expiration_date.present?
-          key = Hydra.config.permissions.lease.expiration_date.sub(/_[^_]+$/, '') #Strip off the suffix
-          ::Solrizer.insert_field(solr_doc, key, lease_expiration_date, :stored_sortable)
-        end
-        solr_doc[::Solrizer.solr_name("visibility_during_embargo", :symbol)] = visibility_during_embargo unless visibility_during_embargo.nil?
-        solr_doc[::Solrizer.solr_name("visibility_after_embargo", :symbol)] = visibility_after_embargo unless visibility_after_embargo.nil?
-        solr_doc[::Solrizer.solr_name("visibility_during_lease", :symbol)] = visibility_during_lease unless visibility_during_lease.nil?
-        solr_doc[::Solrizer.solr_name("visibility_after_lease", :symbol)] = visibility_after_lease unless visibility_after_lease.nil?
-        solr_doc[::Solrizer.solr_name("embargo_history", :symbol)] = embargo_history unless embargo_history.nil?
-        solr_doc[::Solrizer.solr_name("lease_history", :symbol)] = lease_history unless lease_history.nil?
-        solr_doc
-      end
-
-      def indexer
-        self.class.indexer
-      end
-
-      def self.indexer
-        @indexer ||= Solrizer::Descriptor.new(:string, :stored, :indexed, :multivalued)
-      end
-
-      def date_indexer
-        self.class.date_indexer
-      end
-
-      def self.date_indexer
-        @date_indexer ||= Solrizer::Descriptor.new(:date, :stored, :indexed)
-      end
-
-      # Completely clear the permissions
-      def clear_permissions!
-        remove_all_permissions({:person=>true})
-        remove_all_permissions({:group=>true})
-      end
-
-
-      
-      private
-      # Purge all access given group/person 
-      def remove_all_permissions(selector)
-        return unless ng_xml
-        type = selector.keys.first.to_sym
-        actor = selector.values.first
-        xpath = xpath(type, actor)
-        nodes_to_purge = self.find_by_terms(xpath)
-        nodes_to_purge.each {|node| node.remove}
-      end
-
-      # @param [Symbol] type (:group, :person)
-      # @param [String,TrueClass] actor the user we want to find. If actor is true, then don't query.
-      def xpath(type, actor)
-        raise ArgumentError, "Type must either be ':group' or ':person'. You provided: '#{type.inspect}'" unless [:group, :person].include?(type)
-        path = "//oxns:access/oxns:machine/oxns:#{type}"
-        if actor.is_a? String
-          clean_actor = actor.gsub("'", '')
-          path += "[text() = '#{clean_actor}']" 
-        end
-        path
-      end
-      
-    end
-  end
-end

data/lib/hydra/datastream.rb

@@ -1,7 +0,0 @@
-module Hydra
-  module Datastream
-    extend ActiveSupport::Autoload
-    autoload :RightsMetadata
-    autoload :InheritableRightsMetadata
-  end
-end

data/spec/unit/hydra_rights_metadata_persistence_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe Hydra::Datastream::RightsMetadata do
-  before :all do
-    class RightsTest < ActiveFedora::Base
-      include Hydra::AccessControls::Permissions
-    end
-  end
-
-  after :all do
-    Object.send(:remove_const,:RightsTest)
-  end
-
-  describe "rightsMetadata" do
-    let!(:thing) {RightsTest.new}
-
-    [:discover,:read, :edit].each do |mode|
-      describe "##{mode}_users" do
-        let(:get_method) {"#{mode}_users".to_sym}
-        let(:set_method) {"#{mode}_users=".to_sym}
-
-        before :each do
-          thing.send(set_method, ['locutus@borg.collective.mil'])
-          thing.save
-        end
-
-        it "should persist initial setting" do
-          thing.reload.send(get_method).should == ['locutus@borg.collective.mil']
-        end
-
-        it "should persist changes" do
-          thing.send(set_method, ['locutus@borg.collective.mil','sevenofnine@borg.collective.mil'])
-          thing.save
-          thing.reload.send(get_method).should =~ ['locutus@borg.collective.mil','sevenofnine@borg.collective.mil']
-        end
-
-        it "should persist emptiness" do
-          thing.send(set_method, [])
-          thing.save
-          thing.reload.send(get_method).should == []
-        end
-      end
-
-      describe "##{mode}_groups" do
-        let(:get_method) {"#{mode}_groups".to_sym}
-        let(:set_method) {"#{mode}_groups=".to_sym}
-
-        before :each do
-          thing.send(set_method, ['borg'])
-          thing.save
-        end
-
-        it "should persist initial setting" do
-          thing.reload.send(get_method).should == ['borg']
-        end
-
-        it "should persist changes" do
-          thing.send(set_method, ['borg','federation'])
-          thing.save
-          thing.reload.send(get_method).should =~ ['borg','federation']
-        end
-
-        it "should persist emptiness" do
-          thing.send(set_method, [])
-          thing.save
-          thing.reload.send(get_method).should == []
-        end
-      end
-    end
-  end
-end

data/spec/unit/hydra_rights_metadata_spec.rb

@@ -1,301 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Hydra::Datastream::RightsMetadata do
-
-  let(:obj) { ActiveFedora::Base.new }
-  let(:sample) { Hydra::Datastream::RightsMetadata.new(obj.inner_object, nil) }
-  
-  describe "license" do
-    before do
-      sample.license.title = "Creative Commons Attribution 3.0 Unported License." 
-      sample.license.description = "This Creative Commons license lets others distribute, remix, tweak, and build upon your work, even commercially, as long as they credit you for the original creation. This is the most accommodating of licenses offered. Recommended for maximum dissemination and use of licensed materials." 
-      sample.license.url = "http://creativecommons.org/licenses/by/3.0/" 
-    end
-    subject { sample.license}
-    its(:title) {should == ["Creative Commons Attribution 3.0 Unported License."] }
-    its(:description) { should == ["This Creative Commons license lets others distribute, remix, tweak, and build upon your work, even commercially, as long as they credit you for the original creation. This is the most accommodating of licenses offered. Recommended for maximum dissemination and use of licensed materials."] }
-    its(:url) {should == ["http://creativecommons.org/licenses/by/3.0/"] }
-
-    it "should be accessable as a term path" do
-      # This enables us to use:
-      #  delegate :license_title, :to=>'rightsMetadata', :at=>[:license, :title]
-      sample.term_values(:license, :title).should == ["Creative Commons Attribution 3.0 Unported License."]
-    end
-  end
-  
-  describe "permissions" do
-    describe "setter" do
-      it "should set person permissions" do
-        sample.permissions = {"person"=>{"maria"=>"read","marcus"=>"discover"}}
-      end
-      it "should set group permissions" do
-        sample.permissions = {"group"=>{"librarians"=>"read","students"=>"discover"}}
-      end
-      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")
-      expect(sample.users).to eq("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.should_receive(:permissions).with({"group" => "group1"}, "discover")
-      sample.should_receive(:permissions).with({"group" => "group2"}, "edit")
-      sample.should_receive(:permissions).with({"person" => "person1"}, "read")
-      sample.should_receive(:permissions).with({"person" => "person2"}, "discover")
-      
-      sample.update_permissions( {"group"=>{"group1"=>"discover","group2"=>"edit"}, "person"=>{"person1"=>"read","person2"=>"discover"}} )
-    end
-  end
-
-  describe "clear_permissions!" do
-    before do
-      sample.permissions({"person"=>"person_123"}, "read")
-      sample.permissions({"person"=>"person_456"}, "edit")
-      sample.permissions({"person"=>"person_789"}, "discover")
-      sample.permissions({"group"=>"group_123"}, "read")
-      sample.permissions({"group"=>"group_456"}, "edit")
-      sample.permissions({"group"=>"group_789"}, "discover")
-    end
-    it "clears permissions" do
-      sample.clear_permissions!
-      expect(sample.users).to eq({})
-      expect(sample.groups).to eq({})
-    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_ssim"].should == ["Lil Kim"]
-      solr_doc["edit_access_group_ssim"].sort.should == ["group1", "group2"]
-      solr_doc["discover_access_person_ssim"].should == ["Joe Schmoe"]
-      solr_doc["discover_access_group_ssim"].should == ["public"]
-    end
-    it "should solrize fixture content correctly" do
-      lsample = Hydra::Datastream::RightsMetadata.new(nil, nil)
-      lsample.update_permissions({'person' => {'researcher1' => 'edit'},
-                                  'group' => {'archivist' => 'edit', 'public' =>'read', 'bob'=>'discover'}})
-
-      solr_doc = lsample.to_solr
-      solr_doc["edit_access_person_ssim"].should == ["researcher1"]
-      solr_doc["edit_access_group_ssim"].should == ["archivist"]
-      solr_doc["read_access_group_ssim"].should == ["public"]
-      solr_doc["discover_access_group_ssim"].should == ["bob"]
-    end
-
-    it "should solrize embargo information if set" do
-      sample.embargo_release_date = DateTime.parse("2010-12-01T23:59:59+0")
-      solr_doc = sample.to_solr
-      expect(solr_doc["embargo_release_date_dtsi"]).to eq "2010-12-01T23:59:59Z"
-    end
-
-    it "should solrize lease information if set" do
-      sample.lease_expiration_date = DateTime.parse("2010-12-01T23:59:59Z")
-      solr_doc = sample.to_solr
-      expect(solr_doc["lease_expiration_date_dtsi"]).to eq "2010-12-01T23:59:59Z"
-    end
-  end
-
-  describe "embargo" do
-    describe "embargo_release_date=" do
-      it "should update the appropriate node with the value passed" do
-        sample.embargo_release_date = Date.parse("2010-12-01")
-        expect(sample.embargo_release_date).to eq [Date.parse("2010-12-01").to_time.utc]
-      end
-
-      it "should accept a nil value after having a date value" do
-        sample.embargo_release_date = Date.parse("2010-12-01")
-        sample.embargo_release_date = nil
-        expect(sample.embargo_release_date).to be_empty
-      end
-    end
-
-    describe "embargo_release_date" do
-      it "should return solr formatted date" do
-        sample.embargo_release_date = DateTime.parse("2010-12-01T23:59:59Z")
-        expect(sample.embargo_release_date).to eq [DateTime.parse("2010-12-01T23:59:59Z")]
-      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
-        expect(sample).to be_under_embargo
-      end
-
-      it "should return false if the current date is after the embargo release date" do
-        sample.embargo_release_date=Date.today-1.month
-        expect(sample).to_not be_under_embargo
-      end
-
-      it "should return false if there is no embargo date" do
-        sample.embargo_release_date = nil
-        expect(sample).to_not be_under_embargo
-      end
-    end
-
-    describe "visibility during/after embargo" do
-      it "should track visibility values and index them into solr" do
-        expect(sample.visibility_during_embargo).to be_empty
-        expect(sample.visibility_after_embargo).to be_empty
-        sample.visibility_during_embargo = "private"
-        sample.visibility_after_embargo = "restricted"
-        expect(sample.visibility_during_embargo).to eq ["private"]
-        expect(sample.visibility_after_embargo).to eq ["restricted"]
-        solr_doc = sample.to_solr
-        expect(solr_doc["visibility_during_embargo_ssim"]).to eq ["private"]
-        expect(solr_doc["visibility_after_embargo_ssim"]).to eq ["restricted"]
-      end
-
-      it "has the correct xpath" do
-        expect(sample.visibility_during_embargo.xpath).to eq "//oxns:embargo/oxns:machine/oxns:visibility[@scope=\"during\"]"
-        expect(sample.visibility_after_embargo.xpath).to eq "//oxns:embargo/oxns:machine/oxns:visibility[@scope=\"after\"]"
-      end
-    end
-
-    describe 'embargo_history' do
-      subject { sample.embargo_history }
-      it "has the correct xpath" do
-        expect(subject.xpath).to eq '//oxns:embargo/oxns:human'
-      end
-    end
-  end
-
-  describe "leases" do
-
-    describe "lease_expiration_date=" do
-      it "should update the appropriate node with the value passed" do
-        sample.lease_expiration_date = "2010-12-01"
-        expect(sample.lease_expiration_date).to eq [Date.parse("2010-12-01").to_time.utc]
-      end
-      it "should only accept valid date values" do
-
-      end
-      it "should accept a nil value after having a date value" do
-        sample.lease_expiration_date = "2010-12-01"
-        sample.lease_expiration_date = nil
-        expect(sample.lease_expiration_date).to be_empty
-      end
-    end
-
-    describe "active_lease?" do
-      it "should return true if the current date is after the lease expiration date" do
-        sample.lease_expiration_date = Date.today-1.month
-        expect(sample).to_not be_active_lease
-      end
-      it "should return false if the current date is before the lease expiration date" do
-        sample.lease_expiration_date = Date.today+1.month
-        expect(sample).to be_active_lease
-      end
-      it "should return false if there is no lease expiration date" do
-        sample.lease_expiration_date = nil
-        expect(sample).to_not be_active_lease
-      end
-    end
-
-    describe "visibility during/after lease" do
-      it "should track visibility values and index them into solr" do
-        expect(sample.visibility_during_lease).to be_empty
-        expect(sample.visibility_after_lease).to be_empty
-        sample.visibility_during_lease = "restricted"
-        sample.visibility_after_lease = "private"
-        expect(sample.visibility_during_lease).to eq ["restricted"]
-        expect(sample.visibility_after_lease).to eq ["private"]
-        solr_doc = sample.to_solr
-        expect(solr_doc["visibility_during_lease_ssim"]).to eq ["restricted"]
-        expect(solr_doc["visibility_after_lease_ssim"]).to eq ["private"]
-      end
-
-      it "has the correct xpath" do
-        expect(sample.visibility_during_lease.xpath).to eq "//oxns:lease/oxns:machine/oxns:visibility[@scope=\"during\"]"
-        expect(sample.visibility_after_lease.xpath).to eq "//oxns:lease/oxns:machine/oxns:visibility[@scope=\"after\"]"
-      end
-    end
-
-    describe 'lease_history' do
-      subject { sample.lease_history }
-      it "has the correct xpath" do
-        expect(subject.xpath).to eq '//oxns:lease/oxns:human'
-      end
-    end
-  end
-end