annotation_security 1.0.2 → 1.3.1

data/spec/annotation_security/exceptions_spec.rb

@@ -1,17 +1,17 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe AnnotationSecurity::RuleExecutionError do
-
-  before(:all) do
-    AnnotationSecurity.define_relations(:rule_ex_error_test) do
-      broken_relation { 1/0 }
-    end
-  end
-
-  it 'should be raised if a relation throws an error' do
-    lambda {
-      RuleExErrorTestPolicy.new(:user,:res).broken_relation?
-    }.should raise_error(AnnotationSecurity::RuleExecutionError)
-  end
-
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe AnnotationSecurity::RuleExecutionError do
+
+  before(:all) do
+    AnnotationSecurity.define_relations(:rule_ex_error_test) do
+      broken_relation { 1/0 }
+    end
+  end
+
+  it 'should be raised if a relation throws an error' do
+    lambda {
+      RuleExErrorTestPolicy.new(:user,:res).broken_relation?
+    }.should raise_error(AnnotationSecurity::RuleExecutionError)
+  end
+
 end

data/spec/annotation_security/includes/helper_spec.rb

@@ -1,82 +1,82 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe AnnotationSecurity::Helper do
-  
-  before(:each) do
-    SecurityContext.initialize(TestController.new)
-    SecurityContext.credential = TestUser.new 'theuser'
-    @helper = TestHelper.new
-    @res = TestResource.new 'theuser'
-  end
-
-  it "should understand options hash" do
-    options = { :action => :edit, :controller => :test, :id => @res }
-    expect(:test, :edit, [], {:id => @res})
-    @helper.action_allowed?(options).should be_true
-  end
-
-  it "should understand path strings" do
-    path = 'test/theuser/edit'
-    with_path_info path
-    expect :test, :edit, [], {:id => 'theuser'}
-    @helper.action_allowed?(path).should be_true
-  end
-
-  it "should understand resource objects" do
-    with_path_info 'test/theuser', :get, {:action => :show}
-    expect :test, :show, [], {:id => 'theuser'}
-    @helper.expects(:url_for).with(@res).returns('test/theuser')
-    @helper.action_allowed?(@res).should be_true
-  end
-
-  it "should take html options into account" do
-    with_path_info 'test/theuser', :delete, {:action => :destroy}
-    expect :test, :destroy, [], {:id => 'theuser'}
-    @helper.expects(:url_for).with(@res).returns('test/theuser')
-    @helper.action_allowed?(@res, { :method => :delete}).should be_true
-  end
-
-  it "should call named routes" do
-    with_path_info 'test/theuser/edit'
-    expect :test, :edit, [@res], {}
-    @helper.expects(:edit_test_path).with(@res, {}).returns('test/theuser/edit')
-    @helper.action_allowed?(:edit_test_path, @res).should be_true
-  end
-
-  it "should support defining all parameters explicitly" do
-    expect :test, :edit, [@res], {:option => true}
-    params = { :action => :edit, :controller => :test, :option => true }
-    @helper.action_allowed?('path/to/something', @res, params).should be_true
-  end
-
-  it "should create links if allowed" do
-    options = { :action => :edit, :controller => :test, :id => @res }
-    expect(:test, :edit, [], {:id => @res})
-    @helper.expects(:link_to_if).with(true, "Edit", options, {}).returns("<a>success</a>")
-    @helper.link_to_if_allowed("Edit", options){'no access'}.should == "<a>success</a>"
-  end
-
-  it "should not create links if forbidden" do
-    options = { :action => :edit, :controller => :test, :id => @res }
-    expect(:test, :edit, [], {:id => @res}, false)
-    @helper.expects(:link_to_if).with(false, "Edit", options, {}).returns("no access")
-    @helper.link_to_if_allowed("Edit", options){"no access"}.should == "no access"
-  end
-
-  def expect(ctrl, action, obj, param, result=true)
-    SecurityContext.expects(:allow_action?).with(ctrl, action, obj, param).returns(result)
-  end
-
-  # prepares #recognize_path to resolve the request path
-  def with_path_info(path, env = nil, result={})
-    env = { :method => env } if env.is_a? Symbol
-    env ||= { :method => :get }
-    parts = path.split('/')
-    result[:controller] ||= parts.first.to_sym
-    result[:id] ||= parts.second
-    result[:action] ||= parts.third.to_sym
-    ActionController::Routing::Routes.expects(:recognize_path).with(path, env).returns(result)
-  end
-
-end
-
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe AnnotationSecurity::Helper do
+  
+  before(:each) do
+    SecurityContext.initialize(TestController.new)
+    SecurityContext.credential = TestUser.new 'theuser'
+    @helper = TestHelper.new
+    @res = TestResource.new 'theuser'
+  end
+
+  it "should understand options hash" do
+    options = { :action => :edit, :controller => :test, :id => @res }
+    expect(:test, :edit, [], {:id => @res})
+    @helper.action_allowed?(options).should be_true
+  end
+
+  it "should understand path strings" do
+    path = 'test/theuser/edit'
+    with_path_info path
+    expect :test, :edit, [], {:id => 'theuser'}
+    @helper.action_allowed?(path).should be_true
+  end
+
+  it "should understand resource objects" do
+    with_path_info 'test/theuser', :get, {:action => :show}
+    expect :test, :show, [], {:id => 'theuser'}
+    @helper.expects(:url_for).with(@res).returns('test/theuser')
+    @helper.action_allowed?(@res).should be_true
+  end
+
+  it "should take html options into account" do
+    with_path_info 'test/theuser', :delete, {:action => :destroy}
+    expect :test, :destroy, [], {:id => 'theuser'}
+    @helper.expects(:url_for).with(@res).returns('test/theuser')
+    @helper.action_allowed?(@res, { :method => :delete}).should be_true
+  end
+
+  it "should call named routes" do
+    with_path_info 'test/theuser/edit'
+    expect :test, :edit, [@res], {}
+    @helper.expects(:edit_test_path).with(@res, {}).returns('test/theuser/edit')
+    @helper.action_allowed?(:edit_test_path, @res).should be_true
+  end
+
+  it "should support defining all parameters explicitly" do
+    expect :test, :edit, [@res], {:option => true}
+    params = { :action => :edit, :controller => :test, :option => true }
+    @helper.action_allowed?('path/to/something', @res, params).should be_true
+  end
+
+  it "should create links if allowed" do
+    options = { :action => :edit, :controller => :test, :id => @res }
+    expect(:test, :edit, [], {:id => @res})
+    @helper.expects(:link_to_if).with(true, "Edit", options, {}).returns("<a>success</a>")
+    @helper.link_to_if_allowed("Edit", options){'no access'}.should == "<a>success</a>"
+  end
+
+  it "should not create links if forbidden" do
+    options = { :action => :edit, :controller => :test, :id => @res }
+    expect(:test, :edit, [], {:id => @res}, false)
+    @helper.expects(:link_to_if).with(false, "Edit", options, {}).returns("no access")
+    @helper.link_to_if_allowed("Edit", options){"no access"}.should == "no access"
+  end
+
+  def expect(ctrl, action, obj, param, result=true)
+    SecurityContext.expects(:allow_action?).with(ctrl, action, obj, param).returns(result)
+  end
+
+  # prepares #recognize_path to resolve the request path
+  def with_path_info(path, env = nil, result={})
+    env = { :method => env } if env.is_a? Symbol
+    env ||= { :method => :get }
+    parts = path.split('/')
+    result[:controller] ||= parts.first.to_sym
+    result[:id] ||= parts.second
+    result[:action] ||= parts.third.to_sym
+    ActionController::Routing::Routes.expects(:recognize_path).with(path, env).returns(result)
+  end
+
+end
+

