arsettings 1.0.1 → 1.1.1

data/test/_run_one.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+query = File.dirname(__FILE__) << '/*_test.rb'
+Dir[query].each { |filename| require filename }

data/test/activerecord_integration_test.rb

@@ -0,0 +1,137 @@
+require File.dirname(__FILE__) + '/_helper'
+
+class ActiveRecordIntegration < Test::Unit::TestCase
+  
+  def setup
+    ARSettings.default_class = Setting
+    Setting.reset_all
+    @@class_numbers ||= Array(1..100)
+    @klass = Object.const_get "Model#{@@class_numbers.shift}"
+  end
+  
+  verify 'can add settings to any AR::B class with has_setting' do
+    @klass.class_eval { has_setting :abcd , :default => 5 }
+    assert_equal 5 , @klass.abcd
+  end
+  
+  verify 'can specify that a setting should be able to be looked up from the instance' do
+    @klass.class_eval do 
+      has_setting :abcd , :default => 4
+      has_setting :efgh , :default => 5 , :instance => true
+    end
+    assert_raises(NoMethodError) { @klass.new.abcd  }
+    assert_raises(NoMethodError) { @klass.new.abcd? }
+    assert_nothing_raised        { @klass.new.efgh  }
+    assert_nothing_raised        { @klass.new.efgh? }
+  end
+
+  verify 'settings are loaded from the db, if they exist in the db' do
+    $sql_executor.silent_execute "insert into settings (name,value,package,volatile) values ('abcd','#{ARSettings.serialize(12)}','#{@klass.name}','f')"
+    Setting.send :load_from_db # to simulate initial conditions
+    @klass.class_eval { has_setting :abcd }
+    assert_equal 12 , @klass.abcd
+  end
+
+  verify 'uses ARSettings.default_class' do
+    ARSettings.create_settings_class :Setting16
+    ARSettings.default_class = Setting16
+    @klass.class_eval { has_setting :abcd }
+    @klass.abcd = 50
+    assert_equal 1  , Setting16.count
+    assert_equal 50 , Setting16.first.value
+  end
+
+  verify 'can pass all the same args that Setting.add can take' do
+    @klass.class_eval do
+      has_setting :abcd , :default => 12 , :volatile => true do |val|
+        val.to_i
+      end
+      has_setting :efgh , :default => 13.0 , :volatile => false do |val|
+        val.to_f
+      end
+      has_setting :ijkl
+    end
+    assert_equal 12                   ,  @klass.abcd
+    assert_equal 12.class             ,  @klass.abcd.class
+    assert_equal 13.0                 ,  @klass.efgh
+    assert_equal 13.0.class           ,  @klass.efgh.class
+    @klass.abcd = @klass.efgh = @klass.ijkl = '14'
+    assert_equal 14                   ,  @klass.abcd
+    assert_equal 14.class             ,  @klass.abcd.class
+    assert_equal 14.0                 ,  @klass.efgh
+    assert_equal 14.0.class           ,  @klass.efgh.class
+    assert_equal '14'                 ,  @klass.ijkl
+    assert_equal '14'.class           ,  @klass.ijkl.class
+    $sql_executor.silent_execute "update settings set value='#{ARSettings.serialize(200)  }' where name='abcd'"
+    $sql_executor.silent_execute "update settings set value='#{ARSettings.serialize(200.0)}' where name='efgh'"
+    $sql_executor.silent_execute "update settings set value='#{ARSettings.serialize(200.0)}' where name='ijkl'"
+    assert_equal 200                  ,  @klass.abcd
+    assert_equal 14.0                 ,  @klass.efgh
+    assert_equal '14'                 ,  @klass.ijkl
+  end
+
+  verify 'two classes dont see eachothers settings' do
+    @klass1 = @klass
+    setup
+    @klass2 = @klass
+    @klass1.class_eval { has_setting :abcd }
+    @klass2.class_eval { has_setting :abcd }
+    @klass1.abcd = 5
+    @klass2.abcd = 6
+    assert_equal 5 , @klass1.abcd
+    assert_equal 6 , @klass2.abcd
+  end
+
+  verify 'updates setting values if readding' do
+    @klass.class_eval { has_setting :abcd , :volatile => true , &lambda { |val| val.to_i * 2 } }
+    @klass.abcd = 5
+    assert_equal 10 , @klass.abcd
+    $sql_executor.silent_execute "update settings set value='#{ARSettings.serialize(200)}' where name='abcd'"
+    assert_equal 200 , @klass.abcd
+    assert_equal 200 , @klass.abcd
+    @klass.class_eval { has_setting :abcd , :volatile => false , &lambda { |val| val * 3 } }
+    @klass.abcd = 5
+    assert_equal 15 , @klass.abcd
+    $sql_executor.silent_execute "update settings set value='#{ARSettings.serialize(200)}' where name='abcd'"
+    assert_equal 15 , @klass.abcd
+  end
+  
+  verify "doesn't raise error for valid options" do
+    assert_nothing_raised do
+      @klass.class_eval do
+        has_setting :abcd , :instance => true , :volatile => true , :default => 5
+      end
+    end
+  end
+  
+  verify "does raise error if it receives any invalid options" do
+    [[:abcd,:settings_class,Setting],[:efgh,:package,String],[:ijkl,:lkjdsf,true],[:mnop,:abcd,true]].each do |meth,key,value|
+      assert_raises ARSettings::InvalidOptionError do
+        @klass.class_eval do
+          has_setting meth , key => value
+        end
+      end      
+    end
+  end
+  
+end
+
+
+
+# probably a better way, but IDK what it is
+# just adds a table and AR::B class for each test
+# and additional ones as necessary
+ActiveRecord::Schema.define do
+  suppress_messages do
+    ActiveRecordIntegration.instance_methods.grep(/^test/).size.next.times do |i|
+      create_table "model#{i+1}s" do |t|
+        t.string  :name     , :null => false , :size => 30
+        t.text    :value
+        t.boolean :volatile , :default => false
+        t.timestamps
+      end
+      Object.const_set "Model#{i+1}" , Class.new(ActiveRecord::Base)
+    end    
+  end
+end
+  

