simple_record 2.1.3 → 2.1.6

data/test/test_shards.rb

@@ -1,148 +0,0 @@
-require 'test/unit'
-require File.join(File.dirname(__FILE__), "/../lib/simple_record")
-require File.join(File.dirname(__FILE__), "./test_helpers")
-require File.join(File.dirname(__FILE__), "./test_base")
-require "yaml"
-require 'aws'
-require_relative 'my_sharded_model'
-
-# Tests for SimpleRecord
-#
-class TestShards < TestBase
-
-  def setup
-    super
-    delete_all MyShardedModel
-    delete_all MyShardedByFieldModel
-  end
-
-  def teardown
-    super
-
-  end
-
-  # We'll want to shard based on ID's, user decides how many shards and some mapping function will
-  # be used to select the shard.
-  def test_id_sharding
-
-    mm = MyShardedModel.new(:name=>"single")
-    mm.save
-    sleep 1
-    puts 'finding by id'
-    mm2 = MyShardedModel.find(mm.id)
-    p mm2
-    assert_equal mm.id, mm2.id
-    puts 'deleting'
-    mm2.delete
-    sleep 1
-    mm3 = MyShardedModel.find(mm.id)
-    assert_nil mm3
-
-    puts "saving 20 now"
-    saved = []
-    20.times do |i|
-      mm = MyShardedModel.new(:name=>"name #{i}")
-      mm.save
-      saved << mm
-    end
-
-    # todo: assert that we're actually sharding
-
-    puts "finding them all"
-    found = []
-    rs    = MyShardedModel.find(:all)
-    rs.each do |m|
-      p m
-      found << m
-    end
-    saved.each do |so|
-      assert(found.find { |m1| m1.id == so.id })
-    end
-
-    puts "deleting all of them"
-    found.each do |fo|
-      fo.delete
-    end
-
-    puts "Now ensure that all are deleted"
-    rs = MyShardedModel.find(:all)
-    assert rs.size == 0
-
-    puts "Testing belongs_to sharding"
-
-
-  end
-
-  def test_field_sharding
-
-    states = MyShardedByFieldModel.shards
-    puts "states=" + states.inspect
-
-    mm = MyShardedByFieldModel.new(:name=>"single", :state=>"CA")
-    mm.save
-    sleep 1
-    puts 'finding by id'
-    mm2 = MyShardedByFieldModel.find(mm.id)
-    p mm2
-    assert_equal mm.id, mm2.id
-    puts 'deleting'
-    mm2.delete
-    sleep 1
-    mm3 = MyShardedByFieldModel.find(mm.id)
-    assert_nil mm3
-
-    puts "saving 20 now"
-    saved = []
-    20.times do |i|
-      mm = MyShardedByFieldModel.new(:name=>"name #{i}", :state=>states[i % states.size])
-      mm.save
-      p mm
-      saved << mm
-    end
-
-    sleep 1
-    # todo: assert that we're actually sharding
-
-    puts "finding them all"
-    found = []
-    rs    = MyShardedByFieldModel.find(:all)
-    rs.each do |m|
-      p m
-      found << m
-    end
-    saved.each do |so|
-      assert(found.find { |m1| m1.id == so.id })
-    end
-
-    rs = MyShardedByFieldModel.find(:all)
-    rs.each do |m|
-      p m
-      found << m
-    end
-    saved.each do |so|
-      assert(found.find { |m1| m1.id == so.id })
-    end
-
-    # Try to find on a specific known shard
-    selects     = SimpleRecord.stats.selects
-    cali_models = MyShardedByFieldModel.find(:all, :shard => "CA")
-    puts 'cali_models=' + cali_models.inspect
-    assert_equal(5, cali_models.size)
-    assert_equal(selects + 1, SimpleRecord.stats.selects)
-
-    puts "deleting all of them"
-    found.each do |fo|
-      fo.delete
-    end
-    sleep 1
-
-    puts "Now ensure that all are deleted"
-    rs = MyShardedByFieldModel.find(:all)
-    assert rs.size == 0
-  end
-
-  def test_time_sharding
-
-  end
-
-end

