cbac 0.6.10 → 0.7.0

data/spec/cbac_pristine_file_spec.rb

@@ -8,272 +8,274 @@ describe "CbacPristineFile" do
   end
 
   describe "indicate if a line looks like a pristine line" do
-    it "should indicate that a ruby style comment line is not a pristine line" do
+    it "indicates that a ruby style comment line is not a pristine line" do
       comment_line = "#this is a comment line in Ruby"
 
-      @pristine_file.is_pristine_permission_line?(comment_line, 1).should be_false
+      expect(@pristine_file.is_pristine_permission_line?(comment_line, 1)).to be_falsy
     end
 
-    it "should raise an error if the line does not look like a pristine line" do
+    it "raises an error if the line does not look like a pristine line" do
       line = "this is not pristine line. And it isn't a comment. 1"
 
-      proc{
+      expect(proc{
         @pristine_file.is_pristine_permission_line?(line, 0)
-      }.should raise_error(SyntaxError)
+      }).to raise_error(SyntaxError)
     end
 
-    it "should return true in case of a valid pristine line" do
+    it "returns true in case of a valid pristine line" do
       line = "0:+:PrivilegeSet(login)ContextRole(everybody)"
 
-      @pristine_file.is_pristine_permission_line?(line, 0).should be_true
+      expect(@pristine_file.is_pristine_permission_line?(line, 0)).to be_truthy
     end
 
-    it "should fail if the id of the pristine line contains a character" do
+    it "fails if the id of the pristine line contains a character" do
       line = "0b:+:PrivilegeSet(login)ContextRole(everybody)"
 
-      proc{
+      expect(proc{
         @pristine_file.is_pristine_permission_line?(line, 0)
-      }.should raise_error(SyntaxError)
+      }).to raise_error(SyntaxError)
       end
 
-    it "should succeed if the privilege set name is not provided" do
+    it "succeeds if the privilege set name is not provided" do
       line = "0:+:PrivilegeSet()Admin()"
 
-      @pristine_file.is_pristine_permission_line?(line, 0).should be_true
+      expect(@pristine_file.is_pristine_permission_line?(line, 0)).to be_truthy
     end
 
-    it "should succeed if the context role name is not provided" do
+    it "succeeds if the context role name is not provided" do
       line = "0:+:PrivilegeSet(login)ContextRole()"
 
-      @pristine_file.is_pristine_permission_line?(line, 0).should be_true
+      expect(@pristine_file.is_pristine_permission_line?(line, 0)).to be_truthy
     end
 
   end
 
   describe "parse the privilege set name from a pristine line" do
-    it "should fail if the privilege set name is not provided" do
+    it "fails if the privilege set name is not provided" do
       line = "0:+:PrivilegeSet()Admin()"
 
-      proc{
+      expect(proc{
         @pristine_file.parse_privilege_set_name(line, 0)
-      }.should raise_error(SyntaxError)
+      }).to raise_error(SyntaxError)
     end
 
-    it "should return the name of the privilege set provided in the line" do
+    it "returns the name of the privilege set provided in the line" do
       privilege_set_name = "chat"
       line = "0:+:PrivilegeSet(#{privilege_set_name})Admin()"
 
-      @pristine_file.parse_privilege_set_name(line, 0).should == privilege_set_name
+      expect(@pristine_file.parse_privilege_set_name(line, 0)).to eq(privilege_set_name)
     end
 
-    it "should fail if an invalid line is provided" do
+    it "fails if an invalid line is provided" do
       line = "0:+:ContextRole(toeteraars)"
 
-      proc{
+      expect(proc{
           @pristine_file.parse_privilege_set_name(line, 0)
-      }.should raise_error(SyntaxError)
+      }).to raise_error(SyntaxError)
     end
   end
 
   describe "parse the role from a pristine line" do
-    it "should return the admin role if the role is Admin()" do
+    it "returns the admin role if the role is Admin()" do
       admin_role = PristineRole.new(:role_id => 0, :role_type => PristineRole.ROLE_TYPES[:admin], :name => 'administrator')
-      PristineRole.stub!(:admin_role).and_return(admin_role)
+      allow(PristineRole).to receive(:admin_role).and_return(admin_role)
       line = "0:+:PrivilegeSet(chat)Admin()"
 
-      @pristine_file.parse_role(line, 0).should == admin_role
+      expect(@pristine_file.parse_role(line, 0)).to eq(admin_role)
     end
 
-    it "should return a context role if the role specified as ContextRole" do
+    it "returns a context role if the role specified as ContextRole" do
       line = "0:+:PrivilegeSet(chat)ContextRole(logged_in_user)"
 
-      @pristine_file.parse_role(line, 0).role_type.should == PristineRole.ROLE_TYPES[:context]
+      expect(@pristine_file.parse_role(line, 0).role_type).to eq(PristineRole.ROLE_TYPES[:context])
     end
 
-    it "should return a context role with specified name if the role specified as ContextRole" do
+    it "returns a context role with specified name if the role specified as ContextRole" do
       context_role_name = "logged_in_user"
       line = "0:+:PrivilegeSet(chat)ContextRole(#{context_role_name})"
 
