arrest 0.0.21 → 0.0.23

data/lib/arrest/root_resource.rb

@@ -7,9 +7,9 @@ module Arrest
         "#{self.resource_name}"
       end
 
-      def by_url(url)
+      def by_url(context, url)
         begin
-          body = body_root(source().get_many(url))
+          body = body_root(source().get_many(context, url))
         rescue Arrest::Errors::DocumentNotFoundError
           Arrest::logger.info "DocumentNotFoundError for #{url} gracefully returning []"
           return []
@@ -20,9 +20,9 @@ module Arrest
         end
       end
 
-      def all(filter={})
+      def all(context, filter={})
         begin
-          body = body_root(source().get_many(self.resource_path, filter))
+          body = body_root(source().get_many(context, self.resource_path, filter))
         rescue Arrest::Errors::DocumentNotFoundError
           Arrest::logger.info "DocumentNotFoundError for #{self.resource_path} gracefully returning []"
           return []
@@ -43,12 +43,12 @@ module Arrest
         self.build(body)
       end
 
-      def find(id)
+      def find(context, id)
         if id == nil || "" == id
           Arrest::logger.info "DocumentNotFoundError: no id given"
           raise Errors::DocumentNotFoundError.new
         end
-        r = source().get_one "#{self.resource_path}/#{id}"
+        r = source().get_one(context, "#{self.resource_path}/#{id}")
         body = body_root(r)
         if body == nil || body.empty?
           Arrest::logger.info "DocumentNotFoundError for #{self.resource_path}/#{id}"
@@ -57,7 +57,7 @@ module Arrest
         resource = self.build body.merge({:id => id})
         # traverse fields for subresources and fill them in
         self.all_fields.find_all{|f| f.is_a?(HasManySubResourceAttribute)}.each do |attr|
-          ids = AbstractResource::source.get_many_other_ids("#{resource.resource_location}/#{attr.sub_resource_field_name}")
+          ids = AbstractResource::source.get_many_other_ids(context, "#{resource.resource_location}/#{attr.sub_resource_field_name}")
           resource.send("#{attr.name}=", body_root(ids))
         end
         resource
@@ -76,8 +76,8 @@ module Arrest
               instance.instance_exec(call_args, &aproc)
             end
           end
-          send :define_singleton_method, name do |args = nil|
-            self.all.select do |instance|
+          send :define_singleton_method, name do |context, args = nil|
+            self.all(context).select do |instance|
               instance.instance_exec(args, &aproc)
             end
           end
@@ -102,12 +102,12 @@ module Arrest
       def scope name, &block
         super(name)
         if block_given?
-          send :define_singleton_method, name do
-            self.all.select &block
+          send :define_singleton_method, name do |context|
+            self.all(context).select(&block)
           end
         else
-          send :define_singleton_method, name do
-            body_root(source().get_many self.scoped_path(name)).map do |h|
+          send :define_singleton_method, name do |context|
+            body_root(source().get_many(context, self.scoped_path(name))).map do |h|
               self.build(h)
             end
           end
@@ -119,10 +119,10 @@ module Arrest
         resource_path + '/' + scope_name.to_s
       end
 
-      def stub stub_id
-        n = self.new
+      def stub(context, stub_id)
+        n = self.new(context)
         n.initialize_has_attributes({:id => stub_id}) do
-          r = n.class.source().get_one "#{self.resource_path}/#{stub_id}"
+          r = n.class.source().get_one(@context, "#{self.resource_path}/#{stub_id}")
           body = n.class.body_root(r)
           n.init_from_hash(body, true)
         end
@@ -130,8 +130,8 @@ module Arrest
       end
 
 
-      def delete_all
-        source().delete_all(self.resource_path)
+      def delete_all(context)
+        source().delete_all(context, self.resource_path)
       end
     end
 

data/lib/arrest/version.rb

@@ -1,3 +1,3 @@
 module Arrest
-  VERSION = "0.0.21"
+  VERSION = "0.0.23"
 end