data/spec/annotation_security/manager/policy_manager_spec.rb

@@ -1,15 +1,15 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe AnnotationSecurity::PolicyManager do
-
-  it "should provide policy factories" do
-    AnnotationSecurity::PolicyManager.policy_factory(:policy_manager)
-    (defined? PolicyManagerPolicy).should_not be_nil
-  end
-
-  it "should return the policy class for a resource" do
-    AnnotationSecurity::PolicyManager.policy_class(:policy_manager_2).
-      should == PolicyManager2Policy
-  end
-  
-end
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe AnnotationSecurity::PolicyManager do
+
+  it "should provide policy factories" do
+    AnnotationSecurity::PolicyManager.policy_factory(:policy_manager)
+    (defined? PolicyManagerPolicy).should_not be_nil
+  end
+
+  it "should return the policy class for a resource" do
+    AnnotationSecurity::PolicyManager.policy_class(:policy_manager_2).
+      should == PolicyManager2Policy
+  end
+  
+end

data/spec/annotation_security/manager/resource_manager_spec.rb

@@ -1,17 +1,17 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe AnnotationSecurity::ResourceManager do
-
-  it "should provide resource classes" do
-    klass = AnnotationSecurity::ResourceManager.get_resource_class :test_resource
-    klass.should == TestResource
-  end
-
-  it "should find resource instances" do
-    res = AnnotationSecurity::ResourceManager.get_resource :test_resource, 'xy'
-    res.should be_instance_of(TestResource)
-    res.name.should == 'xy'
-  end
-
-end
-
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe AnnotationSecurity::ResourceManager do
+
+  it "should provide resource classes" do
+    klass = AnnotationSecurity::ResourceManager.get_resource_class :test_resource
+    klass.should == TestResource
+  end
+
+  it "should find resource instances" do
+    res = AnnotationSecurity::ResourceManager.get_resource :test_resource, 'xy'
+    res.should be_instance_of(TestResource)
+    res.name.should == 'xy'
+  end
+
+end
+

