hydra-access-controls 8.2.0 → 9.0.0.beta1

data/spec/unit/admin_policy_spec.rb

@@ -1,104 +1,101 @@
 require 'spec_helper'
 
 describe Hydra::AdminPolicy do
-  its(:defaultRights) { should be_kind_of Hydra::Datastream::InheritableRightsMetadata}
-  its(:rightsMetadata) { should be_kind_of Hydra::Datastream::RightsMetadata}
-  its(:descMetadata) { should be_kind_of ActiveFedora::QualifiedDublinCoreDatastream}
 
   describe "when setting attributes" do
     before do
-      subject.title = "My title" 
-      subject.description = "My description" 
-      subject.license_title = "My license" 
-      subject.license_description = "My license desc" 
-      subject.license_url = "My url" 
-    end
-    its(:title) { should == "My title"}
-    its(:description) { should == "My description"}
-    its(:license_title) { should == "My license"}
-    its(:license_description) { should == "My license desc"}
-    its(:license_url) { should == "My url"}
+      subject.title = "My title"
+      subject.description = "My description"
+    end
+    its(:title) { is_expected.to eq "My title"}
+    its(:description) { is_expected.to eq "My description"}
   end
-    
+
 
   describe "to_solr" do
     subject { Hydra::AdminPolicy.new(:title=>"Foobar").to_solr }
     it "should have title_ssim" do
-      subject[ActiveFedora::SolrService.solr_name('title', type: :string)].should == "Foobar"
+      expect(subject[ActiveFedora::SolrQueryBuilder.solr_name('title', type: :string)]).to eq ["Foobar"]
     end
   end
 
   describe "updating default permissions" do
     it "should create new group permissions" do
-      subject.default_permissions = [{:name=>'group1', :access=>'discover', :type=>'group'}]
-      subject.default_permissions.should == [{:type=>'group', :access=>'discover', :name=>'group1'}]
+      subject.default_permissions.build({:name=>'group1', :access=>'discover', :type=>'group'})
+      expect(subject.default_permissions.map(&:to_hash)).to eq [{:type=>'group', :access=>'discover', :name=>'group1'}]
     end
     it "should create new user permissions" do
-      subject.default_permissions = [{:name=>'user1', :access=>'discover', :type=>'user'}]
-      subject.default_permissions.should == [{:type=>'user', :access=>'discover', :name=>'user1'}]
+      subject.default_permissions.build({:name=>'user1', :access=>'discover', :type=>'person'})
+      expect(subject.default_permissions.map(&:to_hash)).to eq [{:type=>'person', :access=>'discover', :name=>'user1'}]
     end
     it "should not replace existing groups" do