data/test/context.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'arrest'
+class ContextTest < Test::Unit::TestCase
+
+  def setup
+    Arrest::Source.source = nil
+  end
+
+  class Facility < Arrest::RootResource
+  end
+  
+
+  class HeaderDeco
+    def self.headers
+      puts "MAAAAAHH"
+      {}
+    end
+  end
+
+  def test_context
+    context = Arrest::RequestContext.new()
+    context.header_decorator = HeaderDeco
+    scope = Arrest::ScopedRoot.new(context)
+    assert_not_nil scope.Facility
+    assert_not_nil scope.Facility.all
+
+    f0 = scope.Facility.new(:name => 'Foo')
+    assert f0.save
+
+    f1 = scope.Facility.all.first
+    f2 = scope.Facility.find(f1.id)
+
+  end
+end
+

data/test/nested_resource.rb

@@ -5,11 +5,12 @@ class NestedResourcesTest < Test::Unit::TestCase
 
   def setup
      Arrest::Source.source = nil
+     @scope = Arrest::ScopedRoot.new
      #Arrest::Source.debug = true
   end
 
   def test_instance_test
-    n = ANestedClass.new({:name => "foo", :underscore_name => "Bar"})
+    n = ANestedClass.new(nil, {:name => "foo", :underscore_name => "Bar"})
     assert_equal "foo", n.name
     assert_equal "Bar", n.underscore_name
   end
@@ -25,7 +26,7 @@ class NestedResourcesTest < Test::Unit::TestCase
       }
     }
 
-    actual = WithNested.new(input)
+    actual = @scope.WithNested.new(input)
     assert_equal 'parent', actual.parent_name
     assert_equal false, actual.bool
     assert actual.respond_to? :nested_object, "The parent object should have an accessor for the nested object"
@@ -44,7 +45,7 @@ class NestedResourcesTest < Test::Unit::TestCase
       }
     }
 
-    actual = WithNested.new(input)
+    actual = @scope.WithNested.new(input)
 
     assert_equal_hashes input, actual.to_hash
 
@@ -65,14 +66,14 @@ class NestedResourcesTest < Test::Unit::TestCase
       ]
     }
 
-    actual = WithManyNested.new(input)
+    actual = @scope.WithManyNested.new(input)
 
     assert_equal_hashes input, actual.to_hash
 
   end
 
   def test_belongs_to_to_hash
-    new_zoo = Zoo.new({:name => "Foo"})
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
     new_zoo.save
 
     input = {
@@ -85,7 +86,7 @@ class NestedResourcesTest < Test::Unit::TestCase
       }
     }
 
-    actual = WithNestedBelongingTo.new(input)
+    actual = @scope.WithNestedBelongingTo.new(input)
 
     assert_equal_hashes input, actual.to_hash
 
@@ -96,10 +97,10 @@ class NestedResourcesTest < Test::Unit::TestCase
 
   def test_custom_belongs_to
 
-    new_zoo = Zoo.new({:name => "Foo"})
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
     new_zoo.save
 
-    c = CustomNamedBelongsTo.new({:name => 'Bar', :schinken => new_zoo.id, :batzen => new_zoo.id})
+    c = @scope.CustomNamedBelongsTo.new({:name => 'Bar', :schinken => new_zoo.id, :batzen => new_zoo.id})
 
     c.save
     assert_not_nil c.id, "Persisted object should have id"
@@ -108,7 +109,7 @@ class NestedResourcesTest < Test::Unit::TestCase
 
 
     assert_not_nil c.id, "Persisted zoo should have id"
-    c_reloaded = CustomNamedBelongsTo.all.first
+    c_reloaded = @scope.CustomNamedBelongsTo.all.first
     assert_equal  "Foo", c_reloaded.zoo_thing.name
     assert_equal  "Foo", c_reloaded.zoo.name
 

data/test/unit.rb

@@ -5,6 +5,7 @@ class FirstTest < Test::Unit::TestCase
 
   def setup
      Arrest::Source.source = nil
+     @scope = Arrest::ScopedRoot.new
      #Arrest::Source.debug = true
   end
 
@@ -16,28 +17,29 @@ class FirstTest < Test::Unit::TestCase
 
   def test_init
     zooname =  "Hagenbecks"
-    z = Zoo.new({:name => zooname})
+    z = @scope.Zoo.new({:name => zooname})
     assert_equal zooname, z.name
     #assert_not_empty Arrest::AbstractResource.all_fields.select {|f| f.name == :id}, "AbstractResource defines the id field itself"
     #assert_not_empty Arrest::RootResource.all_fields.select {|f| f.name == :id}, "RootResource should inherit id from AbstractResource"