-      @pristine_file.parse_role(line, 0).name.should == context_role_name
+      expect(@pristine_file.parse_role(line, 0).name).to eq(context_role_name)
     end
 
-    it "should return an existing context role with specified name if possible" do
+    it "returns an existing context role with specified name if possible" do
       context_role_name = "logged_in_user"
       line = "0:+:PrivilegeSet(chat)ContextRole(#{context_role_name})"
       existing_context_role = PristineRole.create(:name => context_role_name, :role_id => 0, :role_type => PristineRole.ROLE_TYPES[:context])
 
-      @pristine_file.parse_role(line, 0).should == existing_context_role
+      expect(@pristine_file.parse_role(line, 0)).to eq(existing_context_role)
     end
 
-    it "should not return an existing context role with specified name if db should not be used" do
+    it "does not return an existing context role with specified name if db should not be used" do
       context_role_name = "logged_in_user"
       line = "0:+:PrivilegeSet(chat)ContextRole(#{context_role_name})"
       existing_context_role = PristineRole.create(:name => context_role_name, :role_id => 0, :role_type => PristineRole.ROLE_TYPES[:context])
 
-      @pristine_file.parse_role(line, 0, false).should_not == existing_context_role
+      expect(@pristine_file.parse_role(line, 0, false)).not_to eq(existing_context_role)
     end
 
-    it "should return a context role with id of 0 if the role specified as ContextRole" do
+    it "returns a context role with id of 0 if the role specified as ContextRole" do
       line = "0:+:PrivilegeSet(chat)ContextRole(logged_in_user)"
 
-      @pristine_file.parse_role(line, 0).role_id.should == 0
+      expect(@pristine_file.parse_role(line, 0).role_id).to eq(0)
     end
 
-    it "should fail if an invalid line is provided" do
+    it "fails if an invalid line is provided" do
       line = "0:+:PrivilegeSet(toeteraars)"
 
-      proc{
+      expect(proc{
            @pristine_file.parse_role(line, 0)
-      }.should raise_error(SyntaxError)
+      }).to raise_error(SyntaxError)
     end
 
-    it "should fail if a generic role is provided for the normal (non-generic) pristine file" do
+    it "fails if a generic role is provided for the normal (non-generic) pristine file" do
       line = "0:+:PrivilegeSet(chat)GenericRole(group_admins)"
 
-      proc{
+      expect(proc{
            @pristine_file.parse_role(line, 0)
-      }.should raise_error(SyntaxError)
+      }).to raise_error(SyntaxError)
     end
 
-
-    it "should return a generic role if a generic pristine file is used" do
+    it "returns a generic role if a generic pristine file is used" do
       @pristine_file = GenericPristineFile.new(:file_name =>"cbac.pristine")
       line = "0:+:PrivilegeSet(chat)GenericRole(group_admins)"
 
-      @pristine_file.parse_role(line, 0).role_type.should == PristineRole.ROLE_TYPES[:generic]
+      expect(@pristine_file.parse_role(line, 0).role_type).to eq(PristineRole.ROLE_TYPES[:generic])
     end
 
-    it "should return an existing generic role if use_db is not specified" do
+    it "returns an existing generic role if use_db is not specified" do
       generic_role_name = 'group_admins'
       @pristine_file = GenericPristineFile.new(:file_name =>"cbac.pristine")
       line = "0:+:PrivilegeSet(chat)GenericRole(#{generic_role_name})"
       existing_role = PristineRole.create(:role_id => 1, :role_type => PristineRole.ROLE_TYPES[:generic], :name => generic_role_name)
 
-      @pristine_file.parse_role(line, 0).should == existing_role
+      expect(@pristine_file.parse_role(line, 0)).to eq(existing_role)
     end
 
-    it "should not use an existing role if use_db is set to false" do
+    it "does not use an existing role if use_db is set to false" do
       generic_role_name = 'group_admins'
       @pristine_file = GenericPristineFile.new(:file_name =>"cbac.pristine")
       line = "0:+:PrivilegeSet(chat)GenericRole(#{generic_role_name})"
       existing_role = PristineRole.create(:role_id => 1, :role_type => PristineRole.ROLE_TYPES[:generic], :name => generic_role_name)
 
-      @pristine_file.parse_role(line, 0, false).should_not == existing_role
+      expect(@pristine_file.parse_role(line, 0, false)).not_to eq(existing_role)
     end
 
-    it "should fail if an Admin role is used in a generic pristine file" do
+    it "fails if an Admin role is used in a generic pristine file" do
       @pristine_file = GenericPristineFile.new(:file_name =>"cbac.pristine")
       line = "0:+:PrivilegeSet(chat)Admin()"
 
-      proc{
+      expect(proc{
            @pristine_file.parse_role(line, 0)
-      }.should raise_error(SyntaxError)
+      }).to raise_error(SyntaxError)
     end
 
-    it "should fail if an context role is used in a generic pristine file" do
+    it "fails if an context role is used in a generic pristine file" do
       @pristine_file = GenericPristineFile.new(:file_name =>"cbac.pristine")
       line = "0:+:PrivilegeSet(chat)ContextRole(logged_in_user)"
 