data/test/arbitrary_class_test.rb

@@ -0,0 +1,156 @@
+require File.dirname(__FILE__) + '/_helper'
+
+class AddToArbitraryClass < Test::Unit::TestCase
+      
+  def setup
+    Setting.reset_all
+  end
+  
+  def teardown
+    ARSettings.default_class = Setting
+  end
+  
+  def make_class(name,&block)
+    self.class.const_set name , Class.new
+    klass = self.class.const_get name
+    ARSettings.on klass
+    klass.instance_eval &block if block
+  end
+  
+  verify 'can add to any class' do
+    class C1 ; end
+    assert_raises(NoMethodError) { C1.has_setting :abc }
+    class C1 ; ARSettings.on self ; end
+    assert_nothing_raised { C1.has_setting :abc }
+  end
+  
+  verify 'this allows them to have settings' do
+    make_class(:C2) { has_setting :abcd }
+    C2.abcd = 5
+    assert_equal 5 , C2.abcd
+    assert_equal true , C2.abcd?
+  end
+    
+  verify 'can specify the desired settings class when adding to another class' do
+    ARSettings.create_settings_class :Setting12s
+    class C4 ; ARSettings.on self , :settings_class => Setting12s ; end
+    assert_equal 0 , Setting12s.count
+    C4.has_setting :abcd
+    assert_equal 1 , Setting12s.count
+  end
+  
+  verify 'settings are loaded from the db, if they exist in the db' do
+    $sql_executor.silent_execute "insert into settings (name,value,package,volatile) values ('abcd','#{ARSettings.serialize(12)}','AddToArbitraryClass::C3','f')"
+    Setting.send :load_from_db # to simulate initial conditions
+    make_class(:C3) { has_setting :abcd }
+    assert_equal 12 , C3.abcd
+  end
+  
+  verify 'can specify settings without specifying a settings class, then it defaults to ARSettings.default_class' do
+    ARSettings.create_settings_class :Setting13
+    ARSettings.default_class = Setting13
+    make_class(:C4) { has_setting :abcd }
+    C4.abcd = 12
+    assert_equal 1  , Setting13.count
+    assert_equal 12 , Setting13.first.value
+  end
+  
+  verify 'raises error if try to add settings without specifying a settings class or default' do
+    ARSettings.default_class = nil
+    assert_raises(ARSettings::NoDefaultPackageError) { make_class(:C5) { has_setting :abcd } }
+  end
+  
+  verify 'can pass all the same args that Setting.add can take' do
+    ARSettings.default_class = nil
+    ARSettings.create_settings_class :Setting15
+    make_class :C6 do
+      has_setting :abcd , :default => 12 , :volatile => true do |val|
+        val.to_i
+      end
+      has_setting :efgh , :default => 13.0 , :volatile => false do |val|
+        val.to_f
+      end
+      has_setting :ijkl
+    end
+    assert_equal 12                   ,  C6.abcd
+    assert_equal 12.class             ,  C6.abcd.class
+    assert_equal 13.0                 ,  C6.efgh
+    assert_equal 13.0.class           ,  C6.efgh.class
+    C6.abcd = C6.efgh = C6.ijkl = '14'
+    assert_equal 14                   ,  C6.abcd
+    assert_equal 14.class             ,  C6.abcd.class
+    assert_equal 14.0                 ,  C6.efgh
+    assert_equal 14.0.class           ,  C6.efgh.class
+    assert_equal '14'                 ,  C6.ijkl
+    assert_equal '14'.class           ,  C6.ijkl.class
+    $sql_executor.silent_execute "update setting15s set value='#{ARSettings.serialize(200)  }' where name='abcd'"
+    $sql_executor.silent_execute "update setting15s set value='#{ARSettings.serialize(200.0)}' where name='efgh'"
+    $sql_executor.silent_execute "update setting15s set value='#{ARSettings.serialize(200.0)}' where name='ijkl'"
+    assert_equal 200                  ,  C6.abcd
+    assert_equal 14.0                 ,  C6.efgh
+    assert_equal '14'                 ,  C6.ijkl
+  end
+  
+  verify 'two classes dont see eachothers settings' do
+    make_class(:C7) { has_setting :abcd }
+    make_class(:C8) { has_setting :abcd }
+    C7.abcd = 5
+    C8.abcd = 6
+    assert_equal 5 , C7.abcd
+    assert_equal 6 , C8.abcd
+  end
+  
+  verify 'can specify that a setting should be able to be looked up from the instance' do
+    make_class :C25 do
+      has_setting :abcd , :default => 4
+      has_setting :efgh , :default => 5 , :instance => true
+    end
+    assert_raises(NoMethodError) { C25.new.abcd  }
+    assert_raises(NoMethodError) { C25.new.abcd? }
+    assert_nothing_raised        { C25.new.efgh  }
+    assert_nothing_raised        { C25.new.efgh? }
+  end
+  
+  verify "ARSettings.on doesn't raise error for valid options" do
+    class C9 ; end
+    assert_nothing_raised do
+      ARSettings.on C9 , :settings_class => Setting
+    end
+  end
+  
+  verify "ARSettings.on does raise error if it receives any invalid options" do
+    [ [ (class C11;self;end)  ,  :package         ,   String  ],
+      [ (class C12;self;end)  ,  :lkjdsf          ,   true    ],
+      [ (class C13;self;end)  ,  :abcd            ,   true    ],
+      [ (class C14;self;end)  ,  :instance        ,   true    ],
+      [ (class C15;self;end)  ,  :volatile        ,   true    ],
+      [ (class C16;self;end)  ,  :default         ,   true    ],
+    ].each do |klass,key,value|
+      assert_raises ARSettings::InvalidOptionError do
+        ARSettings.on klass , key => value
+      end      
+    end
+  end
+  
+  
+  verify "has_setting doesn't raise error for valid options" do
+    class C17 ; ARSettings.on self ; end
+    assert_nothing_raised do
+      C17.has_setting :abcd , :volatile => true , :default => 4 , :instance => true
+    end
+  end
+  
+  verify "has_setting does raise error if it receives any invalid options" do
+    [ [ (class C18;ARSettings.on(self);self;end)  ,  :a  ,  :package         ,   String  ],
+      [ (class C19;ARSettings.on(self);self;end)  ,  :b  ,  :lkjdsf          ,   true    ],
+      [ (class C20;ARSettings.on(self);self;end)  ,  :c  ,  :abcd            ,   true    ],
+      [ (class C24;ARSettings.on(self);self;end)  ,  :g  ,  :settings_class  ,   Setting ],
+    ].each do |klass,meth,key,value|
+      assert_raises ARSettings::InvalidOptionError do
+        klass.has_setting meth , key => value
+      end      
+    end
+  end
+end
+
+    