-    #assert_not_empty Zoo.all_fields.select {|f| f.name == :id}, "Zoo should inherit id field from RootResource"
+    #assert_not_empty @scope.Zoo.all_fields.select {|f| f.name == :id}, "Zoo should inherit id field from RootResource"
   end
 
   def test_create
-    zoo_count_before = Zoo.all.length
-    new_zoo = Zoo.new({:name => "Foo"})
-    new_zoo.save
-    zoo_count_after = Zoo.all.length
+    zoo_count_before = @scope.Zoo.all.length
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
+    assert_equal "Foo", new_zoo.name 
+    assert new_zoo.save, new_zoo.errors.full_messages.to_s
+    zoo_count_after = @scope.Zoo.all.length
     assert_not_nil new_zoo.id
 
     assert_equal (zoo_count_before + 1), zoo_count_after
     assert new_zoo.id != nil
 
-    zoo_the_last = Zoo.all.last
+    zoo_the_last = @scope.Zoo.all.last
     assert_equal new_zoo.name, zoo_the_last.name
     assert_equal new_zoo.id, zoo_the_last.id
 
-    zoo_reloaded = Zoo.find(new_zoo.id)
+    zoo_reloaded = @scope.Zoo.find(new_zoo.id)
     assert_equal new_zoo.name, zoo_reloaded.name
     assert_equal new_zoo.id, zoo_reloaded.id
   end
@@ -50,17 +52,17 @@ class FirstTest < Test::Unit::TestCase
     ]
 
     invalid_params.each do |p|
-      zoo_count_before = Zoo.all.length
-      new_zoo = Zoo.new(p)
+      zoo_count_before = @scope.Zoo.all.length
+      new_zoo = @scope.Zoo.new(p)
       assert_equal false, new_zoo.save, "zoo without name shouldnt be persistable"
-      assert_equal zoo_count_before, Zoo.all.length
+      assert_equal zoo_count_before, @scope.Zoo.all.length
       assert_equal :name, new_zoo.errors.first[0]
       assert_nil new_zoo.id
 
       new_zoo.name = "Foo"
 
       assert new_zoo.save, "Creating should be possible after setting a name"
-      zoo_count_after = Zoo.all.length
+      zoo_count_after = @scope.Zoo.all.length
       assert_not_nil new_zoo.id
 
       assert_equal (zoo_count_before + 1), zoo_count_after
@@ -72,35 +74,35 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_delete
-    zoo_count_before = Zoo.all.length
-    new_zoo = Zoo.new({:name => "Foo"})
+    zoo_count_before = @scope.Zoo.all.length
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
     new_zoo.save
-    zoo_count_after = Zoo.all.length
+    zoo_count_after = @scope.Zoo.all.length
 
     assert_equal (zoo_count_before + 1), zoo_count_after
     assert new_zoo.id != nil
 
-    zoo_the_last = Zoo.all.last
+    zoo_the_last = @scope.Zoo.all.last
     assert_equal new_zoo.name, zoo_the_last.name
 
-    zoo_reloaded = Zoo.find(new_zoo.id)
+    zoo_reloaded = @scope.Zoo.find(new_zoo.id)
     assert_equal new_zoo.name, zoo_reloaded.name
 
     zoo_reloaded.delete
-    assert_equal zoo_count_before, Zoo.all.length
+    assert_equal zoo_count_before, @scope.Zoo.all.length
   end
 
   def test_create_and_load
-    zoo_count_before = Zoo.all.length
-    new_zoo = Zoo.new({:name => "Foo"})
+    zoo_count_before = @scope.Zoo.all.length
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
     new_zoo.save
-    zoo_count_after = Zoo.all.length
+    zoo_count_after = @scope.Zoo.all.length
 
     assert_equal (zoo_count_before + 1), zoo_count_after
   end
 
   def test_update
-    new_zoo = Zoo.new({:name => "Foo"})
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
     new_zoo.save
 
     new_zoo_name = "Hagenbecks"
@@ -109,7 +111,7 @@ class FirstTest < Test::Unit::TestCase
 
     assert new_zoo.id != nil
 
-    zoo_reloaded = Zoo.find(new_zoo.id)
+    zoo_reloaded = @scope.Zoo.find(new_zoo.id)
     assert_not_nil zoo_reloaded
     assert_equal new_zoo.id, zoo_reloaded.id
 