-      subject.default_permissions = [{:name=>'group1', :access=>'discover', :type=>'group'}]
-      subject.default_permissions = [{:name=>'group2', :access=>'discover', :type=>'group'}]
-      subject.default_permissions.should == [{:type=>'group', :access=>'discover', :name=>'group1'},
+      subject.default_permissions.build({:name=>'group1', :access=>'discover', :type=>'group'})
+      subject.default_permissions.build({:name=>'group2', :access=>'discover', :type=>'group'})
+      expect(subject.default_permissions.map(&:to_hash)).to eq [{:type=>'group', :access=>'discover', :name=>'group1'},
                                    {:type=>'group', :access=>'discover', :name=>'group2'}]
     end
     it "should not replace existing users" do
-      subject.default_permissions = [{:name=>'user1', :access=>'discover', :type=>'user'}]
-      subject.default_permissions = [{:name=>'user2', :access=>'discover', :type=>'user'}]
-      subject.default_permissions.should == [{:type=>'user', :access=>'discover', :name=>'user1'},
-                                   {:type=>'user', :access=>'discover', :name=>'user2'}]
+      subject.default_permissions.build({:name=>'user1', :access=>'discover', :type=>'person'})
+      subject.default_permissions.build({:name=>'user2', :access=>'discover', :type=>'person'})
+      expect(subject.default_permissions.map(&:to_hash)).to eq [{:type=>'person', :access=>'discover', :name=>'user1'},
+                                   {:type=>'person', :access=>'discover', :name=>'user2'}]
     end
     it "should update permissions on existing users" do
-      subject.default_permissions = [{:name=>'user1', :access=>'discover', :type=>'user'}]
-      subject.default_permissions = [{:name=>'user1', :access=>'edit', :type=>'user'}]
-      subject.default_permissions.should == [{:type=>'user', :access=>'edit', :name=>'user1'}]
+      subject.default_permissions.build({:name=>'user1', :access=>'discover', :type=>'person'})
+      subject.default_permissions.first.mode = ::ACL.Write
+      expect(subject.default_permissions.map(&:to_hash)).to eq [{:type=>'person', :access=>'edit', :name=>'user1'}]
     end
     it "should update permissions on existing groups" do
-      subject.default_permissions = [{:name=>'group1', :access=>'discover', :type=>'group'}]
-      subject.default_permissions = [{:name=>'group1', :access=>'edit', :type=>'group'}]
-      subject.default_permissions.should == [{:type=>'group', :access=>'edit', :name=>'group1'}]
+      subject.default_permissions.build({:name=>'group1', :access=>'discover', :type=>'group'})
+      subject.default_permissions.first.mode = ::ACL.Write
+      expect(subject.default_permissions.map(&:to_hash)).to eq [{:type=>'group', :access=>'edit', :name=>'group1'}]
     end
     it "should assign user permissions when :type == 'person'" do
-      subject.default_permissions = [{:name=>'user1', :access=>'discover', :type=>'person'}]
-      subject.default_permissions.should == [{:type=>'user', :access=>'discover', :name=>'user1'}]
+      subject.default_permissions.build({:name=>'user1', :access=>'discover', :type=>'person'})
+      expect(subject.default_permissions.map(&:to_hash)).to eq [{:type=>'person', :access=>'discover', :name=>'user1'}]
     end
     it "should raise an ArgumentError when the :type hashkey is invalid" do
-      expect{subject.default_permissions = [{:name=>'user1', :access=>'read', :type=>'foo'}]}.to raise_error(ArgumentError)
+      expect { subject.default_permissions.build({:name=>'user1', :access=>'read', :type=>'foo'}) }.to raise_error(ArgumentError, 'Unknown agent type "foo"')
     end
   end
-  
+
   describe "Inheritable rights" do
     before do
       @policy = Hydra::AdminPolicy.new
-      @policy.default_permissions = [{:name=>"africana-faculty", :access=>"edit", :type=>"group"}, {:name=>"cool-kids", :access=>"edit", :type=>"group"}, {:name=>"julius_caesar", :access=>"edit", :type=>"user"}]
-      @policy.default_permissions = [{:name=>"slightlycoolkids", :access=>"read", :type=>"group"}, {:name=>"nero", :access=>"read", :type=>"user"}]
-      @policy.default_permissions = [{:name=>"posers", :access=>"discover", :type=>"group"}, {:name=>"constantine", :access=>"discover", :type=>"user"}]
-      @policy.defaultRights.embargo_release_date = "2102-10-01"
+      @policy.default_permissions.build([
+        {:name=>"africana-faculty", :access=>"edit", :type=>"group"},
+        {:name=>"cool-kids", :access=>"edit", :type=>"group"},
+        {:name=>"julius_caesar", :access=>"edit", :type=>"person"},
+        {:name=>"slightlycoolkids", :access=>"read", :type=>"group"},
+        {:name=>"nero", :access=>"read", :type=>"person"},
+        {:name=>"posers", :access=>"discover", :type=>"group"},
+        {:name=>"constantine", :access=>"discover", :type=>"person"}
+      ])
+      @policy.build_default_embargo.embargo_release_date = "2102-10-01"
     end
 
     describe "to_solr" do
-      subject {@policy.to_solr}
-      it "should not affect normal solr permissions fields" do    
-        subject.should_not have_key( Hydra.config[:permissions][:discover][:group] ) 
-        subject.should_not have_key( Hydra.config[:permissions][:discover][:individual] )
-        subject.should_not have_key( Hydra.config[:permissions][:read][:group] )
-        subject.should_not have_key( Hydra.config[:permissions][:read][:individual] )
-        subject.should_not have_key( Hydra.config[:permissions][:edit][:group] )
-        subject.should_not have_key( Hydra.config[:permissions][:edit][:individual] )
-        subject.should_not have_key( Hydra.config[:permissions][:embargo_release_date] )
+      subject { @policy.to_solr }
+
+      it "should not affect normal solr permissions fields" do
+        expect(subject).to_not have_key Hydra.config.permissions.discover.group
+        expect(subject).to_not have_key Hydra.config.permissions.discover.individual
+        expect(subject).to_not have_key Hydra.config.permissions.read.group
+        expect(subject).to_not have_key Hydra.config.permissions.read.individual
+        expect(subject).to_not have_key Hydra.config.permissions.edit.group
+        expect(subject).to_not have_key Hydra.config.permissions.edit.individual
+        expect(subject).to_not have_key Hydra.config.permissions.embargo.release_date
       end
+
       it "should provide prefixed/inherited solr permissions fields" do
-        subject[Hydra.config[:permissions][:inheritable][:discover][:group] ].should == ["posers"]
-        subject[Hydra.config[:permissions][:inheritable][:discover][:individual] ].should == ["constantine"]
-        subject[Hydra.config[:permissions][:inheritable][:read][:group] ].should == ["slightlycoolkids"]
-        subject[Hydra.config[:permissions][:inheritable][:read][:individual] ].should == ["nero"]
-        inheritable_group = Hydra.config[:permissions][:inheritable][:edit][:group]
-        subject[inheritable_group].length.should == 2
-        subject[inheritable_group].should include("africana-faculty", "cool-kids")
-
-        subject[Hydra.config[:permissions][:inheritable][:edit][:individual] ].should == ["julius_caesar"]
-        expect(subject[Hydra.config[:permissions][:inheritable][:embargo_release_date] ]).to eq Date.parse("2102-10-01").to_time.utc.iso8601
+        expect(subject[Hydra.config.permissions.inheritable.discover.group]).to eq ["posers"]
+        expect(subject[Hydra.config.permissions.inheritable.discover.individual]).to eq ["constantine"]
+        expect(subject[Hydra.config.permissions.inheritable.read.group]).to eq ["slightlycoolkids"]
+        expect(subject[Hydra.config.permissions.inheritable.read.individual]).to eq ["nero"]
+        expect(subject[Hydra.config.permissions.inheritable.edit.group]).to match_array ["africana-faculty", "cool-kids"]
+
+        expect(subject[Hydra.config.permissions.inheritable.edit.individual]).to eq ["julius_caesar"]
+        expect(subject[Hydra.config.permissions.inheritable.embargo.release_date]).to eq DateTime.parse("2102-10-01").to_time.utc.iso8601
       end
     end
 
@@ -110,8 +107,9 @@ describe Hydra::AdminPolicy do
   describe "When accessing assets with Policies associated" do
     before do
       @user = FactoryGirl.build(:martia_morocco)
-      RoleMapper.stub(:roles).with(@user).and_return(@user.roles)
+      allow(RoleMapper).to receive(:roles).with(@user).and_return(@user.roles)
     end
+
     before(:all) do
       class TestAbility
         include Hydra::PolicyAwareAbility
@@ -121,54 +119,60 @@ describe Hydra::AdminPolicy do
     after(:all) do
       Object.send(:remove_const, :TestAbility)
     end
+
     subject { TestAbility.new(@user) }
+
     context "Given a policy grants read access to a group I belong to" do
       before do
         @policy = Hydra::AdminPolicy.new
-        @policy.default_permissions = [{:type=>"group", :access=>"read", :name=>"africana-faculty"}]
+        @policy.default_permissions.build({:type=>"group", :access=>"read", :name=>"africana-faculty"})
         @policy.save
       end
-      after { @policy.delete }
+
     	context "And a subscribing asset does not grant access" do
     	  before do
           @asset = ModsAsset.new()
           @asset.admin_policy = @policy
           @asset.save
         end
-        after { @asset.delete }
+
     		it "Then I should be able to view the asset" do
-    		  subject.can?(:read, @asset).should be true
+    		  expect(subject.can?(:read, @asset)).to be true
   		  end
+
         it "Then I should not be able to edit, update and destroy the asset" do
-          subject.can?(:edit, @asset).should be false
-          subject.can?(:update, @asset).should be false
-          subject.can?(:destroy, @asset).should be false
+          expect(subject.can?(:edit, @asset)).to be false
+          expect(subject.can?(:update, @asset)).to be false
+          expect(subject.can?(:destroy, @asset)).to be false
         end
       end
     end
+
     context "Given a policy grants edit access to a group I belong to" do
       before do
         @policy = Hydra::AdminPolicy.new
-        @policy.default_permissions = [{:type=>"group", :access=>"edit", :name=>"africana-faculty"}]
+        @policy.default_permissions.build({:type=>"group", :access=>"edit", :name=>"africana-faculty"})
         @policy.save
       end
-      after { @policy.delete }
+
     	context "And a subscribing asset does not grant access" do
     	  before do
           @asset = ModsAsset.new()
           @asset.admin_policy = @policy
           @asset.save
         end
-        after { @asset.delete }
+
     		it "Then I should be able to view the asset" do
-    		  subject.can?(:read, @asset).should be true
+    		  expect(subject.can?(:read, @asset)).to be true
   		  end
+
     		it "Then I should be able to edit/update/destroy the asset" do
-          subject.can?(:edit, @asset).should be true
-          subject.can?(:update, @asset).should be true
-          subject.can?(:destroy, @asset).should be true
+          expect(subject.can?(:edit, @asset)).to be true
+          expect(subject.can?(:update, @asset)).to be true
+          expect(subject.can?(:destroy, @asset)).to be true
         end
   		end
+
     	context "And a subscribing asset grants read access to me as an individual" do
     	  before do
           @asset = ModsAsset.new()
@@ -176,14 +180,15 @@ describe Hydra::AdminPolicy do
           @asset.admin_policy = @policy
           @asset.save
         end
-        after { @asset.delete }
+
     		it "Then I should be able to view the asset" do
-    		  subject.can?(:read, @asset).should be true
+    		  expect(subject.can?(:read, @asset)).to be true
   		  end
+
         it "Then I should be able to edit/update/destroy the asset" do
-          subject.can?(:edit, @asset).should be true
-          subject.can?(:update, @asset).should be true
-          subject.can?(:destroy, @asset).should be true
+          expect(subject.can?(:edit, @asset)).to be true
+          expect(subject.can?(:update, @asset)).to be true
+          expect(subject.can?(:destroy, @asset)).to be true
         end
       end
     end
@@ -193,23 +198,25 @@ describe Hydra::AdminPolicy do
         @policy = Hydra::AdminPolicy.new
         @policy.save
       end
-      after { @policy.delete }
+
       context "And a subscribing asset does not grant access" do
         before do
           @asset = ModsAsset.new()
           @asset.admin_policy = @policy
           @asset.save
         end
-        after { @asset.delete }
+
   		  it "Then I should not be able to view the asset" do
-    		  subject.can?(:read, @asset).should be false
+    		  expect(subject.can?(:read, @asset)).to be false
   		  end
+
         it "Then I should not be able to edit/update/destroy the asset" do
-          subject.can?(:edit, @asset).should be false
-          subject.can?(:update, @asset).should be false
-          subject.can?(:destroy, @asset).should be false
+          expect(subject.can?(:edit, @asset)).to be false
+          expect(subject.can?(:update, @asset)).to be false
+          expect(subject.can?(:destroy, @asset)).to be false
         end
       end
+
       context "And a subscribing asset grants read access to me as an individual" do
         before do
           @asset = ModsAsset.new()
@@ -217,17 +224,17 @@ describe Hydra::AdminPolicy do
           @asset.admin_policy = @policy
           @asset.save
         end
-        after { @asset.delete }
+
   		  it "Then I should be able to view the asset" do
-    		  subject.can?(:read, @asset).should be true
+    		  expect(subject.can?(:read, @asset)).to be true
   		  end
+
         it "Then I should not be able to edit/update/destroy the asset" do
-          subject.can?(:edit, @asset).should be false
-          subject.can?(:update, @asset).should be false
-          subject.can?(:destroy, @asset).should be false
+          expect(subject.can?(:edit, @asset)).to be false
+          expect(subject.can?(:update, @asset)).to be false
+          expect(subject.can?(:destroy, @asset)).to be false
         end
       end
     end
   end
-
 end

data/spec/unit/config_spec.rb

@@ -6,44 +6,43 @@ describe Hydra::Config do
       # You only need to change these values if you've indexed permissions by some means other than the Hydra's built-in tooling.
       # If you change these, you must also update the permissions request handler in your solrconfig.xml to return those values
       config[:permissions] = {
-        :discover => {:group =>ActiveFedora::SolrService.solr_name("discover_access_group", :symbol), :individual=>ActiveFedora::SolrService.solr_name("discover_access_person", :symbol)},
-        :read => {:group =>ActiveFedora::SolrService.solr_name("read_access_group", :symbol), :individual=>ActiveFedora::SolrService.solr_name("read_access_person", :symbol)},
-        :edit => {:group =>ActiveFedora::SolrService.solr_name("edit_access_group", :symbol), :individual=>ActiveFedora::SolrService.solr_name("edit_access_person", :symbol)},
-        :owner => ActiveFedora::SolrService.solr_name("depositor", :symbol),
-        :embargo_release_date => ActiveFedora::SolrService.solr_name("embargo_release_date", Solrizer::Descriptor.new(:date, :stored, :indexed))
+        :discover => {:group =>ActiveFedora::SolrQueryBuilder.solr_name("discover_access_group", :symbol), :individual=>ActiveFedora::SolrQueryBuilder.solr_name("discover_access_person", :symbol)},
+        :read => {:group =>ActiveFedora::SolrQueryBuilder.solr_name("read_access_group", :symbol), :individual=>ActiveFedora::SolrQueryBuilder.solr_name("read_access_person", :symbol)},
+        :edit => {:group =>ActiveFedora::SolrQueryBuilder.solr_name("edit_access_group", :symbol), :individual=>ActiveFedora::SolrQueryBuilder.solr_name("edit_access_person", :symbol)},
+        :owner => ActiveFedora::SolrQueryBuilder.solr_name("depositor", :symbol),
       }
+      config.permissions.embargo.release_date = ActiveFedora::SolrQueryBuilder.solr_name("embargo_release_date", Solrizer::Descriptor.new(:date, :stored, :indexed))
 
       # specify the user model
       config[:user_model] = 'User'
 
-      config[:permissions][:edit][:individual].should == 'edit_access_person_ssim'
+      expect(config[:permissions][:edit][:individual]).to eq 'edit_access_person_ssim'
   end
 
   it "should accept a struct based config" do
       # This specifies the solr field names of permissions-related fields.
       # You only need to change these values if you've indexed permissions by some means other than the Hydra's built-in tooling.
       # If you change these, you must also update the permissions request handler in your solrconfig.xml to return those values
-      config.permissions.discover.group = ActiveFedora::SolrService.solr_name("discover_access_group", :symbol)
+      config.permissions.discover.group = ActiveFedora::SolrQueryBuilder.solr_name("discover_access_group", :symbol)
 
       # specify the user model
       config.user_model = 'User'
 
-      config.permissions.discover.group.should == 'discover_access_group_ssim'
-      config.user_model.should == 'User'
+      expect(config.permissions.discover.group).to eq 'discover_access_group_ssim'
+      expect(config.user_model).to eq 'User'
   end
 
   it "should have inheritable attributes" do
-      config[:permissions][:inheritable][:edit][:individual].should == 'inheritable_edit_access_person_ssim'
+      expect(config[:permissions][:inheritable][:edit][:individual]).to eq 'inheritable_edit_access_person_ssim'
   end
   it "should have a nil policy_class" do
-      config[:permissions][:policy_class].should be_nil
+      expect(config[:permissions][:policy_class]).to be_nil
   end
 
   it "should have defaults" do
-    config.permissions.read.individual.should == 'read_access_person_ssim'
-    config.permissions.embargo_release_date.should == 'embargo_release_date_dtsi'
-    config.permissions.embargo.release_date.should == 'embargo_release_date_dtsi'
-    config.user_model.should == 'User'
+    expect(config.permissions.read.individual).to eq 'read_access_person_ssim'
+    expect(config.permissions.embargo.release_date).to eq 'embargo_release_date_dtsi'
+    expect(config.user_model).to eq 'User'
   end
 
 end

data/spec/unit/embargoable_spec.rb

@@ -2,23 +2,21 @@ require 'spec_helper'
 
 describe Hydra::AccessControls::Embargoable do
 
-  let(:model) {
-    Class.new(ActiveFedora::Base) {
+  before do
+    class TestModel < ActiveFedora::Base
       def save(returning_value = true)
         valid? && run_callbacks(:save) && !!returning_value
       end
 
       include Hydra::AccessControls::Embargoable
-    }
-  }
+    end
+  end
+
+  after { Object.send(:remove_const, :TestModel) }
 
   let(:future_date) { Date.today+2 }
   let(:past_date) { Date.today-2 }
-  let(:persistence) {
-    subject.rightsMetadata
-  }
-
-  subject { model.new }
+  subject { TestModel.new }
 
   context 'validations' do
     subject { ModsAsset.new(lease_expiration_date: past_date, embargo_release_date: past_date) }
@@ -53,14 +51,14 @@ describe Hydra::AccessControls::Embargoable do
       }.to change { subject.visibility_changed? }.from(false).to(true)
       expect(subject).to be_under_embargo
       expect(subject.visibility).to eq  Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