data/test/packaged_test.rb

@@ -0,0 +1,306 @@
+require File.dirname(__FILE__) + '/_helper'
+
+class TestPackaging < Test::Unit::TestCase
+  
+  def setup
+    Setting.reset_all
+  end
+  
+  
+  context 'singleton' do
+    
+    packaged = ARSettings::Packaged
+    
+    verify 'cannot instantiate on your own' do
+      assert_raises(NoMethodError) { ARSettings::Packaged.new Setting , String }
+    end
+    
+    verify 'has_instance? returns whether it has instantiated a given package' do
+      MyClass1 = Class.new
+      assert !packaged.has_instance?(Setting,MyClass1)
+      packaged.instance Setting , MyClass1
+      assert packaged.has_instance?(Setting,MyClass1)
+    end
+    
+    verify 'instance returns the same result' do
+      packaged.instance(Setting,String)
+      packaged.instance(Setting,String)
+    end
+    
+    verify '#instance returns an instance of Packaged' do
+      MyClass2 = Class.new
+      assert_equal packaged , packaged.instance(Setting , MyClass2).class
+      assert_equal packaged , packaged.instance(Setting , String).class
+    end
+    
+    verify 'it raises an error if given a package that is not a string / symbol / class' do
+      assert_raises(ARSettings::InvalidPackageError) { packaged.instance(Setting,/whoops!/) }
+      assert_nothing_raised { packaged.instance(Setting,'string')  }
+      assert_nothing_raised { packaged.instance(Setting,:symbol)   }
+      assert_nothing_raised { packaged.instance(Setting,Class)     }
+    end
+    
+    verify 'it considers strings, symbols, and classes to symbols' do
+      assert_equal :cLaSs  , packaged.instance(Setting,'cLaSs').package
+      assert_equal :Symbol , packaged.instance(Setting,:Symbol).package
+      assert_equal :Symbol , packaged.instance(Setting,Symbol).package
+    end
+    
+    verify 'raises error if settings_class is not a settings class' do
+      assert_raises(packaged::InvalidSettingsClassError) { packaged.instance(String,String) }
+    end
+  
+    verify 'returns the same package regardless of how it is requested' do
+      id = Setting.package(Setting).object_id
+      assert_equal id , Setting.package(:Setting).object_id
+      assert_equal id , Setting.package('Setting').object_id
+    end
+    
+  end
+  
+  
+  
+  
+  
+  context 'settings behaviour' do
+  
+    s = Setting.package(String)
+  
+    verify 'can query whether a setting exists with setting?, and can declare settings with add, or has_setting' do
+      assert !s.setting?(:a)
+      assert !s.setting?(:b)
+      s.add :a
+      s.add :b
+      assert s.setting?(:a)
+      assert s.setting?(:b)
+    end
+    
+    verify 'has_setting is an alias for add' do
+      assert_equal s.method(:add) , s.method(:has_setting)
+    end
+    
+    verify "add returns the package the setting was added to" do
+      assert_equal s , s.add( :xyz , :default => 1)
+      assert_equal s , s.add( :xyz , :default => 2)
+    end
+        
+    verify 'can add default when creating' do
+      s.add :a , :default => 123
+      assert_equal 123 , s.a
+    end
+      
+    verify 'can pass proc to handle postprocessing' do
+      s.add :a , :default => '123' do |setting|
+        setting.to_i
+      end
+      assert_equal 123 , s.a
+      s.a = '456'
+      assert_equal 456 , s.a
+    end
+      
+    verify 'adds record to the db' do
+      assert_count 0
+      s.add :a , :default => /abc/
+      assert_count 1
+      setting = Setting.find_by_sql("select * from settings").first
+      assert_equal 'a' , setting.name
+      assert_equal( /abc/ , setting.value )
+    end
+      
+    verify 'does not raise error if the setting already exists' do
+      assert_nothing_raised { s.add :a }
+      assert_nothing_raised { s.add :a }
+    end
+      
+    verify 'does not overwrite current value with default when added repeatedly' do
+      s.add :a , :default => 12
+      assert_equal 12 , s.a
+      s.add 'a' , :default => 13
+      assert_equal 12 , s.a
+      s.add 'b' , :default => 14
+      assert_equal 14 , s.b
+      s.add :b , :default => 15
+      assert_equal 14 , s.b
+    end
+      
+    verify 'get a list of settings' do
+      s.add :abc
+      s.add :def
+      s.add :ghi
+      assert_equal [:abc,:def,:ghi] , s.settings.sort_by { |name| name.to_s }
+    end
+      
+    verify 'get a list of settings and values' do
+      s.add :abc , :default => 1
+      s.add :def , :default => 2
+      s.add :ghi , :default => 3
+      assert_equal [[:abc,1],[:def,2],[:ghi,3]] , s.settings_with_values.sort_by { |name,value| name.to_s }
+    end
+      
+    verify 'can specify that object should reload from db each time' do
+      s.add :abcd , :default => 1
+      s.add :efgh , :default => 10 , :volatile => true
+      assert_equal 1  , s.abcd
+      assert_equal 10 , s.efgh
+      $sql_executor.silent_execute "update settings set value='#{ARSettings.serialize(2)}' where name='abcd'"
+      $sql_executor.silent_execute "update settings set value='#{ARSettings.serialize(20)}' where name='efgh'"
+      assert_equal 1  , s.abcd
+      assert_equal 20 , s.efgh
+    end
+      
+    verify 'retains postprocessing after a reload' do
+      s.add( :abcd , :default => 1 , :volatile => true ) { |val| val.to_i }
+      assert_equal 1 , s.abcd
+      $sql_executor.silent_execute "update settings set value='#{ARSettings.serialize(2)}' where name='abcd'"
+      assert_equal 2  , s.abcd
+      s.abcd = "3"
+      assert_equal 3 , s.abcd
+    end
+    
+    verify 'readding the setting allows you to update volatility' do
+      s.add( :abcd , :default => "12.5" , :volatile => false ) { |val| val.to_f }
+      assert_equal 12.5 , s.abcd
+      $sql_executor.silent_execute "update settings set value='#{ARSettings.serialize(5.5)}' where name='abcd'"
+      assert_equal 12.5 , s.abcd
+      s.add :abcd , :volatile => true
+      assert_equal 5.5 , s.abcd
+    end
+
+    verify 'postprocessing only occurs when inserting the data' do
+      s.add( :abcd , :default => "12.5" , :volatile => false ) { |val| val.to_f }
+      assert_equal 12.5 , s.abcd
+      s.add( :abcd ) { |val| val.to_i }    
+      assert_equal 12.5 , s.abcd
+    end
+
+    verify 'readding the setting allows you to update postprocessing' do
+      s.add( :abcd , :default => 0 ) { |val| val.to_f }
+      s.abcd = "12.5"
+      assert_equal 12.5 , s.abcd
+      s.add( :abcd ) { |val| val.to_i }
+      s.abcd = "12.5"
+      assert_equal 12 , s.abcd
+    end
+      
+    verify 'defaults get run through the postprocessor' do
+      s.add( :abcd , :default => "5" ) { |i| i.to_i }
+      assert_equal 5 , s.abcd
+    end
+      
+    verify 'raises NoSuchSettingError when invoking nonexistent setting' do
+      assert_raises(ARSettings::NoSuchSettingError) { s.hjk     }
+      assert_raises(ARSettings::NoSuchSettingError) { s.hjk = 1 }
+    end
+    
+    verify 'raises InvalidSetting for settings with over MAX_NAME chars' do
+      assert_nothing_raised { s.add 'a' * s.settings_class.MAX_CHARS      }
+      assert_invalid_name   { s.add 'a' * s.settings_class.MAX_CHARS.next }
+    end
+        
+  end
+
+
+
+
+
+  
+
+  context 'initializations' do
+    
+    s = Setting.package(String)
+    packaged = ARSettings::Packaged
+    
+    verify 'it raises an error if given a package that is not string / symbol / class' do
+      assert_nothing_raised { Setting.package "string" }
+      assert_nothing_raised { Setting.package :Symbol  }
+      assert_nothing_raised { Setting.package Class    }
+      assert_raises(ARSettings::InvalidPackageError) { Setting.package 1 }
+      assert_raises(ARSettings::InvalidPackageError) { Setting.package Object.new }
+      assert_raises(ARSettings::InvalidPackageError) { Setting.package(SomeConstant=Object.new) }
+    end
+    
+    verify 'can add a package as an option' do
+      Setting.add :abcd , :package => Hash , :default => 12
+      assert_equal 12 , Setting.package(Hash).abcd
+      assert_raises(ARSettings::NoSuchSettingError) { Setting.abcd }
+    end
+    
+    verify 'can package settings with classes' do
+      Setting.add :abcd , :package => String , :default => 12
+      assert_equal 12 , s.abcd
+      assert_equal :String , Setting.find( :first , :conditions => { :name => 'abcd' } ).package
+    end
+  
+    verify 'Setting.package(package) returns a PackagedSetting object' do
+      assert_equal ARSettings::Packaged , Setting.package(String).class
+    end
+  
+    verify 'packaged knows its settings class' do
+      assert_equal Setting , Setting.package(String).settings_class
+    end
+  
+    verify 'current_package returns the current package' do
+      assert_equal :String , Setting.package(String).package
+      assert_equal :string , Setting.package('string').package
+      assert_equal :strIng , Setting.package(:strIng).package
+    end
+    
+  
+    verify 'can add and remove variables within a given package' do
+      s.add :abcd , :default => 12
+      assert_equal 12 , s.abcd
+      s.abcd = 5
+      assert_equal 5 , s.abcd
+    end
+  
+    verify 'raises NoSuchSettingError when given incorrect package' do
+      s.add :abcd , :default => 12
+      assert_raises(ARSettings::NoSuchSettingError) { Setting.abcd }
+      assert_raises(ARSettings::NoSuchSettingError) { Setting.abcd = 3 }
+      assert_nothing_raised { s.abcd }
+      assert_nothing_raised { s.abcd = 5 }
+    end
+  
+    verify 'packaged settings can list all settings and values' do
+      s.add :abcd , :default => 1
+      s.add :efgh , :default => 2
+      s.add :ijkl , :default => 3
+      assert_equal [:abcd,:efgh,:ijkl] , s.settings.sort_by { |setting| setting.to_s }
+      assert_equal [[:abcd,1],[:efgh,2],[:ijkl,3]] , s.settings_with_values.sort_by { |setting,value| value }
+    end
+    
+    verify 'reset only applies to settings of a given package' do
+      string = Setting.package(String)
+      hash   = Setting.package(Hash)
+      string.add :abcd , :default => 1
+      hash.add :abcd   , :default => 2
+      string.reset
+      assert_equal 1 , Setting.count
+      assert_equal :Hash , Setting.first.package
+      assert_equal 2 , hash.abcd
+    end
+
+    verify "doesn't raise error for valid options" do
+      assert_nothing_raised do
+        s.add :abcd , :default => 1 , :volatile => true do end
+      end
+    end
+    
+    verify "does raise error if it receives any invalid options" do
+      [ [ :a  ,  :package         ,   String  ],
+        [ :b  ,  :settings_class  ,   Setting ],
+        [ :c  ,  :lkjdsf          ,   true    ],
+        [ :d  ,  :abcd            ,   true    ],
+        [ :e  ,  :instance        ,   true    ],
+      ].each do |meth,key,value|
+        assert_raises ARSettings::InvalidOptionError do
+          s.add meth , key => value
+        end      
+      end
+    end
+
+  end
+  
+  
+end
+