-      proc{
+      expect(proc{
            @pristine_file.parse_role(line, 0)
-      }.should raise_error(SyntaxError)
+      }).to raise_error(SyntaxError)
     end
 
-    it "should fail if an invalid line is provided in a generic pristine file" do
+    it "fails if an invalid line is provided in a generic pristine file" do
       @pristine_file = GenericPristineFile.new(:file_name =>"cbac.pristine")
       line = "0:+:PrivilegeSet(toeteraars)"
 
-      proc{
+      expect(proc{
            @pristine_file.parse_role(line, 0)
-      }.should raise_error(SyntaxError)
+      }).to raise_error(SyntaxError)
     end
   end
 
   describe "parsing a cbac_pristine file" do
-    it "should fail if a row number is used twice" do
+    it "fails if a row number is used twice" do
       pristine_file_lines = ["0:+:PrivilegeSet(chat)ContextRole(logged_in_user)"]
       pristine_file_lines.push("0:+:PrivilegeSet(log_in)ContextRole(everybody)")
 
-      File.stub!(:open).and_return(pristine_file_lines)
+      allow(File).to receive(:open).and_return(pristine_file_lines)
 
       pristine_file = PristineFile.new(:file_name =>"cbac.pristine")
 
-      proc{
+      expect(proc{
         pristine_file.parse
-      }.should raise_error(SyntaxError)
+      }).to raise_error(SyntaxError)
     end
 
-    it "should fill the lines array with an object for each file line" do
+    it "fills the lines array with an object for each file line" do
       pristine_file_lines = ["0:+:PrivilegeSet(chat)ContextRole(logged_in_user)"]
       pristine_file_lines.push("1:+:PrivilegeSet(log_in)ContextRole(everybody)")
       pristine_file_lines.push("2:+:PrivilegeSet(log_out)ContextRole(logged_in_user)")
 
-      File.stub!(:open).and_return(pristine_file_lines)
+      allow(File).to receive(:open).and_return(pristine_file_lines)
 
       pristine_file = PristineFile.new(:file_name =>"cbac.pristine")
       pristine_file.parse
 
-      pristine_file.permissions.length.should == pristine_file_lines.length
+      expect(pristine_file.permissions.length).to eq(pristine_file_lines.length)
     end
 
-    it "should not create an object for a comment line" do
+    it "does not create an object for a comment line" do
       pristine_file_lines = ["0:+:PrivilegeSet(chat)ContextRole(logged_in_user)"]
       pristine_file_lines.push("1:+:PrivilegeSet(log_in)ContextRole(everybody)")
       pristine_file_lines.push("#this is a Ruby comment line")
 
-      File.stub!(:open).and_return(pristine_file_lines)
+      allow(File).to receive(:open).and_return(pristine_file_lines)
 
       pristine_file = PristineFile.new(:file_name =>"cbac.pristine")
       pristine_file.parse
 
-      pristine_file.permissions.length.should == 2
+      expect(pristine_file.permissions.length).to eq(2)
     end
 
-    it "should also add a permission object if permission is revoked (operand - is used)" do
+    it "also adds a permission object if permission is revoked (operand - is used)" do
       pristine_file_lines = ["0:+:PrivilegeSet(chat)ContextRole(logged_in_user)"]
       pristine_file_lines.push("1:+:PrivilegeSet(log_in)ContextRole(everybody)")
       pristine_file_lines.push("2:-:PrivilegeSet(chat)ContextRole(logged_in_user)")
 
-      File.stub!(:open).and_return(pristine_file_lines)
+      allow(File).to receive(:open).and_return(pristine_file_lines)
 
       pristine_file = PristineFile.new(:file_name =>"cbac.pristine")
       pristine_file.parse
 
-      pristine_file.permissions.length.should == 3
-      pristine_file.permissions[2].operation.should == '-'
+      expect(pristine_file.permissions.length).to eq(3)
+      expect(pristine_file.permissions[2].operation).to eq('-')
     end
 
-    it "should fail if a permission is revoked which wasn't added before" do
+    it "fails if a permission is revoked which wasn't added before" do
       pristine_file_lines = ["0:+:PrivilegeSet(chat)ContextRole(logged_in_user)"]
       pristine_file_lines.push("1:+:PrivilegeSet(log_in)ContextRole(everybody)")
       pristine_file_lines.push("2:-:PrivilegeSet(chat)ContextRole(everybody)")
 
-      File.stub!(:open).and_return(pristine_file_lines)
+      allow(File).to receive(:open).and_return(pristine_file_lines)
 
       pristine_file = PristineFile.new(:file_name =>"cbac.pristine")
-      proc{
+
+      expect(proc{
         pristine_file.parse
-      }.should raise_error(SyntaxError)
+      }).to raise_error(SyntaxError)
     end
 
-    it "should fail if an x is used as an operand" do
+    it "fails if an x is used as an operand" do
       pristine_file_lines = ["0:x:PrivilegeSet(chat)ContextRole(logged_in_user)"]