data/spec/annotation_security/manager/right_loader_spec.rb

@@ -1,17 +1,17 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe AnnotationSecurity::RightLoader do
-
-  it "should allow right definitions by hash" do
-    AnnotationSecurity::RightLoader.define_rights({
-      :right_loader => {
-        :right1 => 'if logged_in',
-        :right2 => 'if may_right1',
-      }})
-    (defined? RightLoaderPolicy).should_not be_nil
-    RightLoaderPolicy.has_rule?(:right1).should be_true
-    RightLoaderPolicy.has_rule?(:right2).should be_true
-  end
-
-end
-
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe AnnotationSecurity::RightLoader do
+
+  it "should allow right definitions by hash" do
+    AnnotationSecurity::RightLoader.define_rights({
+      :right_loader => {
+        :right1 => 'if logged_in',
+        :right2 => 'if may_right1',
+      }})
+    (defined? RightLoaderPolicy).should_not be_nil
+    RightLoaderPolicy.has_rule?(:right1).should be_true
+    RightLoaderPolicy.has_rule?(:right2).should be_true
+  end
+
+end
+

data/spec/annotation_security/policy/abstract_policy_spec.rb

@@ -1,17 +1,17 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe AnnotationSecurity::AbstractPolicy do
-  # For more tests see test_policy_spec.rb
-
-  it 'should create a subclass for a resource type' do
-    klass = AnnotationSecurity::AbstractPolicy.new_subclass(:abs_policy_test)
-    (defined? AbsPolicyTestPolicy).should_not be_nil
-    klass.should eql(AbsPolicyTestPolicy)
-    klass.static?.should be_false
-
-    (defined? AbsPolicyTestStaticPolicy).should_not be_nil
-    klass.static_policy_class.should eql(AbsPolicyTestStaticPolicy)
-    klass.static_policy_class.static?.should be_true
-  end
-
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe AnnotationSecurity::AbstractPolicy do
+  # For more tests see test_policy_spec.rb
+
+  it 'should create a subclass for a resource type' do
+    klass = AnnotationSecurity::AbstractPolicy.new_subclass(:abs_policy_test)
+    (defined? AbsPolicyTestPolicy).should_not be_nil
+    klass.should eql(AbsPolicyTestPolicy)
+    klass.static?.should be_false
+
+    (defined? AbsPolicyTestStaticPolicy).should_not be_nil
+    klass.static_policy_class.should eql(AbsPolicyTestStaticPolicy)
+    klass.static_policy_class.static?.should be_true
+  end
+
 end