-      expect(subject.embargo_release_date).to eq future_date.to_time.utc
+      expect(subject.embargo_release_date).to eq future_date
       expect(subject.visibility_after_embargo).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
     end
     it "relies on default before/after visibility if none provided" do
       subject.apply_embargo(future_date.to_s)
       expect(subject).to be_under_embargo
       expect(subject.visibility).to eq  Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
-      expect(subject.embargo_release_date).to eq future_date.to_time.utc
+      expect(subject.embargo_release_date).to eq future_date
       expect(subject.visibility_after_embargo).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
     end
   end
@@ -118,13 +116,13 @@ describe Hydra::AccessControls::Embargoable do
         expect(subject).to be_active_lease
         expect(subject).to be_visibility_changed
         expect(subject.visibility).to eq  Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-        expect(subject.lease_expiration_date).to eq future_date.to_time.utc
+        expect(subject.lease_expiration_date).to eq future_date
         expect(subject.visibility_after_lease).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
       end
       it "relies on default before/after visibility if none provided" do
         subject.apply_lease(future_date.to_s)
         expect(subject.visibility_during_lease).to eq  Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
-        expect(subject.lease_expiration_date).to eq future_date.to_time.utc
+        expect(subject.lease_expiration_date).to eq future_date
         expect(subject.visibility_after_lease).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
       end
     end