@@ -117,13 +119,13 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_child
-    new_zoo = Zoo.new({:name => "Foo"})
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
     new_zoo.save
     assert_not_nil new_zoo.id
     #assert_not_nil new_zoo.class.all_fields.select {|f| f.name = :id}
 
     animal_kind = "mouse"
-    new_animal = Animal.new new_zoo, {:kind => animal_kind, :age => 42}
+    new_animal = @scope.Animal.new new_zoo, {:kind => animal_kind, :age => 42}
     assert new_zoo.id != nil
     assert_equal new_zoo.id, new_animal.zoo.id
     assert_equal new_zoo.id, new_animal.parent.id
@@ -132,7 +134,7 @@ class FirstTest < Test::Unit::TestCase
 
     assert new_animal.id != nil
 
-    zoo_reloaded = Zoo.find(new_zoo.id)
+    zoo_reloaded = @scope.Zoo.find(new_zoo.id)
     assert_equal new_zoo.id, zoo_reloaded.id
     assert_equal new_animal.parent.id, zoo_reloaded.id
 
@@ -148,11 +150,11 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_child_update
-    new_zoo = Zoo.new({:name => "Foo"})
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
     new_zoo.save
 
     animal_kind = "mouse"
-    new_animal = Animal.new new_zoo, {:kind => "foo", :age => 42}
+    new_animal = @scope.Animal.new new_zoo, {:kind => "foo", :age => 42}
     new_animal.save
 
     animal_reloaded = new_zoo.animals.first
@@ -166,13 +168,13 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_inheritance
-    new_zoo = SpecialZoo.new({:name => "Foo", :is_magic => true})
+    new_zoo = @scope.SpecialZoo.new({:name => "Foo", :is_magic => true})
     assert_equal "Foo", new_zoo.name
     assert_equal true, new_zoo.is_magic
     new_zoo.save
 
     assert new_zoo.id != nil, "Zoo must have id after save"
-    zoo_reloaded = SpecialZoo.find(new_zoo.id)
+    zoo_reloaded = @scope.SpecialZoo.find(new_zoo.id)
     assert_equal new_zoo.id, zoo_reloaded.id
     assert_equal true, zoo_reloaded.is_magic
     assert_equal "Foo", zoo_reloaded.name
@@ -181,11 +183,11 @@ class FirstTest < Test::Unit::TestCase
   def test_inheritance_update
     assert_equal :zoo3000, SpecialZoo.resource_name
 
-    new_zoo = SpecialZoo.new({:name => "Foo", :is_magic => true})
+    new_zoo = @scope.SpecialZoo.new({:name => "Foo", :is_magic => true})
     new_zoo.save
 
     assert new_zoo.id != nil, "Zoo must have id after save"
-    zoo_reloaded = SpecialZoo.find(new_zoo.id)
+    zoo_reloaded = @scope.SpecialZoo.find(new_zoo.id)
     assert_equal true, zoo_reloaded.is_magic
     assert_equal "Foo", zoo_reloaded.name
 
@@ -195,14 +197,14 @@ class FirstTest < Test::Unit::TestCase
     zoo_reloaded.is_magic = !zoo_reloaded.is_magic
     zoo_reloaded.save
 
-    updated_zoo = SpecialZoo.find(zoo_reloaded.id)
+    updated_zoo = @scope.SpecialZoo.find(zoo_reloaded.id)
     assert_equal new_name, updated_zoo.name
     assert_equal !old_is_magic, updated_zoo.is_magic
   end
 
   def test_read_only_attributes
     now = Time.now