data/spec/annotation_security/policy/all_resources_policy_spec.rb

@@ -1,24 +1,24 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe AllResourcesPolicy do
-
-  it 'should provide :__self__ relation' do
-    user = TestUser.new
-    user2 = TestUser.new
-    policy = AllResourcesPolicy.new(user)
-    policy.with_resource(user).__self__?.should be_true
-    policy.with_resource(user.as_one_role).__self__?.should be_true
-    policy.with_resource(user2).__self__?.should be_false
-  end
-
-  it 'should provide :logged_in relation' do
-    AllResourcesPolicy.new(TestUser.new).logged_in?.should be_true
-    AllResourcesPolicy.new(nil).logged_in?.should be_false
-
-    AllResourcesPolicy.has_static_rule?(:logged_in).should be_true
-    AllResourcesPolicy.has_dynamic_rule?(:logged_in).should be_false
-    rule = AllResourcesPolicy.rule_set.get_static_rule(:logged_in)
-    rule.requires_credential?.should be_false
-  end
-
-end
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe AllResourcesPolicy do
+
+  it 'should provide :__self__ relation' do
+    user = TestUser.new
+    user2 = TestUser.new
+    policy = AllResourcesPolicy.new(user)
+    policy.with_resource(user).__self__?.should be_true
+    policy.with_resource(user.as_one_role).__self__?.should be_true
+    policy.with_resource(user2).__self__?.should be_false
+  end
+
+  it 'should provide :logged_in relation' do
+    AllResourcesPolicy.new(TestUser.new).logged_in?.should be_true
+    AllResourcesPolicy.new(nil).logged_in?.should be_false
+
+    AllResourcesPolicy.has_static_rule?(:logged_in).should be_true
+    AllResourcesPolicy.has_dynamic_rule?(:logged_in).should be_false
+    rule = AllResourcesPolicy.rule_set.get_static_rule(:logged_in)
+    rule.requires_credential?.should be_false
+  end
+
+end

data/spec/annotation_security/policy/rule_set_spec.rb