@@ -142,7 +140,7 @@ describe Hydra::AccessControls::Embargoable do
         }.to change { subject.visibility_changed? }.from(false).to(true)
         expect(subject).to be_active_lease
         expect(subject.visibility).to eq  Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
-        expect(subject.lease_expiration_date).to eq future_date.to_time.utc
+        expect(subject.lease_expiration_date).to eq future_date
         expect(subject.visibility_after_lease).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
       end
     end
@@ -210,7 +208,7 @@ describe Hydra::AccessControls::Embargoable do
     end
   end
 
-  context 'validate_embargo' do
+  context 'validate_visibility_complies_with_embargo' do
     before do
       subject.visibility_during_embargo = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
       subject.visibility_after_embargo = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
@@ -219,12 +217,12 @@ describe Hydra::AccessControls::Embargoable do
       it 'returns true if current visibility matches visibility_during_embargo' do
         subject.visibility = subject.visibility_during_embargo
         subject.embargo_release_date = future_date.to_s
-        expect(subject.validate_embargo).to be true
+        expect(subject.validate_visibility_complies_with_embargo).to be true
       end
       it 'records a failures in record.errors[:embargo]' do
         subject.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
         subject.embargo_release_date = future_date.to_s
-        expect(subject.validate_embargo).to be false
+        expect(subject.validate_visibility_complies_with_embargo).to be false
         expect(subject.errors[:embargo].first).to eq "An embargo is in effect for this object until #{subject.embargo_release_date}.  Until that time the visibility should be #{Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE} but it is currently #{Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED}.  Call embargo_visibility! on this object to repair."
       end
     end