-    zoo = SpecialZoo.new({
+    zoo = @scope.SpecialZoo.new({
       :name => "Zoo",
       :ro1 => "one",
       :ro2 => "two",
@@ -225,12 +227,12 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_stub_delayed_load
-    new_zoo = Zoo.new({:name => "Foo"})
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
     new_zoo.save
 
     assert_not_nil new_zoo.id
 
-    stubbed = Zoo.stub(new_zoo.id)
+    stubbed = @scope.Zoo.stub(new_zoo.id)
     assert stubbed.stubbed?, "Zoo should be a stub, so not loaded yet"
     new_name = stubbed.name
     assert !stubbed.stubbed?, "Zoo should not be a stub, so loaded now"
@@ -239,14 +241,14 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_stub_not_load_for_child_access
-    new_zoo = Zoo.new({:name => "Foo"})
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
     new_zoo.save
 
     assert_not_nil new_zoo.id
     # this is where the magic hapens
-    stubbed = Zoo.stub(new_zoo.id)
+    stubbed = @scope.Zoo.stub(new_zoo.id)
 
-    new_animal = Animal.new new_zoo, {:kind => "foo", :age => 42}
+    new_animal = @scope.Animal.new new_zoo, {:kind => "foo", :age => 42}
     new_animal.save
 
     assert stubbed.stubbed?, "Zoo should be a stub, so not loaded yet"
@@ -263,11 +265,11 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_root_scope
-    assert_not_nil Zoo.server_scope
+    assert_not_nil @scope.Zoo.server_scope
   end
 
   def test_child_scope
-    new_zoo = Zoo.new({:name => "Foo"})
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
     new_zoo.save
 
     assert_not_nil new_zoo.id
@@ -277,54 +279,54 @@ class FirstTest < Test::Unit::TestCase
 
   def test_local_scope
 
-    zoo_false = Zoo.new({:name => "Foo", :open => false})
+    zoo_false = @scope.Zoo.new({:name => "Foo", :open => false})
     zoo_false.save
-    zoo_true = Zoo.new({:name => "Foo", :open => true})
+    zoo_true = @scope.Zoo.new({:name => "Foo", :open => true})
     zoo_true.save
 
-    assert_equal 1, Zoo.open.length
-    assert_equal true, Zoo.open.first.open
+    assert_equal 1, @scope.Zoo.open.length
+    assert_equal true, @scope.Zoo.open.first.open
   end
 
   def test_local_child_scope
-    new_zoo = Zoo.new({:name => "Foo"})
+    new_zoo = @scope.Zoo.new({:name => "Foo"})
     new_zoo.save
 
-    new_zoo2 = Zoo.new({:name => "Boo"})
+    new_zoo2 = @scope.Zoo.new({:name => "Boo"})
     new_zoo2.save
 
     animal_kind = "mouse"
-    Animal.new(new_zoo, {:kind => animal_kind, :age => 42, :male => true}).save
-    Animal.new(new_zoo, {:kind => animal_kind, :age => 42, :male => false}).save
-    Animal.new(new_zoo2, {:kind => animal_kind, :age => 42, :male => false}).save
+    @scope.Animal.new(new_zoo, {:kind => animal_kind, :age => 42, :male => true}).save
+    @scope.Animal.new(new_zoo, {:kind => animal_kind, :age => 42, :male => false}).save
+    @scope.Animal.new(new_zoo2, {:kind => animal_kind, :age => 42, :male => false}).save
 
-    assert_equal 2, Zoo.all.first.animals.length
-    assert_equal 1, Zoo.all.last.animals.length
-    assert_equal 1, Zoo.all.first.animals.males_only.length
-    assert_equal true, Zoo.all.first.animals.males_only.first.male
+    assert_equal 2, @scope.Zoo.all.first.animals.length
+    assert_equal 1, @scope.Zoo.all.last.animals.length
+    assert_equal 1, @scope.Zoo.all.first.animals.males_only.length
+    assert_equal true, @scope.Zoo.all.first.animals.males_only.first.male
 
   end
 
   def test_para_filter
-    p1 = ParentFilter.new({:afield => "Foo"})
-    p2 = ParentFilter.new({:afield => "Bar"})
+    p1 = @scope.ParentFilter.new({:afield => "Foo"})
+    p2 = @scope.ParentFilter.new({:afield => "Bar"})
     p1.save
     p2.save
 
-    nnn = ParentFilter.nnn("Foo")
+    nnn = @scope.ParentFilter.nnn("Foo")
     assert_equal ["Foo"], nnn.map(&:afield)
   end
 
   def test_para_filter_child
-    p1 = ParentFilter.new({:afield => "ParentFoo"})
+    p1 = @scope.ParentFilter.new({:afield => "ParentFoo"})
     p1.save
 
-    c1 = ChildFilter.new(p1, :bfield => "Foo")
+    c1 = @scope.ChildFilter.new(p1, :bfield => "Foo")
     c1.save
-    c2 = ChildFilter.new(p1, :bfield => "Bar")
+    c2 = @scope.ChildFilter.new(p1, :bfield => "Bar")
     c2.save
 
-    reloaded_parent = ParentFilter.find(p1.id)
+    reloaded_parent = @scope.ParentFilter.find(p1.id)
     assert_not_nil reloaded_parent
     assert_equal "ParentFoo", reloaded_parent.afield
     assert_equal 2, reloaded_parent.child_filters.length
@@ -333,24 +335,24 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_no_param_filter
-    p1 = ParentFilter.new({:afield => "Foo"})
-    p2 = ParentFilter.new({:afield => "Bar"})
+    p1 = @scope.ParentFilter.new({:afield => "Foo"})
+    p2 = @scope.ParentFilter.new({:afield => "Bar"})
     p1.save
     p2.save
 
-    no_param = ParentFilter.no_param
+    no_param = @scope.ParentFilter.no_param
     assert_equal ["Foo"], no_param.map(&:afield)
   end
 
   def test_has_many
-    Zoo.new(:name => "Foo1").save
-    Zoo.new(:name => "Foo2").save
-    assert_equal 2, Zoo.all.length
-    all_zoo_ids = Zoo.all.map(&:id)
-    v1 = ZooOwner.new({:name => "Foo", :zoo_ids => all_zoo_ids})
+    @scope.Zoo.new(:name => "Foo1").save
+    @scope.Zoo.new(:name => "Foo2").save
+    assert_equal 2, @scope.Zoo.all.length
+    all_zoo_ids = @scope.Zoo.all.map(&:id)
+    v1 = @scope.ZooOwner.new({:name => "Foo", :zoo_ids => all_zoo_ids})
     v1.save
 
-    v1_reloaded = ZooOwner.all.first
+    v1_reloaded = @scope.ZooOwner.all.first
     assert_equal all_zoo_ids, v1_reloaded.zoo_ids
 
     url = v1.resource_location + '/' + Zoo.resource_name
@@ -360,7 +362,7 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_build
-    v1 = ZooOwner.new({:name => "Foo"})
+    v1 = @scope.ZooOwner.new({:name => "Foo"})
     v1.save
 
     zoo = v1.zoos.build
@@ -368,18 +370,18 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_scope_has_many
-    z1 = Zoo.new(:name => "Foo1", :open => true)
+    z1 = @scope.Zoo.new(:name => "Foo1", :open => true)
     z1.save
-    z2 = Zoo.new(:name => "Foo2", :open => false)
+    z2 = @scope.Zoo.new(:name => "Foo2", :open => false)
     z2.save
-    z3 = Zoo.new(:name => "Foo3", :open => true)
+    z3 = @scope.Zoo.new(:name => "Foo3", :open => true)
     z3.save
-    assert_equal 3, Zoo.all.length
+    assert_equal 3, @scope.Zoo.all.length
     all_zoo_ids = [z1.id, z2.id]
-    v1 = ZooOwner.new({:name => "Foo", :zoo_ids => all_zoo_ids})
+    v1 = @scope.ZooOwner.new({:name => "Foo", :zoo_ids => all_zoo_ids})
     v1.save
 
-    v1_reloaded = ZooOwner.all.first
+    v1_reloaded = @scope.ZooOwner.all.first
     assert_equal all_zoo_ids, v1_reloaded.zoo_ids
 
     url = v1.resource_location + '/' + Zoo.resource_name
@@ -389,79 +391,79 @@ class FirstTest < Test::Unit::TestCase
 
     assert_equal 1, v1_reloaded.zoos.open_filter.length
     assert_equal "Foo1", v1_reloaded.zoos.open_filter.first.name
-    assert_equal 3, Zoo.all.length
+    assert_equal 3, @scope.Zoo.all.length
   end
 
   def test_time
     now = Time.now
     expected = now.strftime "%FT%T%z"
-    t = TimeClass.new(:time => now)
+    t = @scope.TimeClass.new(:time => now)
     assert_equal expected, t.to_jhash[:time], "This is the expected default format"
   end
 
   def test_polymorphic_belongs_to
-    coma = CommentableA.new()
+    coma = @scope.CommentableA.new()
     coma.save
-    comb = CommentableB.new()
+    comb = @scope.CommentableB.new()
     comb.save
 
-    c = Comment.new(:commentable_ref => { :id => coma.id, :type => "coma"})
+    c = @scope.Comment.new(:commentable_ref => { :id => coma.id, :type => "coma"})
     result = c.commentable
     assert_equal coma.id, c.commentable_ref.id
     assert_equal result.class, CommentableA
 
-    c2 = Comment.new(:commentable_ref => { :id => comb.id, :type => "comb"})
+    c2 = @scope.Comment.new(:commentable_ref => { :id => comb.id, :type => "comb"})
     result2 = c2.commentable
     assert_equal comb.id, c2.commentable_ref.id
     assert_equal result2.class, CommentableB
   end
 
   def test_polymorphic_belongs_to_extended
-    coma = CommentableA.new()
+    coma = @scope.CommentableA.new()
     coma.save
-    comc = CommentableC.new()
+    comc = @scope.CommentableC.new()
     comc.save
 
-    c = ExtendedComment.new({ :special_commentable_ref => { :id => comc.id, :type => "comc"},
+    c = @scope.ExtendedComment.new({ :special_commentable_ref => { :id => comc.id, :type => "comc"},
                               :commentable_ref => { :id => coma.id, :type => "coma" }})
     assert_equal c.commentable.class, CommentableA
     assert_equal c.other_commentable.class, CommentableC
 
     c.save
-    c_reloaded = ExtendedComment.find(c.id)
+    c_reloaded = @scope.ExtendedComment.find(c.id)
     assert_equal comc.id, c_reloaded.special_commentable_ref.id
     assert_equal CommentableC, c_reloaded.other_commentable.class
     assert_equal CommentableA, c_reloaded.commentable.class
   end
 
   def test_delete_all_root_resources
-    d1 = DeleteMeAll.new()
+    d1 = @scope.DeleteMeAll.new()
     d1.save
-    d2 = DeleteMeAll.new()
+    d2 = @scope.DeleteMeAll.new()
     d2.save
 
-    d1_rel = DeleteMeAll.find(d1.id)
+    d1_rel = @scope.DeleteMeAll.find(d1.id)
     assert_not_nil d1_rel
-    d2_rel = DeleteMeAll.find(d2.id)
+    d2_rel = @scope.DeleteMeAll.find(d2.id)
     assert_not_nil d2_rel
-    all = DeleteMeAll.all
+    all = @scope.DeleteMeAll.all
     assert_equal 2, all.length
 
-    DeleteMeAll.delete_all
-    all = DeleteMeAll.all
+    @scope.DeleteMeAll.delete_all
+    all = @scope.DeleteMeAll.all
     assert_equal [], all
   end
 
   def test_update_belongs_to
-    f1 = Foo.new()
+    f1 = @scope.Foo.new()
     f1.save
     assert_equal 0, Arrest::Source.source.edge_count
-    b1 = Bar.new({:foo_id => f1.id})
+    b1 = @scope.Bar.new({:foo_id => f1.id})
     b1.save
     assert_equal 2, Arrest::Source.source.edge_count
     assert_equal 2, Arrest::Source.source.node_count
 
-    f2 = Foo.new()
+    f2 = @scope.Foo.new()
     f2.save
     assert_equal 2, Arrest::Source.source.edge_count
     b1.foo_id = f2.id
@@ -472,24 +474,24 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_has_many_matrix_in_mem_source
-    f1 = Foo.new()
+    f1 = @scope.Foo.new()
     f1.save
-    f2 = Foo.new()
+    f2 = @scope.Foo.new()
     f2.save
-    f3 = Foo.new()
+    f3 = @scope.Foo.new()
     f3.save
 
-    b1 = Bar.new({:foo_ids => [f1.id, f2.id], :foo_id => f3.id})
+    b1 = @scope.Bar.new({:foo_ids => [f1.id, f2.id], :foo_id => f3.id})
     b1.save
 
     assert_equal 2, b1.foos.length
 
-    b2 = Bar.new({:foo_ids => [f2.id, f3.id], :foo_id =>f1.id})
+    b2 = @scope.Bar.new({:foo_ids => [f2.id, f3.id], :foo_id =>f1.id})
     b2.save
 
     f1.delete
 
-    b1_rel = Bar.find(b1.id)
+    b1_rel = @scope.Bar.find(b1.id)
     assert_equal 1, b1_rel.foos.length
     assert_equal f2.id, b1_rel.foos.first.id
 
@@ -497,13 +499,13 @@ class FirstTest < Test::Unit::TestCase
     f2.bar_ids=[b1.id]
     f2.other_bar_ids=[b2.id]
     f2.save
-    f2_rel = Foo.find(f2.id)
+    f2_rel = @scope.Foo.find(f2.id)
     assert_equal 1, f2_rel.bars.length
     assert_equal 1, f2_rel.other_bars.length
 
     b2.delete
 
-    f2_rel = Foo.find(f2.id)
+    f2_rel = @scope.Foo.find(f2.id)
     assert_equal 1, f2_rel.bars.length
     assert_equal 0, f2_rel.other_bars.length
     assert_equal b1.id, f2_rel.bars.first.id
@@ -511,21 +513,21 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_has_many_with_belongs_to
-    f1 = Foo.new()
+    f1 = @scope.Foo.new()
     f1.save
-    f2 = Foo.new()
+    f2 = @scope.Foo.new()
     f2.save
-    f3 = Foo.new()
+    f3 = @scope.Foo.new()
     f3.save
 
-    b1 = Bar.new({:other_foo_id => f1.id, :foo_id => f3.id})
+    b1 = @scope.Bar.new({:other_foo_id => f1.id, :foo_id => f3.id})
     b1.save
-    b2 = Bar.new({:other_foo_id => f2.id, :foo_id => f1.id})
+    b2 = @scope.Bar.new({:other_foo_id => f2.id, :foo_id => f1.id})
     b2.save
 
-    f1_rel = Foo.find(f1.id)
-    f2_rel = Foo.find(f2.id)
-    f3_rel = Foo.find(f3.id)
+    f1_rel = @scope.Foo.find(f1.id)
+    f2_rel = @scope.Foo.find(f2.id)
+    f3_rel = @scope.Foo.find(f3.id)
 
     assert_equal 1, f1_rel.bars.length
     assert_equal b1.id, f1_rel.other_bars.first.id
@@ -539,19 +541,19 @@ class FirstTest < Test::Unit::TestCase
     b1.save
 
 
-    f3_rel = Foo.find(f3.id)
+    f3_rel = @scope.Foo.find(f3.id)
     assert f3_rel.bars.empty?
-    f2_rel = Foo.find(f2.id)
+    f2_rel = @scope.Foo.find(f2.id)
     assert_equal b1.id, f2_rel.bars.first.id
 
     b1.delete
-    f1_rel = Foo.find(f1.id)
+    f1_rel = @scope.Foo.find(f1.id)
     assert f1_rel.other_bars.empty?
   end
 
   def test_equality_non_persistent
-    zoo1 = Zoo.new(:name => 'zoo1')
-    zoo2 = Zoo.new(:name => 'zoo2')
+    zoo1 = @scope.Zoo.new(:name => 'zoo1')
+    zoo2 = @scope.Zoo.new(:name => 'zoo2')
     zoo1.id = '1'
     zoo2.id = '1'
 
@@ -563,8 +565,8 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_equality
-    zoo1 = Zoo.new(:name => 'zoo1')
-    zoo2 = Zoo.new(:name => 'zoo2')
+    zoo1 = @scope.Zoo.new(:name => 'zoo1')
+    zoo2 = @scope.Zoo.new(:name => 'zoo2')
 
     assert zoo1.save, 'simple zoo should be saveable'
     assert zoo2.save, 'simple zoo should be saveable'
@@ -577,12 +579,12 @@ class FirstTest < Test::Unit::TestCase
 
     assert_not_equal zoo1, nil, 'Anactual object should not equal nil'
 
-    zoo1_reloaded = Zoo.find(zoo1.id)
+    zoo1_reloaded = @scope.Zoo.find(zoo1.id)
     assert_not_nil zoo1_reloaded
 
     assert zoo1 == zoo1_reloaded, "Objects of the same class with the same id should be equal"
 
-    foo = Foo.new()
+    foo = @scope.Foo.new()
     foo.id = zoo1.id
 
     assert_not_equal zoo1, foo, "Objects of different classes should not be euqal, even if they have the same id"
@@ -592,7 +594,7 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_has_many_sub_resource_attr_setter
-    b = BarWithHasManySubResource.new()
+    b = @scope.BarWithHasManySubResource.new()
     b.save
 
     assert_raise ArgumentError do
@@ -607,7 +609,7 @@ class FirstTest < Test::Unit::TestCase
   end
 
   def test_update_attribute
-    zoo1 = Zoo.new(:name => 'zoo1')
+    zoo1 = @scope.Zoo.new(:name => 'zoo1')
     zoo1.update_attributes({:name => "updated"})
     assert_equal "updated", zoo1.name
   end