@@ -1,112 +1,112 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe AnnotationSecurity::RuleSet do
-
-  before(:all) do
-    AnnotationSecurity.define_relations(:rule_set_test,:rule_set_test2) do
-      sys_relation :system, "true"
-      res_relation :resource, "true"
-      pre_relation :pretest, "true"
-    end
-    # This rule set is not to be modified during the tests!
-    @rule_set2 = RuleSetTest2Policy.rule_set
-  end
-
-  before(:each) do
-    # Use a fresh rule set for each test.
-    # This will break some functions of RuleSet,
-    # in these cases @rule_set2 is used for testing.
-    @rule_set = AnnotationSecurity::RuleSet.new(RuleSetTestPolicy)
-  end
-
-  it 'should have a self explaining name' do
-    @rule_set.to_s.should eql('<RuleSet of RuleSetTestPolicy>')
-  end
-
-  it 'should manage static relations' do
-    rule = @rule_set.add_rule(:sys_relation, :system) { true }
-    rule.should be_instance_of(AnnotationSecurity::Rule)
-    @rule_set.get_rule(:sys_relation, true).should eql(rule)
-    @rule_set.get_rule(:sys_relation, false).should be_nil
-  end
-
-  it 'should manage dynamic relations' do
-    rule = @rule_set.add_rule(:res_relation, :resource) { true }
-    rule.should be_instance_of(AnnotationSecurity::Rule)
-    @rule_set.get_rule(:res_relation, false).should eql(rule)
-    @rule_set.get_rule(:res_relation, true).should be_nil
-  end
-
-  it 'should manage pretest relations' do
-    rule = @rule_set.add_rule(:pre_relation, :pretest) { true }
-    rule.should be_instance_of(AnnotationSecurity::Rule)
-    @rule_set.get_rule(:pre_relation, true).should eql(rule)
-    @rule_set.get_rule(:pre_relation, false).should eql(rule)
-  end
-
-  it 'should manage dynamic rights' do
-    rule = @rule_set.add_rule(:res_right, :right, "if res_relation")
-    rule.should be_instance_of(AnnotationSecurity::Rule)
-    @rule_set.get_rule(:res_right,false).should eql(rule)
-    @rule_set.get_rule(:res_right,true).should be_nil
-  end
-
-  it 'should manage static rights' do
-    rule = @rule_set.add_rule(:sys_right, :right, "if sys_relation")
-    rule.should be_instance_of(AnnotationSecurity::Rule)
-    @rule_set.get_rule(:sys_right,true).should eql(rule)
-    @rule_set.get_rule(:sys_right,false).should be_nil
-  end
-
-  it 'should manage pretest rights' do
-    rule = @rule_set.add_rule(:pre_right, :right, "if pre_relation")
-    rule.should be_instance_of(AnnotationSecurity::Rule)
-    @rule_set.get_rule(:pre_right,true).should eql(rule)
-    @rule_set.get_rule(:pre_right,false).should eql(rule)
-  end
-
-  it 'should be able to copy dynamic rules from other rule sets' do
-    rule = @rule_set.copy_rule_from(:res_relation, @rule_set2, false)
-    rule.should be_instance_of(AnnotationSecurity::Rule)
-    @rule_set.get_rule(:res_relation, false).should eql(rule)
-    @rule_set2.get_rule(:res_relation, false).should_not eql(rule)
-  end
-
-  it 'should not create dynamic copies of static rules from other rule sets' do
-    rule = @rule_set.copy_rule_from(:sys_relation, @rule_set2, false)
-    rule.should be_nil
-  end
-
-  it 'should be able to copy static rules from other rule sets' do
-    rule = @rule_set.copy_rule_from(:sys_relation, @rule_set2, true)
-    rule.should be_instance_of(AnnotationSecurity::Rule)
-    @rule_set.get_rule(:sys_relation, true).should eql(rule)
-    @rule_set2.get_rule(:sys_relation, true).should_not eql(rule)
-  end
-
-  it 'should not create static copies of dynamic rules from other rule sets' do
-    rule = @rule_set.copy_rule_from(:res_relation, @rule_set2, true)
-    rule.should be_nil
-  end
-
-  it 'should not allow rules with forbidden names' do
-    lambda {
-      @rule_set.add_rule(:get_rule) {  }
-    }.should raise_error(AnnotationSecurity::RuleError)
-  end
-
-  it 'should not allow rules to be defined twice' do
-    @rule_set.add_rule(:test_rule) {  }
-    lambda {
-      @rule_set.add_rule(:test_rule) {  }
-    }.should raise_error(AnnotationSecurity::RuleError)
-  end
-
-  it 'should allow rules to be defined both statically and dynamically' do
-    r1 = @rule_set.add_rule(:test_rule, :system) {  }
-    r2 = @rule_set.add_rule(:test_rule, :resource) {  }
-    @rule_set.get_rule(:test_rule,true).should eql(r1)
-    @rule_set.get_rule(:test_rule,false).should eql(r2)
-  end
-
-end
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe AnnotationSecurity::RuleSet do
+
+  before(:all) do
+    AnnotationSecurity.define_relations(:rule_set_test,:rule_set_test2) do
+      sys_relation :system, "true"
+      res_relation :resource, "true"
+      pre_relation :pretest, "true"
+    end
+    # This rule set is not to be modified during the tests!
+    @rule_set2 = RuleSetTest2Policy.rule_set
+  end
+
+  before(:each) do
+    # Use a fresh rule set for each test.
+    # This will break some functions of RuleSet,
+    # in these cases @rule_set2 is used for testing.
+    @rule_set = AnnotationSecurity::RuleSet.new(RuleSetTestPolicy)
+  end
+
+  it 'should have a self explaining name' do
+    @rule_set.to_s.should eql('<RuleSet of RuleSetTestPolicy>')
+  end
+
+  it 'should manage static relations' do
+    rule = @rule_set.add_rule(:sys_relation, :system) { true }
+    rule.should be_instance_of(AnnotationSecurity::Rule)
+    @rule_set.get_rule(:sys_relation, true).should eql(rule)
+    @rule_set.get_rule(:sys_relation, false).should be_nil
+  end
+
+  it 'should manage dynamic relations' do
+    rule = @rule_set.add_rule(:res_relation, :resource) { true }
+    rule.should be_instance_of(AnnotationSecurity::Rule)
+    @rule_set.get_rule(:res_relation, false).should eql(rule)
+    @rule_set.get_rule(:res_relation, true).should be_nil
+  end
+
+  it 'should manage pretest relations' do
+    rule = @rule_set.add_rule(:pre_relation, :pretest) { true }
+    rule.should be_instance_of(AnnotationSecurity::Rule)
+    @rule_set.get_rule(:pre_relation, true).should eql(rule)
+    @rule_set.get_rule(:pre_relation, false).should eql(rule)
+  end
+
+  it 'should manage dynamic rights' do
+    rule = @rule_set.add_rule(:res_right, :right, "if res_relation")
+    rule.should be_instance_of(AnnotationSecurity::Rule)
+    @rule_set.get_rule(:res_right,false).should eql(rule)
+    @rule_set.get_rule(:res_right,true).should be_nil
+  end
+
+  it 'should manage static rights' do
+    rule = @rule_set.add_rule(:sys_right, :right, "if sys_relation")
+    rule.should be_instance_of(AnnotationSecurity::Rule)
+    @rule_set.get_rule(:sys_right,true).should eql(rule)
+    @rule_set.get_rule(:sys_right,false).should be_nil
+  end
+
+  it 'should manage pretest rights' do
+    rule = @rule_set.add_rule(:pre_right, :right, "if pre_relation")
+    rule.should be_instance_of(AnnotationSecurity::Rule)
+    @rule_set.get_rule(:pre_right,true).should eql(rule)
+    @rule_set.get_rule(:pre_right,false).should eql(rule)
+  end
+
+  it 'should be able to copy dynamic rules from other rule sets' do
+    rule = @rule_set.copy_rule_from(:res_relation, @rule_set2, false)
+    rule.should be_instance_of(AnnotationSecurity::Rule)
+    @rule_set.get_rule(:res_relation, false).should eql(rule)
+    @rule_set2.get_rule(:res_relation, false).should_not eql(rule)
+  end
+
+  it 'should not create dynamic copies of static rules from other rule sets' do
+    rule = @rule_set.copy_rule_from(:sys_relation, @rule_set2, false)
+    rule.should be_nil
+  end
+
+  it 'should be able to copy static rules from other rule sets' do
+    rule = @rule_set.copy_rule_from(:sys_relation, @rule_set2, true)
+    rule.should be_instance_of(AnnotationSecurity::Rule)
+    @rule_set.get_rule(:sys_relation, true).should eql(rule)
+    @rule_set2.get_rule(:sys_relation, true).should_not eql(rule)
+  end
+
+  it 'should not create static copies of dynamic rules from other rule sets' do
+    rule = @rule_set.copy_rule_from(:res_relation, @rule_set2, true)
+    rule.should be_nil
+  end
+
+  it 'should not allow rules with forbidden names' do
+    lambda {
+      @rule_set.add_rule(:get_rule) {  }
+    }.should raise_error(AnnotationSecurity::RuleError)
+  end
+
+  it 'should not allow rules to be defined twice' do
+    @rule_set.add_rule(:test_rule) {  }
+    lambda {
+      @rule_set.add_rule(:test_rule) {  }
+    }.should raise_error(AnnotationSecurity::RuleError)
+  end
+
+  it 'should allow rules to be defined both statically and dynamically' do
+    r1 = @rule_set.add_rule(:test_rule, :system) {  }
+    r2 = @rule_set.add_rule(:test_rule, :resource) {  }
+    @rule_set.get_rule(:test_rule,true).should eql(r1)
+    @rule_set.get_rule(:test_rule,false).should eql(r2)
+  end
+
+end