@@ -232,12 +230,12 @@ describe Hydra::AccessControls::Embargoable do
       it 'returns true if current visibility matches visibility_after_embargo' do
         subject.visibility = subject.visibility_after_embargo
         subject.embargo_release_date = past_date.to_s
-        expect(subject.validate_embargo).to be true
+        expect(subject.validate_visibility_complies_with_embargo).to be true
       end
       it '(embargo expired) records a failures in record.errors[:embargo]' do
         subject.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
         subject.embargo_release_date = past_date.to_s
-        expect(subject.validate_embargo).to be false
+        expect(subject.validate_visibility_complies_with_embargo).to be false
         expect(subject.errors[:embargo].first).to eq "The embargo expired on #{subject.embargo_release_date}.  The visibility should be #{Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC} but it is currently #{Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE}.  Call embargo_visibility! on this object to repair."
       end
     end
@@ -286,7 +284,7 @@ describe Hydra::AccessControls::Embargoable do
     end
   end
 
-  context 'validate_lease' do
+  context 'validate_visibility_complies_with_lease' do
     let(:future_date) { 2.days.from_now }
     let(:past_date) { 2.days.ago }
     before do
@@ -297,12 +295,12 @@ describe Hydra::AccessControls::Embargoable do
       it 'returns true if current visibility matches visibility_after_lease' do
         subject.visibility = subject.visibility_after_lease
         subject.lease_expiration_date = past_date.to_s