-      File.stub!(:open).and_return(pristine_file_lines)
+      allow(File).to receive(:open).and_return(pristine_file_lines)
 
       pristine_file = PristineFile.new(:file_name =>"cbac.pristine")
-      proc{
+
+      expect(proc{
         pristine_file.parse
-      }.should raise_error(NotImplementedError)
+      }).to raise_error(NotImplementedError)
     end
 
-    it "should fail if an => is used as an operand" do
+    it "fails if an => is used as an operand" do
       pristine_file_lines = ["0:=>:PrivilegeSet(chat)ContextRole(logged_in_user)"]
-      File.stub!(:open).and_return(pristine_file_lines)
+      allow(File).to receive(:open).and_return(pristine_file_lines)
 
       pristine_file = PristineFile.new(:file_name =>"cbac.pristine")
-      proc{
+
+      expect(proc{
         pristine_file.parse
-      }.should raise_error(NotImplementedError)
+      }).to raise_error(NotImplementedError)
     end
   end
 
@@ -284,40 +286,40 @@ describe "CbacPristineFile" do
       @pristine_file = PristineFile.new(:file_name =>"cbac.pristine")
     end
 
-    it "should filter out the permissions which were revoked" do
+    it "filters out the permissions which were revoked" do
       permission_to_revoke = PristinePermission.new(:privilege_set_name => "chat", :pristine_role => @context_role, :operation => '+')
       @pristine_file.permissions.push(permission_to_revoke)
       @pristine_file.permissions.push(PristinePermission.new(:privilege_set_name => permission_to_revoke.privilege_set_name, :pristine_role => permission_to_revoke.pristine_role, :operation => '-'))
 
-      @pristine_file.permission_set.should_not include(permission_to_revoke)
+      expect(@pristine_file.permission_set).not_to include(permission_to_revoke)
     end
 
-     it "should not include the revoke permission itself" do
+     it "does not include the revoke permission itself" do
       revoke_permission = PristinePermission.new(:privilege_set_name => "chat", :pristine_role => @context_role, :operation => '-')
       @pristine_file.permissions.push(PristinePermission.new(:privilege_set_name => revoke_permission.privilege_set_name, :pristine_role => revoke_permission.pristine_role, :operation => '+'))
       @pristine_file.permissions.push(revoke_permission)
 
-      @pristine_file.permission_set.should_not include(revoke_permission)
+      expect(@pristine_file.permission_set).not_to include(revoke_permission)
     end
 
-    it "should contain the permission if it is re-applied" do
+    it "contains the permission if it is re-applied" do
       re_applied_permission = PristinePermission.new(:privilege_set_name => "chat", :pristine_role => @context_role, :operation => '+')
       @pristine_file.permissions.push(PristinePermission.new(:privilege_set_name => re_applied_permission.privilege_set_name, :pristine_role => re_applied_permission.pristine_role, :operation => '+'))
       @pristine_file.permissions.push(PristinePermission.new(:privilege_set_name =>  re_applied_permission.privilege_set_name, :pristine_role => re_applied_permission.pristine_role, :operation => '-'))
       @pristine_file.permissions.push(re_applied_permission)
 
-      @pristine_file.permission_set.should include(re_applied_permission)
+      expect(@pristine_file.permission_set).to include(re_applied_permission)
     end
 
-    it "should raise an error if a permission is revoked which wasn't created before" do
+    it "raises an error if a permission is revoked which wasn't created before" do
       @pristine_file.permissions.push(PristinePermission.new(:privilege_set_name =>  "chat", :pristine_role => @context_role, :operation => '+'))
       @pristine_file.permissions.push(PristinePermission.new(:privilege_set_name =>  "login", :pristine_role => @context_role, :operation =>  '+'))
       @pristine_file.permissions.push(PristinePermission.new(:privilege_set_name =>  "blog_read", :pristine_role => @context_role, :operation =>  '-'))
       @pristine_file.permissions.push(PristinePermission.new(:privilege_set_name =>  "update_blog", :pristine_role => @context_role, :operation => '+'))
 
-      proc {
+      expect(proc {
         @pristine_file.permission_set
-      }.should raise_error(ArgumentError)
+      }).to raise_error(ArgumentError)
     end
   end
 end

data/spec/cbac_pristine_permission_spec.rb

@@ -9,60 +9,62 @@ describe "CbacPristinePermission" do
       @context_role = PristineRole.new(:role_id => 0, :role_type => PristineRole.ROLE_TYPES[:context], :name => "chat_starter")
     end
 
-    it "should raise an error if the pristine line has no role" do
+    it "raises an error if the pristine line has no role" do
       pristine_permission = PristinePermission.new(:line_number => 1, :privilege_set_name => 'log_in', :pristine_role =>  nil)
-      lambda {
+
+      expect(lambda {
         pristine_permission.to_yml_fixture
-      }.should raise_error(ArgumentError)
+      }).to raise_error(ArgumentError)
     end
 