data/test/test_simple_record.rb

@@ -1,693 +0,0 @@
-require 'test/unit'
-require File.join(File.dirname(__FILE__), "/../lib/simple_record")
-require File.join(File.dirname(__FILE__), "./test_helpers")
-require_relative "test_base"
-require "yaml"
-require 'aws'
-require_relative 'my_model'
-require_relative 'my_child_model'
-require_relative 'model_with_enc'
-require_relative 'my_simple_model'
-
-# Tests for SimpleRecord
-#
-
-class TestSimpleRecord < TestBase
-
-
-    def test_save_get
-        mm = MyModel.new
-        mm.name = "Travis"
-        mm.age = 32
-        mm.cool = true
-        mm.save
-        sleep 1
-
-        assert !mm.created.nil?
-        assert !mm.updated.nil?
-        assert !mm.id.nil?
-        assert mm.age == 32
-        assert mm.cool == true
-        assert mm.name == "Travis"
-
-        id = mm.id
-        puts 'id=' + id.to_s
-        # Get the object back
-        mm2 = MyModel.find(id)
-        #puts 'got=' + mm2.name + ' and he/she is ' + mm2.age.to_s + ' years old and he/she is cool? ' + mm2.cool.to_s
-        #puts mm2.cool.class.name
-        assert mm2.id == mm.id
-        assert mm2.age == mm.age
-        assert mm2.cool == mm.cool
-        assert mm2.age == 32
-        assert mm2.cool == true
-        assert mm2.name == "Travis"
-        assert mm2.created.is_a? DateTime
-
-        # test nilification
-        mm2.age = nil
-        mm2.save
-        puts mm2.errors.inspect
-        sleep 1
-        mm2 = MyModel.find(id)
-        puts mm2.inspect
-        assert mm2.age.nil?, "doh, age should be nil, but it's " + mm2.age.inspect
-    end
-
-
-    def test_updates
-        mm = MyModel.new
-        mm.name = "Travis"
-        mm.age = 32
-        mm.cool = true
-        mm.s1 = "Initial value"
-        mm.save
-        id = mm.id
-        sleep 1
-
-        mm = MyModel.find(id)
-        mm.name = "Travis2"
-        mm.age = 10
-        mm.cool = false
-        mm.s1 = "" # test blank string
-
-        puts 'mm=' + mm.inspect
-        mm.save
-        sleep 1
-
-        puts 'mm2=' + mm.inspect
-
-        assert mm.s1 == "", "mm.s1 is not empty string, it is " + mm.s1.inspect
-
-        mm = MyModel.find(id)
-        assert mm.name == "Travis2", "Name was not Travis2, it was #{mm.name}"
-        assert mm.age == 10
-        assert mm.cool == false
-        assert mm.s1 == "", "mm.s1 is not empty string, it is #{mm.s1.inspect}"
-
-    end
-
-    def test_funky_values
-        mm = MyModel.new(:name=>"Funky")
-        mm.s1 = "other/2009-11-10/04/84.eml" # reported here: http://groups.google.com/group/simple-record/browse_thread/thread/3659e82491d03a2c?hl=en
-        assert mm.save
-        assert mm.errors.size == 0
-
-        mm2 = MyModel.find(mm.id)
-        puts 'mm2=' + mm2.inspect
-
-    end
-
-
-    def test_create
-        mm = MyModel.create(:name=>"Travis", :age=>32, :cool=>true)
-        puts 'mm=' + mm.inspect
-        assert !mm.id.nil?
-    end
-
-    def test_bad_query
-        assert_raise Aws::AwsError do
-            mm2 = MyModel.find(:all, :conditions=>["name =4?", "1"])
-        end
-    end
-
-    def test_batch_save
-        items = []
-        mm = MyModel.new
-        mm.name = "Travis"
-        mm.age = 32
-        mm.cool = true
-        items << mm
-        mm = MyModel.new
-        mm.name = "Tritt"
-        mm.age = 44
-        mm.cool = false
-        items << mm
-        MyModel.batch_save(items)
-        sleep 2
-        items.each do |item|
-            puts 'id=' + item.id
-            new_item = MyModel.find(item.id)
-            #puts 'new=' + new_item.inspect
-            assert item.id == new_item.id
-            assert item.name == new_item.name
-            assert item.cool == new_item.cool
-        end
-    end
-
-    # Testing getting the association ID without materializing the obejct
-    def test_get_belongs_to_id
-        mm = MyModel.new
-        mm.name = "Parent"
-        mm.age = 55
-        mm.cool = true
-        mm.save
-
-        child = MyChildModel.new
-        child.name = "Child"
-        child.my_model = mm
-        puts 'c1=' + child.inspect
-        puts 'mmid1=' + child.my_model_id.to_s
-        assert child.my_model_id == mm.id
-        child.save
-        puts 'mmid2=' + child.my_model_id.to_s
-
-        puts "child=" + child.inspect
-        sleep 1
-
-        child = MyChildModel.find(child.id)
-        puts "child find=" + child.inspect
-        puts "child.my_model_id = " + child.my_model_id.to_s
-        assert !child.my_model_id.nil?
-        assert !child.my_model.nil?
-        assert child.my_model_id == mm.id
-    end
-
-    def test_callbacks
-
-
-        mm = MyModel.new
-        assert !mm.save
-        assert mm.errors.count == 1 # name is required
-
-        # test queued callback before_create
-        mm.name = "Travis"
-        assert mm.save
-        sleep 1
-        # now nickname should be set on before_create
-        assert mm.nickname == mm.name
-
-        mm2 = MyModel.find(mm.id)
-        assert_equal mm2.nickname, mm.nickname
-        assert_equal mm2.name, mm.name
-
-
-    end
-
-    def test_dirty
-        mm = MyModel.new
-        mm.name = "Travis"
-        mm.age = 32
-        mm.cool = true
-        mm.save
-        id = mm.id
-        puts 'id=' + id.to_s
-        sleep 1
-        # Get the object back
-        mm2 = MyModel.find(id)
-        puts 'mm2=' + mm2.inspect
-        puts 'got=' + mm2.name.to_s + ' and he/she is ' + mm2.age.to_s + ' years old and he/she is cool? ' + mm2.cool.to_s
-        assert mm2.id == mm.id
-        assert mm2.age == mm.age
-        assert mm2.cool == mm.cool
-
-        mm2.name = "Travis 2"
-        mm2.save(:dirty=>true)
-
-        # todo: how do we assert this?  perhaps change a value directly in sdb and see that it doesn't get overwritten.
-        # or check stats and ensure only 1 attribute was put
-
-        # Test to ensure that if an item is not dirty, sdb doesn't get hit
-        puts SimpleRecord.stats.saves.to_s
-        SimpleRecord.stats.clear
-        mm2.save(:dirty=>true)
-        puts SimpleRecord.stats.saves.to_s
-        assert SimpleRecord.stats.saves == 0
-
-        mmc = MyChildModel.new
-        mmc.my_model = mm
-        mmc.x = mm
-        mmc.save
-
-        sleep 1
-
-        mmc2 = MyChildModel.find(mmc.id)
-        assert mmc2.my_model_id == mmc.my_model_id, "mm2.my_model_id=#{mmc2.my_model_id} mmc.my_model_id=#{mmc.my_model_id}"
-        puts 'setting my_model to nil'
-        mmc2.my_model = nil
-        mmc2.x = nil
-        puts 'saving my_model to nil'
-        SimpleRecord.stats.clear
-        assert mmc2.save(:dirty=>true)
-        assert SimpleRecord.stats.saves == 1, "saves is #{SimpleRecord.stats.saves}" # 1 put only for updated, should have a count of attributes saved in stats
-        assert SimpleRecord.stats.deletes == 1, "deletes is #{SimpleRecord.stats.deletes}"
-        assert mmc2.id == mmc.id
-        assert mmc2.my_model_id == nil
-        assert mmc2.my_model == nil, "my_model not nil? #{mmc2.my_model.inspect}"
-
-        sleep 1
-
-        mmc3 = MyChildModel.find(mmc.id)
-        puts "mmc3 1 =" + mmc3.inspect
-        assert mmc3.my_model_id == nil, "my_model_id not nil? #{mmc3.my_model_id.inspect}"
-        assert mmc3.my_model == nil
-
-        mm3 = MyModel.new(:name=>"test")
-        assert mm3.save
-        sleep 1
-
-        mmc3.my_model = mm3
-        assert mmc3.my_model_changed?
-        assert mmc3.save(:dirty=>true)
-        assert mmc3.my_model_id == mm3.id
-        assert mmc3.my_model.id == mm3.id
-
-        sleep 1
-        mmc3 = MyChildModel.find(mmc3.id)
-        puts "mmc3=" + mmc3.inspect
-        assert mmc3.my_model_id == mm3.id, "my_model_id=#{mmc3.my_model_id.inspect} mm3.id=#{mm3.id.inspect}"
-        assert mmc3.my_model.id == mm3.id
-
-        mmc3 = MyChildModel.find(mmc3.id)
-        mmc3.my_model_id = mm2.id
-        assert mmc3.my_model_id == mm2.id
-        assert mmc3.changed?
-        assert mmc3.my_model_changed?
-        assert mmc3.my_model.id == mm2.id
-
-    end
-
-    # http://api.rubyonrails.org/classes/ActiveRecord/Dirty.html#M002136
-    def test_changed
-        mm = MySimpleModel.new
-        mm.name = "Travis"
-        mm.age = 32
-        mm.cool = true
-        mm.save
-
-        puts 'changed?=' + mm.changed?.to_s
-        p mm.changed
-        assert !mm.changed?
-        assert mm.changed.size == 0
-        assert mm.changes.size == 0
-        assert !mm.name_changed?
-
-        mm.name = "Jim"
-        assert mm.changed?
-        assert mm.changed.size == 1
-        assert mm.changed[0] == "name"
-
-        assert mm.changes.size == 1
-        puts 'CHANGES=' + mm.changes.inspect
-        assert mm.changes["name"][0] == "Travis"
-        assert mm.changes["name"][1] == "Jim"
-
-        assert mm.name_changed?
-        assert mm.name_was == "Travis", "was #{mm.name_was}"
-        assert mm.name_change[0] == "Travis"
-        assert mm.name_change[1] == "Jim"
-
-    end
-
-    def test_count
-
-        SimpleRecord.stats.clear
-
-        count = MyModel.find(:count) # select 1
-        assert count > 0
-
-        mms = MyModel.find(:all) # select 2
-        puts 'mms=' + mms.inspect
-        assert mms.size > 0 # select 3
-        puts 'mms=' + mms.inspect
-        assert mms.size == count, "size != count! size=" + mms.size.to_s + " count=" + count.to_s
-        assert SimpleRecord.stats.selects == 3, "should have been 3 select, but was actually #{SimpleRecord.stats.selects}" # count should not have been called twice
-
-        count = MyModel.find(:count, :conditions=>["name=?", "Travis"])
-        assert count > 0
-
-        mms = MyModel.find(:all, :conditions=>["name=?", "Travis"])
-        assert mms.size > 0
-        assert mms.size == count
-
-    end
-
-    def test_attributes_correct
-        # child should contain child class attributes + parent class attributes
-
-        #MyModel.defined_attributes.each do |a|
-        #
-        #end
-        #MyChildModel.defined_attributes.inspect
-
-    end
-
-    def test_results_array
-        mms = MyModel.find(:all) # select 2
-        assert !mms.first.nil?
-        assert !mms.last.nil?
-        assert !mms.empty?
-        assert mms.include?(mms[0])
-
-        assert mms[2, 2].size == 2
-        assert mms[2..5].size == 4
-        assert mms[2...5].size == 3
-
-    end
-
-    def test_random_index
-        create_my_models(120)
-        mms = MyModel.find(:all)
-        o = mms[85]
-        puts 'o=' + o.inspect
-        assert !o.nil?
-        o = mms[111]
-        puts 'o=' + o.inspect
-        assert !o.nil?
-    end
-
-    def test_objects_in_constructor
-        mm = MyModel.new(:name=>"model1")
-        mm.save
-        # my_model should be treated differently since it's a belong_to
-        mcm = MyChildModel.new(:name=>"johnny", :my_model=>mm)
-        mcm.save
-        sleep 1
-
-        assert mcm.my_model != nil
-
-        mcm = MyChildModel.find(mcm.id)
-        puts 'mcm=' + mcm.inspect
-        assert mcm.my_model != nil
-
-    end
-
-
-    def test_nil_attr_deletion
-        mm = MyModel.new
-        mm.name = "Chad"
-        mm.age = 30
-        mm.cool = false
-        mm.save
-
-        sleep 1
-
-        # Should have 1 age attribute
-        sdb_atts = @@sdb.get_attributes('simplerecord_tests_my_models', mm.id, 'age')
-        puts 'sdb_atts=' + sdb_atts.inspect
-        assert sdb_atts[:attributes].size == 1, "hmmm, not size 1: " + sdb_atts[:attributes].size.to_s
-
-        mm.age = nil
-        mm.save
-        sleep 1
-
-        # Should be NIL
-        assert mm.age == nil, "age is #{mm.age}"
-
-        # Should have NO age attributes
-        assert @@sdb.get_attributes('simplerecord_tests_my_models', mm.id, 'age')[:attributes].size == 0
-    end
-
-    def test_null
-        puts Time.now.to_i.to_s
-        TestHelpers.clear_out_my_models
-
-        mm = MyModel.new(:name=>"birthay is null")
-        mm.save
-        mm2 = MyModel.new(:name=>"birthday is not null")
-        mm2.birthday = Time.now
-        mm2.save
-        sleep 2
-        mms = MyModel.find(:all, :conditions=>["birthday is null"])
-        mms.each do |m|
-            puts m.inspect
-        end
-        assert mms.size == 1
-        assert mms[0].id = mm.id
-        mms = MyModel.find(:all, :conditions=>["birthday is not null"])
-        mms.each do |m|
-            puts m.inspect
-        end
-        assert mms.size == 1
-        assert mms[0].id = mm2.id
-
-    end
-
-    # Test to add support for IN
-    def test_in_clause
-#        mms = MyModel.find(:all)
-
-#        mms2 = MyModel.find(:all, :conditions=>["id in ?"])
-
-    end
-
-    def test_base_attributes
-        mm = MyModel.new()
-        mm.name = "test name"
-        mm.base_string = "in base class"
-        mm.save_with_validation!
-        sleep 1
-
-        mm2 = MyModel.find(mm.id)
-        assert mm2.base_string == mm.base_string
-
-        mm2.base_string = "changed base string"
-        mm2.save_with_validation!
-        sleep 1
-
-        mm3 = MyModel.find(mm2.id)
-        assert mm3.base_string == mm2.base_string
-        puts mm3.inspect
-
-
-    end
-
-    def test_dates
-        mm = MyModel.new()
-        mm.name = "test name"
-        mm.date1 = Date.today
-        mm.date2 = Time.now
-        mm.date3 = DateTime.now
-        mm.save
-
-        sleep 1
-
-        mm = MyModel.find(:first, :conditions=>["date1 >= ?", 1.days.ago.to_date])
-        puts 'mm=' + mm.inspect
-        assert mm.is_a? MyModel
-
-        mm = MyModel.find(:first, :conditions=>["date2 >= ?", 1.minutes.ago])
-        puts 'mm=' + mm.inspect
-        assert mm.is_a? MyModel
-
-        mm = MyModel.find(:first, :conditions=>["date3 >= ?", 1.minutes.ago])
-        puts 'mm=' + mm.inspect
-        assert mm.is_a? MyModel
-
-    end
-
-    def test_attr_encrypted
-        require_relative 'model_with_enc'
-        ssn = "123456789"
-        password = "my_password"
-
-        ob = ModelWithEnc.new
-        ob.name = "my name"
-        ob.ssn = ssn
-        ob.password = password
-        puts "ob before save=" + ob.inspect
-        assert ssn == ob.ssn, "#{ssn} != #{ob.ssn} apparently!?"
-        puts "#{ob.password.class.name} ob.password=#{ob.password} password=#{password}"
-        assert password != ob.password # we know this doesn't work right
-        assert ob.password == password, "#{ob.password.class.name} ob.password=#{ob.password} password=#{password}"
-        ob.save
-
-        # try also with constructor, just to be safe
-        ob = ModelWithEnc.create(:ssn=>ssn, :name=>"my name", :password=>password)
-        assert ssn == ob.ssn, "#{ssn} != #{ob.ssn} apparently!?"
-        puts "#{ob.password.class.name} ob.password=#{ob.password} password=#{password}"
-        assert password != ob.password # we know this doesn't work right
-        assert ob.password == password, "#{ob.password.class.name} ob.password=#{ob.password} password=#{password}"
-        puts "ob after save=" + ob.inspect
-        assert ssn == ob.ssn
-        assert ob.password == password, "#{ob.password.class.name} ob.password=#{ob.password} password=#{password}"
-
-        sleep 2
-
-        ob2 = ModelWithEnc.find(ob.id)
-        puts 'ob2=' + ob2.inspect
-        assert ob2.name == ob.name, "#{ob2.name} vs #{ob.name}"
-        assert ob2.ssn == ob.ssn, "#{ob2.ssn} vs #{ob.ssn}"
-        assert ob2.ssn == ssn, "#{ob2.ssn} vs #{ssn}"
-        assert ob2.password == password, "#{ob2.password} vs #{password}"
-        assert ob2.attributes["password"] != password
-        assert ob2.password == ob.password, "#{ob2.password} vs #{ob.password}"
-
-    end
-
-    def test_non_persistent_attributes
-        mm = MyModel.new({:some_np_att=>"word"})
-        mm = MyModel.new({"some_other_np_att"=>"up"})
-
-    end
-
-    def test_atts_using_strings_and_symbols
-        mm = MyModel.new({:name=>"myname"})
-        mm2 = MyModel.new({"name"=>"myname"})
-        assert_equal(mm.name, mm2.name)
-
-        mm.save
-        mm2.save
-        sleep 1
-
-        mm = MyModel.find(mm.id)
-        mm2 = MyModel.find(mm2.id)
-        assert_equal mm.name, mm2.name
-    end
-
-    def test_constructor_using_belongs_to_ids
-        mm = MyModel.new({:name=>"myname"})
-        mm.save
-        sleep 1
-
-        mm2 = MyChildModel.new({"name"=>"myname2", :my_model_id=>mm.id})
-        puts 'mm2=' + mm2.inspect
-        assert_equal mm.id, mm2.my_model_id, "#{mm.id} != #{mm2.my_model_id}"
-        mm3 = mm2.my_model
-        puts 'mm3=' + mm3.inspect
-        assert_equal mm.name, mm3.name
-
-        mm3 = MyChildModel.create(:my_model_id=>mm.id, :name=>"myname3")
-
-        sleep 2
-        mm4 = MyChildModel.find(mm3.id)
-        assert_equal mm4.my_model_id, mm.id
-        assert !mm4.my_model.nil?
-
-    end
-
-    def test_update_attributes
-        mm = MyModel.new({:name=>"myname"})
-        mm.save
-
-        now = Time.now
-        mm.update_attributes(:name=>"name2", :age=>21, "date2"=>now)
-        assert mm.name == "name2", "Name is #{mm.name}"
-        assert mm.age == 21
-#        assert mm.date2.to_time.utc == now.utc, "#{mm.date2.class.name} #{mm.date2.to_time.inspect} != #{now.inspect}"
-        sleep 1
-
-        mm = MyModel.find(mm.id)
-        assert mm.name == "name2", "Name is #{mm.name}"
-        assert mm.age == 21, "Age is not 21, it is #{mm.age}"
-#        assert mm.date2 == now, "Date is not correct, it is #{mm.date2}"
-    end
-
-    def test_explicit_class_name
-        mm = MyModel.new({:name=>"myname"})
-        mm.save
-        sleep 1
-
-        mm2 = MyChildModel.new({"name"=>"myname2"})
-        mm2.x = mm
-        assert mm2.x.id == mm.id
-        mm2.save
-        sleep 1
-
-        mm3 = MyChildModel.find(mm2.id)
-        puts "mm3.x=" + mm3.x.inspect
-        assert mm3.x.id == mm.id
-    end
-
-    def test_storage_format
-
-        mm = MyModel.new({:name=>"myname"})
-        mm.date1 = Time.now
-        mm.date2 = DateTime.now
-        mm.save
-        sleep 1
-
-        raw = @@sdb.get_attributes(MyModel.domain, mm.id)
-        puts "raw=" + raw.inspect
-        assert raw[:attributes]["updated"][0].size == "2010-01-06T16:04:23".size
-        assert raw[:attributes]["date1"][0].size == "2010-01-06T16:04:23".size
-        assert raw[:attributes]["date2"][0].size == "2010-01-06T16:04:23".size
-
-    end
-
-    def test_empty_initialize
-        mm = MyModel.new
-
-        mme = ModelWithEnc.new
-        mme = ModelWithEnc.new(:ssn=>"", :password=>"") # this caused encryptor errors
-        mme = ModelWithEnc.new(:ssn=>nil, :password=>nil)
-    end
-
-    def test_string_ints
-        mm = MyModel.new
-        mm.name = "whatever"
-        mm.age = "1"
-        puts mm.inspect
-
-        mm2 = MyModel.new
-        mm2.name = "whatever2"
-        mm2.age = 1
-        params = {:name=>"scooby", :age=>"123"}
-        mm3 = MyModel.new(params)
-
-
-        assert mm.age == 1, "mm.age=#{mm.age}"
-        assert mm2.age == 1
-        assert mm3.age == 123
-
-        mm.save!
-        mm2.save!
-        mm3.save!
-        sleep 1
-
-        assert mm.age == 1
-        assert mm2.age == 1
-        assert mm3.age == 123
-
-        mmf1 = MyModel.find(mm.id)
-        mmf2 = MyModel.find(mm2.id)
-        mmf3 = MyModel.find(mm3.id)
-
-        assert mmf1.age == 1
-        assert mmf2.age == 1
-        assert mmf3.age == 123
-
-        mmf1.update_attributes({:age=>"456"})
-
-        mmf1.age == 456
-
-    end
-
-    def test_box_usage
-        mm = MyModel.new
-        mm.name = "whatever"
-        mm.age = "1"
-        mm.save
-        sleep 1
-
-        mms = MyModel.all
-
-        assert mms.box_usage && mms.box_usage > 0
-        assert mms.request_id
-
-    end
-
-    def test_multi_value_attributes
-
-        val = ['a', 'b', 'c']
-        val2 = [1, 2, 3]
-
-        mm = MyModel.new
-        mm.name = val
-        mm.age = val2
-        assert_equal val, mm.name
-        assert_equal val2, mm.age
-        mm.save
-
-        sleep 1
-        mm = MyModel.find(mm.id)
-        # Values are not returned in order
-        assert_equal val, mm.name.sort
-        assert_equal val2, mm.age.sort
-
-
-
-
-    end
-
-end