-        expect(subject.validate_lease).to be true
+        expect(subject.validate_visibility_complies_with_lease).to be true
       end
       it 'records a failures in record.errors[:lease]' do
         subject.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
         subject.lease_expiration_date = past_date.to_s
-        expect(subject.validate_lease).to be false
+        expect(subject.validate_visibility_complies_with_lease).to be false
         expect(subject.errors[:lease].first).to eq "The lease expired on #{subject.lease_expiration_date}.  The visibility should be #{Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE} but it is currently #{Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC}.  Call lease_visibility! on this object to repair."
       end
     end
@@ -310,12 +308,12 @@ describe Hydra::AccessControls::Embargoable do
       it 'returns true if current visibility matches visibility_during_embargo' do
         subject.visibility = subject.visibility_during_lease
         subject.lease_expiration_date = future_date.to_s
-        expect(subject.validate_lease).to be true
+        expect(subject.validate_visibility_complies_with_lease).to be true
       end
       it 'records a failures in record.errors[:lease]' do
         subject.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
         subject.lease_expiration_date = future_date.to_s
-        expect(subject.validate_lease).to be false
+        expect(subject.validate_visibility_complies_with_lease).to be false
         expect(subject.errors[:lease].first).to eq "A lease is in effect for this object until #{subject.lease_expiration_date}.  Until that time the visibility should be #{Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC} but it is currently #{Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED}.  Call lease_visibility! on this object to repair."
       end
     end