data/test/reset_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/_helper'
+
+class ResetTest < Test::Unit::TestCase
+  
+  def setup
+    Setting.package(String).reset
+    Setting.package(String).add :abc
+  end
+  
+  s = Setting.package(String)
+  
+  verify 'resets respond_to?' do
+    assert s.respond_to?(:abc)
+    assert s.respond_to?(:abc=)
+    s.reset
+    assert !s.respond_to?(:abc)
+    assert !s.respond_to?(:abc=)
+  end
+  
+  verify 'resets method' do
+    assert_nothing_raised { s.abc = 1 }
+    s.reset
+    assert_raises(ARSettings::NoSuchSettingError) { s.abc     }
+    assert_raises(ARSettings::NoSuchSettingError) { s.abc = 2 }
+  end
+  
+  verify 'resets setting?' do
+    assert s.setting?(:abc)
+    s.reset
+    assert !s.setting?(:abc)
+  end
+
+  verify 'resets count' do
+    assert_count 1
+    s.reset
+    assert_count 0
+  end
+  
+  verify 'can reset all packages' do
+    Setting.reset_all
+    Setting.package(String).add :abcd
+    Setting.package(Hash).add :efgh
+    assert_equal 2 , Setting.count
+    Setting.reset_all
+    assert_equal 0 , Setting.count
+  end
+  
+  verify "resetting one settings class' package doesn't impact others" do
+    ARSettings.create_settings_class 'Setting6'
+    Setting6.package(String).add :abc
+    Setting6.package(Hash).add :def
+    Setting.package(:ghi).add :jkl
+    assert_equal 2 , Setting6.count
+    assert_equal 2 , Setting.count
+    Setting.reset_all
+    assert_equal 2 , Setting6.count
+    assert_equal 0 , Setting.count
+    Setting.package(:ghi).add :mno
+    Setting.package(:ghi).add :pqr
+    Setting6.reset_all
+    assert_equal 0 , Setting6.count
+    assert_equal 2 , Setting.count
+  end
+  
+  
+end

data/test/setting_choose_name_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/_helper'
+
+class CanChooseNameOfSettingClass < Test::Unit::TestCase
+  
+  verify 'can choose name of the class to store settings in' do
+    assert_raises(NameError) { DifferentName }
+    ARSettings.create_settings_class 'DifferentName'
+    assert_nothing_raised { DifferentName }
+    assert_equal Class , DifferentName.class
+    assert DifferentName.ancestors.include?(ActiveRecord::Base)
+    assert_nothing_raised { DifferentName.add :abc , :default => 12 }
+    assert_equal 12 , DifferentName.abc
+  end
+    
+end