-    it "should raise an error if the pristine line has no privilege_set_name" do
+    it "raises an error if the pristine line has no privilege_set_name" do
       pristine_permission = PristinePermission.new(:line_number => 1, :privilege_set_name => "", :pristine_role => @context_role)
-      lambda {
+
+      expect(lambda {
         pristine_permission.to_yml_fixture
-      }.should raise_error(ArgumentError)
+      }).to raise_error(ArgumentError)
     end
 
-    it "should return a yml string starting with cbac_permission_ " do
+    it "returns a yml string starting with cbac_permission_ " do
       pristine_permission = PristinePermission.new(:line_number => 1, :privilege_set_name => "chat", :pristine_role => @context_role)
 
-      pristine_permission.to_yml_fixture.should match(/\Acbac_permission_/)
+      expect(pristine_permission.to_yml_fixture).to match(/\Acbac_permission_/)
     end
 
-    it "should return a yml string containing the line number of the pristine line" do
+    it "returns a yml string containing the line number of the pristine line" do
       line_number= 100
       pristine_permission = PristinePermission.new(:line_number => line_number, :privilege_set_name => "chat", :pristine_role => @context_role)
 
-      pristine_permission.to_yml_fixture.should match(/id: #{line_number}/)
+      expect(pristine_permission.to_yml_fixture).to match(/id: #{line_number}/)
     end
 
-    it "should return a yml string containing a generic role id of 0 if a context_role is used" do
+    it "returns a yml string containing a generic role id of 0 if a context_role is used" do
       pristine_permission = PristinePermission.new(:line_number => 150, :privilege_set_name => "chat", :pristine_role => @context_role)
 
-      pristine_permission.to_yml_fixture.should match(/generic_role_id: 0/)
+      expect(pristine_permission.to_yml_fixture).to match(/generic_role_id: 0/)
     end
 
-    it "should return a yml string containing the name of the context role if a context_role is used" do
+    it "returns a yml string containing the name of the context role if a context_role is used" do
       pristine_permission = PristinePermission.new(:line_number => 150, :privilege_set_name => "chat", :pristine_role => @context_role)
 
-      pristine_permission.to_yml_fixture.should match(/context_role: #{@context_role.name}/)
+      expect(pristine_permission.to_yml_fixture).to match(/context_role: #{@context_role.name}/)
     end
 
-    it "should return a yml string containing the id of the generic role if a generic role is used" do
+    it "returns a yml string containing the id of the generic role if a generic role is used" do
       pristine_permission = PristinePermission.new(:line_number => 150, :privilege_set_name => "chat", :pristine_role => @admin_role)
 
-      pristine_permission.to_yml_fixture.should match(/generic_role_id: #{@admin_role.id.to_s}/)
+      expect(pristine_permission.to_yml_fixture).to match(/generic_role_id: #{@admin_role.id.to_s}/)
     end
 
-    it "should return a yml string containing ruby code to find the privilege set by name" do
+    it "returns a yml string containing ruby code to find the privilege set by name" do
       pristine_permission = PristinePermission.new(:line_number => 150, :privilege_set_name => "chat", :pristine_role => @context_role)
 
-      pristine_permission.to_yml_fixture.should match(/privilege_set_id: \<%= Cbac::PrivilegeSetRecord.find\(:first, :conditions => \{:name => '#{pristine_permission.privilege_set_name}'\}\)\.id %>/)
+      expect(pristine_permission.to_yml_fixture).to match(/privilege_set_id: \<%= Cbac::PrivilegeSetRecord.where\(name: '#{pristine_permission.privilege_set_name}'\)\.first\.id %>/)
     end
 
-    it "should return a yml string containing created_at and updated_at" do
+    it "returns a yml string containing created_at and updated_at" do
       pristine_permission = PristinePermission.new(:line_number => 1, :privilege_set_name => "chat", :pristine_role => @context_role)
-      pristine_permission.to_yml_fixture.should match(/created_at:.+updated_at:/m)
+      expect(pristine_permission.to_yml_fixture).to match(/created_at:.+updated_at:/m)
     end
   end
 
@@ -75,49 +77,49 @@ describe "CbacPristinePermission" do
       @pristine_admin_role = PristineRole.new(:role_id => 1, :role_type => PristineRole.ROLE_TYPES[:admin],  :name => @admin_role.name)
     end
 
-    it "should return true if the pristine permission exists as generic cbac permission in the database" do
+    it "returns true if the pristine permission exists as generic cbac permission in the database" do
       Cbac::Permission.create(:privilege_set_id => @privilege_set.id, :generic_role_id => @admin_role.id)
 
       pristine_permission = PristinePermission.new(:privilege_set_name => @privilege_set.name, :pristine_role => @pristine_admin_role)
 
-      pristine_permission.cbac_permission_exists?.should be_true
+      expect(pristine_permission.cbac_permission_exists?).to be_truthy
     end
 
-    it "should return true if the pristine permission exists as context cbac permission in the database" do
+    it "returns true if the pristine permission exists as context cbac permission in the database" do
       Cbac::Permission.create(:privilege_set_id => @privilege_set.id, :generic_role_id => 0, :context_role => @pristine_context_role.name)
 
       pristine_permission = PristinePermission.new(:privilege_set_name => @privilege_set.name, :pristine_role => @pristine_context_role)
 
-      pristine_permission.cbac_permission_exists?.should be_true
+      expect(pristine_permission.cbac_permission_exists?).to be_truthy
     end
 
-    it "should return false if the pristine permission does not exist as context cbac permission in the database" do
+    it "returns false if the pristine permission does not exist as context cbac permission in the database" do
       pristine_permission = PristinePermission.new(:privilege_set_name => @privilege_set.name, :pristine_role => @pristine_context_role)
 
-      pristine_permission.cbac_permission_exists?.should be_false
+      expect(pristine_permission.cbac_permission_exists?).to be_falsey
     end
 
-    it "should return false if the pristine permission does not exist as a generic cbac permission in the database" do
+    it "returns false if the pristine permission does not exist as a generic cbac permission in the database" do
       pristine_permission = PristinePermission.new(:privilege_set_name => @privilege_set.name, :pristine_role => @pristine_admin_role)
 
-      pristine_permission.cbac_permission_exists?.should be_false
+      expect(pristine_permission.cbac_permission_exists?).to be_falsey
     end
 
-    it "should return false if a similar pristine permission exist as a generic cbac permission in the database, but for another generic role" do
+    it "returns false if a similar pristine permission exist as a generic cbac permission in the database, but for another generic role" do
       group_admin = Cbac::GenericRole.create(:name => "group_administrator")
       Cbac::Permission.create(:privilege_set_id => @privilege_set.id, :generic_role_id => group_admin.id)
 
       pristine_permission = PristinePermission.new(:privilege_set_name => @privilege_set.name, :pristine_role => @pristine_admin_role)
 
-      pristine_permission.cbac_permission_exists?.should be_false
+      expect(pristine_permission.cbac_permission_exists?).to be_falsey
     end
 
-    it "should return false if a similar pristine permission exist as a context cbac permission in the database, but for another context role" do
+    it "returns false if a similar pristine permission exist as a context cbac permission in the database, but for another context role" do
       Cbac::Permission.create(:privilege_set_id => @privilege_set.id, :generic_role_id => 0, :context_role => "group_owner")
 
       pristine_permission = PristinePermission.new(:privilege_set_name => @privilege_set.name, :pristine_role => @pristine_context_role)
 
-      pristine_permission.cbac_permission_exists?.should be_false
+      expect(pristine_permission.cbac_permission_exists?).to be_falsey
     end
   end
 
@@ -127,12 +129,12 @@ describe "CbacPristinePermission" do
       @pristine_admin_role = PristineRole.new(:role_id => 1, :role_type => PristineRole.ROLE_TYPES[:admin],  :name => "administrator")
     end
 
-    it "should return true if the pristine permission exists as a known permission in the database" do
+    it "returns true if the pristine permission exists as a known permission in the database" do
       pristine_permission = PristinePermission.new(:pristine_role => @pristine_admin_role, :line_number => 4, :privilege_set_name => "not relevant")
 
       Cbac::KnownPermission.create(:permission_number => pristine_permission.line_number, :permission_type => Cbac::KnownPermission.PERMISSION_TYPES[:context])
 
-      pristine_permission.known_permission_exists?.should be_true
+      expect(pristine_permission.known_permission_exists?).to be_truthy
     end
   end
 
@@ -147,30 +149,30 @@ describe "CbacPristinePermission" do
       @pristine_permission.operation = '+'
       @pristine_permission.line_number = rand
 
-      @pristine_file = mock('pristine_file', :permissions => [ @pristine_permission ])
-      @pristine_permission.stub(:pristine_file).and_return @pristine_file
+      @pristine_file = double('pristine_file', :permissions => [ @pristine_permission ])
+      allow(@pristine_permission).to receive(:pristine_file).and_return @pristine_file
     end
 
-    it "should create a known permission to record a change" do
-      proc {
+    it "creates a known permission to record a change" do
+      expect(proc {
         @pristine_permission.accept
-      }.should change(Cbac::KnownPermission, :count).by(1)
+      }).to change(Cbac::KnownPermission, :count).by(1)
     end
 
-    it "should create a known permission with specified permission identifier" do
+    it "creates a known permission with specified permission identifier" do
       @pristine_permission.accept
 
       known_permission = Cbac::KnownPermission.last
 
-      known_permission.permission_number.should == @pristine_permission.line_number
+      expect(known_permission.permission_number).to eq(@pristine_permission.line_number)
     end
 
-    it "should create a known permission with specified role type" do
+    it "creates a known permission with specified role type" do
       @pristine_permission.accept
 
       known_permission = Cbac::KnownPermission.last
 
-      known_permission.permission_type.should == Cbac::KnownPermission.PERMISSION_TYPES[:context]
+      expect(known_permission.permission_type).to eq(Cbac::KnownPermission.PERMISSION_TYPES[:context])
     end
 
     context "if the operation is '-'" do
@@ -180,10 +182,10 @@ describe "CbacPristinePermission" do
         @pristine_permission.operation = '-'
       end
 
-      it "should still create a known permission" do
-        proc {
+      it "still creates a known permission" do
+        expect(proc {
           @pristine_permission.accept
-        }.should change(Cbac::KnownPermission, :count).by(1)
+        }).to change(Cbac::KnownPermission, :count).by(1)
       end
     end
   end
@@ -197,7 +199,7 @@ describe "CbacPristinePermission" do
       @pristine_admin_role = PristineRole.new(:role_id => 1, :role_type => PristineRole.ROLE_TYPES[:admin], :name => @admin_role.name)
 
       @pristine_permission = PristinePermission.new(:privilege_set_name => @privilege_set.name)
-      @pristine_permission.stub(:register_change)
+      allow(@pristine_permission).to receive(:register_change)
     end
 
     context "if operation '+' is used" do
@@ -211,22 +213,22 @@ describe "CbacPristinePermission" do
           @pristine_permission.save!
         end
 
-        it "should delete the pristine permission since it was accepted" do
-          proc {
+        it "deletes the pristine permission since it was accepted" do
+          expect(proc {
             @pristine_permission.accept
-          }.should change(PristinePermission, :count).by(-1)
+          }).to change(PristinePermission, :count).by(-1)
         end
 
-        it "should register the change" do
-          @pristine_permission.should_receive(:register_change)
+        it "registers the change" do
+          expect(@pristine_permission).to receive(:register_change)
 
           @pristine_permission.accept
         end
 
-        it "should add the context permission to the database" do
-          proc {
+        it "adds the context permission to the database" do
+          expect(proc {
             @pristine_permission.accept
-          }.should change(Cbac::Permission, :count).by(1)
+          }).to change(Cbac::Permission, :count).by(1)
         end
       end
 
@@ -236,31 +238,31 @@ describe "CbacPristinePermission" do
           @pristine_permission.save!
         end
 
-        it "should delete the pristine permission since it was accepted" do
-          proc {
+        it "deletes the pristine permission since it was accepted" do
+          expect(proc {
             @pristine_permission.accept
-          }.should change(PristinePermission, :count).by(-1)
+          }).to change(PristinePermission, :count).by(-1)
         end
 
-        it "should register the change" do
-          @pristine_permission.should_receive(:register_change)
+        it "registers the change" do
+          expect(@pristine_permission).to receive(:register_change)
 
           @pristine_permission.accept
         end
 
-        it "should create a generic permission" do
-          proc {
+        it "creates a generic permission" do
+          expect(proc {
             @pristine_permission.accept
-          }.should change(Cbac::Permission, :count).by(1)
+          }).to change(Cbac::Permission, :count).by(1)
         end
 
         context "and the given role already exists" do
-          it "should use the existing role" do
+          it "uses the existing role" do
             @pristine_permission.pristine_role = @pristine_admin_role
 
             @pristine_permission.accept
 
-            Cbac::Permission.last.generic_role.should == @admin_role
+            expect(Cbac::Permission.last.generic_role).to eq(@admin_role)
           end
         end
 
@@ -269,10 +271,10 @@ describe "CbacPristinePermission" do
             Cbac::GenericRole.delete_all
           end
 
-          it "should create a generic role if it doesn't exist in yet" do
-            proc {
+          it "creates a generic role if it doesn't exist yet" do
+            expect(proc {
               @pristine_permission.accept
-            }.should change(Cbac::GenericRole, :count).by(1)
+            }).to change(Cbac::GenericRole, :count).by(1)
           end
         end
       end
@@ -284,12 +286,12 @@ describe "CbacPristinePermission" do
         @pristine_permission.pristine_role = @pristine_context_role
       end
 
-      it "should remove an existing permission" do
+      it "removes an existing permission" do
         Cbac::Permission.create(:privilege_set_id => @privilege_set.id, :generic_role_id => 0, :context_role => @pristine_context_role.name)
 
-        proc {
+        expect(proc {
           @pristine_permission.accept
-        }.should change(Cbac::Permission, :count).by(-1)
+        }).to change(Cbac::Permission, :count).by(-1)
       end
 
       context "if the permission specified does not exist" do
@@ -297,10 +299,10 @@ describe "CbacPristinePermission" do
           Cbac::Permission.delete_all
         end
 
-        it "should raise an error" do
-          proc {
+        it "raises an error" do
+          expect(proc {
             @pristine_permission.accept
-          }.should raise_error(ArgumentError)
+          }).to raise_error(ArgumentError)
         end
       end
     end
@@ -312,82 +314,82 @@ describe "CbacPristinePermission" do
       @pristine_admin_role = PristineRole.new(:role_id => 1, :role_type => PristineRole.ROLE_TYPES[:admin], :name => "administrator")
     end
 
-    it "should persist the pristine permission to the database" do
+    it "persists the pristine permission to the database" do
       pristine_permission = PristinePermission.new(:privilege_set_name => "login", :pristine_role => @pristine_context_role, :operation => '+')
 
-      proc {
+      expect(proc {
         pristine_permission.stage
-      }.should change(Cbac::CbacPristine::PristinePermission, :count).by(1)
-
+      }).to change(Cbac::CbacPristine::PristinePermission, :count).by(1)
     end
 
-    it "should persist the associated role if it doesn't exist yet" do
+    it "persists the associated role if it doesn't exist yet" do
       pristine_permission = PristinePermission.new(:privilege_set_name => "login", :pristine_role => @pristine_context_role, :operation => '+')
 
-      proc {
+      expect(proc {
         pristine_permission.stage
-      }.should change(Cbac::CbacPristine::PristineRole, :count).by(1)
+      }).to change(Cbac::CbacPristine::PristineRole, :count).by(1)
     end
 
-    it "should not create a new pristine permission if the cbac permission exists and the pristine permission wants to add" do
+    it "does not create a new pristine permission if the cbac permission exists and the pristine permission wants to add" do
       privilege_set = Cbac::PrivilegeSetRecord.create(:name => "login")
       Cbac::Permission.create(:privilege_set_id => privilege_set.id, :generic_role_id => 0, :context_role => @pristine_context_role.name)
 
       pristine_permission = PristinePermission.new(:operation => '+', :privilege_set_name => privilege_set.name, :pristine_role => @pristine_context_role)
-      proc {
+
+      expect(proc {
         pristine_permission.stage
-      }.should_not change(Cbac::CbacPristine::PristinePermission, :count)
+      }).not_to change(Cbac::CbacPristine::PristinePermission, :count)
     end
 
-    it "should create a new pristine permission if the cbac permission exists and the pristine permission wants to revoke" do
+    it "creates a new pristine permission if the cbac permission exists and the pristine permission wants to revoke" do
       privilege_set = Cbac::PrivilegeSetRecord.create(:name => "login")
       Cbac::Permission.create(:privilege_set_id => privilege_set.id, :generic_role_id => 0, :context_role => @pristine_context_role.name)
 
       pristine_permission = PristinePermission.new(:operation => '-', :privilege_set_name => privilege_set.name, :pristine_role => @pristine_context_role)
-      proc {
+
+      expect(proc {
         pristine_permission.stage
-      }.should change(Cbac::CbacPristine::PristinePermission, :count).by(1)
+      }).to change(Cbac::CbacPristine::PristinePermission, :count).by(1)
     end
 
-    it "should not create a new pristine permission if a staged add permission exists and this pristine permission wants to revoke" do
+    it "does not create a new pristine permission if a staged add permission exists and this pristine permission wants to revoke" do
       privilege_set_name = "chat"
       PristinePermission.new(:operation => '+', :privilege_set_name => privilege_set_name, :pristine_role => @pristine_context_role)
       pristine_revoke_permission = PristinePermission.new(:operation => '-', :privilege_set_name => privilege_set_name, :pristine_role => @pristine_context_role)
 
-      proc {
+      expect(proc {
         pristine_revoke_permission.stage
-      }.should_not change(Cbac::CbacPristine::PristinePermission, :count).by(1)
+      }).not_to change(Cbac::CbacPristine::PristinePermission, :count)
     end
 
-    it "should delete a staged add permission if the pristine permission wants to revoke the same permission" do
+    it "deletes a staged add permission if the pristine permission wants to revoke the same permission" do
       privilege_set_name = "chat"
       PristinePermission.create(:operation => '+', :privilege_set_name => privilege_set_name, :pristine_role => @pristine_context_role)
       pristine_revoke_permission = PristinePermission.new(:operation => '-', :privilege_set_name => privilege_set_name, :pristine_role => @pristine_context_role)
 
-      proc {
+      expect(proc {
         pristine_revoke_permission.stage
-      }.should change(Cbac::CbacPristine::PristinePermission, :count).by(-1)
+      }).to change(Cbac::CbacPristine::PristinePermission, :count).by(-1)
     end
 
-    it "should not create a new pristine permission if a cbac known permission exists" do
+    it "does not create a new pristine permission if a cbac known permission exists" do
       known_number = 1
       pristine_permission = PristinePermission.new(:line_number => known_number, :privilege_set_name => "name not relevant", :pristine_role => @pristine_context_role)
       Cbac::KnownPermission.create(:permission_number => known_number, :permission_type => Cbac::KnownPermission.PERMISSION_TYPES[:context])
 
-      proc {
+      expect(proc {
         pristine_permission.stage
-      }.should_not change(Cbac::CbacPristine::PristinePermission, :count)
-
+      }).not_to change(Cbac::CbacPristine::PristinePermission, :count)
     end
 
-    it "should raise an error if the same pristine permission is staged twice" do
+    it "raises an error if the same pristine permission is staged twice" do
       privilege_set_name = "chat"
       PristinePermission.create(:operation => '+', :privilege_set_name => privilege_set_name, :pristine_role => @pristine_context_role, :line_number => 2)
       pristine_permission = PristinePermission.new(:operation => '+', :privilege_set_name => privilege_set_name, :pristine_role => @pristine_context_role, :line_number => 3)
 
-      proc {
+      expect(proc {
         pristine_permission.stage
-      }.should raise_error(ArgumentError)
+      }).to raise_error(ArgumentError)
     end
   end
 end