@@ -368,24 +366,24 @@ describe Hydra::AccessControls::Embargoable do
 
     it 'persists a date object' do
       subject.embargo_release_date = the_date
-      expect(persistence.embargo_release_date.first).to be_kind_of DateTime
+      expect(subject.embargo_release_date).to be_kind_of DateTime
     end
 
     it 'persists a valid string' do
       subject.embargo_release_date = the_date.to_s
-      expect(persistence.embargo_release_date.first).to be_kind_of DateTime
+      expect(subject.embargo_release_date).to be_kind_of DateTime
     end
 
     it 'raises an error on an empty string' do
       expect {
         subject.embargo_release_date = ''
-      }.to raise_error OM::TypeMismatch
+      }.to raise_error(ArgumentError, "invalid date")
     end
 
     it 'does not persist an invalid string' do
       expect {
         subject.embargo_release_date = "Tim"
-      }.to raise_error OM::TypeMismatch
+      }.to raise_error(ArgumentError, "invalid date")
     end
   end
 

data/spec/unit/permission_spec.rb

@@ -1,28 +1,48 @@
 require 'spec_helper'
 
 describe Hydra::AccessControls::Permission do
-  describe "hash-like key access" do
-    let(:perm) { described_class.new(type: 'user', name: 'bob', access: 'read') }
-    it "should return values" do
-      perm[:type].should == 'user'
-      perm[:name].should == 'bob'
-      perm[:access].should == 'read'
+
+  describe "an initialized instance" do
+    let(:permission) { described_class.new(type: 'person', name: 'bob', access: 'read') }
+
+    it "should set predicates" do
+      expect(permission.agent.first.rdf_subject).to eq ::RDF::URI.new('http://projecthydra.org/ns/auth/person#bob')
+      expect(permission.mode.first.rdf_subject).to eq ACL.Read
+    end
+
+    describe "#to_hash" do
+      subject { permission.to_hash }
+      it { should eq(type: 'person', name: 'bob', access: 'read') }
+    end
+
+    describe "#agent_name" do
+      subject { permission.agent_name }
+      it { should eq 'bob' }
+    end
+
+    describe "#access" do
+      subject { permission.access }
+      it { should eq 'read' }
+    end
+
+    describe "#type" do
+      subject { permission.type }
+      it { should eq 'person' }
     end
   end
-  describe "#to_hash" do
-    subject { described_class.new(type: 'user', name: 'bob', access: 'read') }
-    its(:to_hash) { should == {type: 'user', name: 'bob', access: 'read'} }
-  end
+
   describe "equality comparison" do
-    let(:perm1) { described_class.new(type: 'user', name: 'bob', access: 'read') }
-    let(:perm2) { described_class.new(type: 'user', name: 'bob', access: 'read') }
-    let(:perm3) { described_class.new(type: 'user', name: 'jane', access: 'read') }
+    let(:perm1) { described_class.new(type: 'person', name: 'bob', access: 'read') }
+    let(:perm2) { described_class.new(type: 'person', name: 'bob', access: 'read') }
+    let(:perm3) { described_class.new(type: 'person', name: 'jane', access: 'read') }
+
     it "should be equal if all values are equal" do
-      perm1.should == perm2
+      expect(perm1).to eq perm2
     end
+
     it "should be unequal if some values are unequal" do
-      perm1.should_not == perm3
-      perm2.should_not == perm3
+      expect(perm1).to_not eq perm3
+      expect(perm2).to_not eq perm3
     end
   end
 end