configure_me 0.5.0 → 0.6.0

data/spec/configure_me/base_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe ConfigureMe do
-  it { should respond_to(:init) }
-  it { should respond_to(:persistence_klass) }
-  it { should respond_to(:cache_object) }
-  it 'should provide nil defaults for :init' do
-    ConfigureMe.init
-    ConfigureMe.persistence_klass.should be_nil
-    ConfigureMe.cache_object.should be_nil
-  end
-
-  it 'should accept a hash of initialization arguments' do
-    ConfigureMe.init(:persist_with => 'foo', :cache_with => 'bar')
-    ConfigureMe.persistence_klass.should eql('foo')
-    ConfigureMe.cache_object.should eql('bar')
-  end
-end
-
-describe ConfigureMe::Base do
-  it 'should enforce the singleton pattern' do
-    lambda { ConfigureMe::Base.new }.should raise_error(NoMethodError)
-  end
-
-  class BaseConfig < ConfigureMe::Base
-    setting :setting1, :type => :integer, :default => 12
-  end
-
-  subject { BaseConfig.instance }
-  its(:persisted?) { should be_true }
-  its(:class) { should respond_to(:setting1) }
-
-  describe 'ActiveModel compliance' do
-    before { @config = define_test_class('TestConfig', ConfigureMe::Base).instance }
-    subject { @config }
-    it_should_behave_like "ActiveModel"
-  end
-
-  describe 'find_by_id' do
-    subject { ConfigureMe::Base }
-    before {
-      @mock_config = mock('Config') do
-        stubs(:config_key).returns('the-right-one')
-        stubs(:instance).returns('instance')
-      end
-      @configs = [@mock_config]
-    }
-    it 'should return nil for an invalid id' do
-      subject.stubs(:configs).returns([])
-      subject.find_by_id('something').should be_nil
-    end
-
-    it 'should return a matching config' do
-      subject.stubs(:configs).returns(@configs)
-      subject.find_by_id('the-right-one').should eql('instance')
-    end
-  end
-end

data/spec/configure_me/caching_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-describe ConfigureMe::Caching, 'the class' do
-  subject { ConfigureMe::Base }
-  it { should respond_to(:cache_me) }
-  it { should respond_to(:caching?) }
-end
-
-describe ConfigureMe::Caching, 'caching?' do
-  before {
-    @caching_class = define_test_class('CachingConfig', ConfigureMe::Base)
-    @caching_class.send(:cache_me)
-  }
-  subject { @caching_class }
-
-  context 'when cache_object is available' do
-    before { ConfigureMe.stubs(:cache_object).returns({}) }
-    specify { subject.caching?.should be_true }
-  end
-
-  context 'when cache_object is unavailable' do
-    before { ConfigureMe.stubs(:cache_object).returns(nil) }
-    specify { subject.caching?.should be_false }
-  end
-
-end
-
-describe ConfigureMe::Caching, 'when caching is enabled' do
-  before {
-    @caching_class = define_test_class('CachingConfig', ConfigureMe::Base)
-    @caching_class.stubs(:caching?).returns(true)
-    @cache_object = mock('CacheObject') do
-      stubs(:read).returns('cached_value')
-      stubs(:write)
-    end
-    ConfigureMe.stubs(:cache_object).returns(@cache_object)
-  }
-  subject { @caching_class.instance }
-
-  it 'should attempt to read from the cache' do
-    ConfigureMe.expects(:cache_object).once.returns(@cache_object)
-    subject.read_cache('cachedsetting')
-  end
-
-  it 'should return the value from the cache' do
-    subject.read_cache('cachedsetting').should eql('cached_value')
-  end
-
-  it 'should attempt to write to the cache' do
-    @cache_object.expects(:write).once
-    subject.write_cache('cachedsetting', 'newvalue')
-  end
-end
-
-describe ConfigureMe::Caching, 'when caching is disabled' do
-  before {
-    @caching_class = define_test_class('CachingConfig', ConfigureMe::Base)
-    @caching_class.stubs(:caching?).returns(false)
-  }
-  subject { @caching_class.instance }
-
-  it 'should not attempt to read from the cache' do
-    ConfigureMe.expects(:cache_object).never
-    subject.read_cache('cachedsetting')
-  end
-
-  it 'should return nil when read_cache is called' do
-    subject.read_cache('cachedsetting').should be_nil
-  end
-
-  it 'should not attempt to write to the cache' do
-    ConfigureMe.expects(:cache_object).never
-    subject.write_cache('cachedsetting', 'newvalue')
-  end
-end

data/spec/configure_me/identity_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe ConfigureMe::Identity do
-  before {
-    @parent_class = define_test_class('ParentConfig', ConfigureMe::Base)
-    @nested_class = define_test_class('NestedConfig', ConfigureMe::Base)
-  }
-
-  context 'a root class' do
-    subject { @parent_class.instance }
-    it { should respond_to(:config_key) }
-    it { should respond_to(:config_name) }
-    it { should respond_to(:storage_key) }
-    its(:config_name) { should eql('parent') }
-    its(:config_key) { should eql('parent') }
-    it 'should generate a valid storage key' do
-      subject.storage_key('foo').should eql('parent-foo')
-    end
-  end
-
-  context 'a nested class' do
-    before { @nested_class.send(:nest_me, @parent_class) }
-    subject { @nested_class.instance }
-    its(:config_name) { should eql('nested') }
-    its(:config_key) { should eql('parent-nested') }
-    it 'should generate a valid storage key' do
-      subject.storage_key('foo').should eql('parent-nested-foo')
-    end
-  end
-end

data/spec/configure_me/loading_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe ConfigureMe::Loading, 'a filename' do
-  subject { ConfigureMe::Base }
-  it 'should raise an error for a non-existent file' do
-    lambda { subject.load('foo') }.should raise_error(ArgumentError)
-  end
-
-  it 'should load an existing file' do
-    File.stubs(:exists?).returns(true)
-    File.stubs(:open).returns({:foo => 'bar'}.to_yaml)
-    subject.expects(:from_hash)
-    subject.load('avalidfile')
-  end
-end
-
-describe ConfigureMe::Loading, 'a hash' do
-  subject { ConfigureMe::Base }
-
-  context 'with :app => {:setting1 => \'foo\', :setting2 => 845}' do
-    before { @config = ConfigureMe::Base.load(:app => {:setting1 => 'foo', :setting2 => 845}) }
-    subject { @config.instance }
-    its(:config_name) { should eql('app') }
-
-    it { should respond_to(:setting1) }
-    it { should respond_to(:setting2) }
-    it { should_not respond_to(:setting3) }
-    its(:setting1) { should eql('foo') }
-    its(:setting2) { should eql(845) }
-    its(:parent_config) { should be_nil }
-  end
-
-  context 'with :group1 => {:setting1 => 6, :setting2 => \'foo\'}, :group2 => {:setting3 => 8, :setting4 => \'bar\'}' do
-    describe 'the instance' do
-      before {
-        @config = ConfigureMe::Base.load(
-          :group1 => {
-            :setting1 => 6,
-            :setting2 => 'foo'
-          },
-          :group2 => {
-            :setting3 => 8,
-            :setting4 => 'bar'
-          }
-        )
-      }
-
-      subject { @config.instance }
-      its(:config_name) { should eql('root') }
-      it { should respond_to(:group1) }
-      it { should respond_to(:group2) }
-      it { should_not respond_to(:group3) }
-
-      describe 'group1' do
-        subject { @config.group1 }
-        it { should_not be_nil }
-        it { should respond_to(:setting1) }
-        it { should respond_to(:setting2) }
-        it { should_not respond_to(:setting3) }
-        its(:setting1) { should eql(6) }
-        its(:setting2) { should eql('foo') }
-        its(:parent_config) { should eql(@config.instance) }
-      end
-
-      describe 'group2' do
-        subject { @config.instance.group2 }
-        it { should_not be_nil }
-        it { should respond_to(:setting3) }
-        it { should respond_to(:setting4) }
-        it { should_not respond_to(:setting1) }
-        its(:setting3) { should eql(8) }
-        its(:setting4) { should eql('bar') }
-        its(:parent_config) { should eql(@config.instance) }
-      end
-    end
-  end
-end
-
-describe ConfigureMe::Loading, 'something unsupported' do
-  subject { ConfigureMe::Base }
-  it 'should raise an exception' do
-    lambda { subject.load(123) }.should raise_error(ArgumentError)
-  end
-end

data/spec/configure_me/naming_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe ConfigureMe::Naming do
-  class NamingConfig < ConfigureMe::Base
-  end
-
-  before {
-    @persistence_klass = mock('PersistenceKlass') do
-      stubs(:model_name).returns('persistence')
-    end
-    ConfigureMe.stubs(:persistence_klass).returns(@persistence_klass)
-  }
-  subject { NamingConfig }
-  context 'when persisting' do
-    before { NamingConfig.stubs(:persisting?).returns(true) }
-    its(:model_name) { should eql('persistence') }
-  end
-
-  context 'when not persisting' do
-    before { NamingConfig.stubs(:persisting?).returns(false) }
-    its(:model_name) { should_not eql('persistence') }
-  end
-end

data/spec/configure_me/nesting_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe ConfigureMe::Nesting, 'the class' do
-  subject { ConfigureMe::Base }
-  it { should respond_to(:nest_me) }
-end
-
-describe ConfigureMe::Nesting do
-  before {
-    @parent_class = define_test_class('ParentConfig', ConfigureMe::Base)
-    @nested_class = define_test_class('NestedConfig', ConfigureMe::Base)
-    @parent_config = @parent_class.instance
-    @nested_config = @nested_class.instance
-    @parent_class.stubs(:instance).returns(@parent_config)
-    @nested_class.stubs(:instance).returns(@nested_config)
-    @nested_class.send(:nest_me, @parent_class)
-  }
-
-  context 'a nested class' do
-    subject { @nested_config }
-    its(:children) { should be_empty }
-    its(:all_configs) { should have(1).items }
-    its(:parent_config) { should eql(@parent_config) }
-  end
-
-  context 'a parent class' do
-    subject { @parent_config }
-    its(:children) { should have(1).items }
-    its(:children) { should eql(:nested => @nested_config) }
-    its(:all_configs) { should have(2).items }
-    its(:parent_config) { should be_nil }
-    it { should respond_to(:nested) }
-    its(:nested) { should eql(@nested_config) }
-    its(:class) { should respond_to(:nested) }
-  end
-end

data/spec/configure_me/persistence_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe ConfigureMe::Persistence do
-  before {
-    @persistence_class = define_test_class('PersistenceConfig', ConfigureMe::Base)
-    @config = @persistence_class.instance
-  }
-  subject { @config }
-  describe 'saving' do
-    before {
-      @config.stubs(:write_persist)
-      @config.stubs(:write_cache)
-      @config.stubs(:make_clean)
-      @temp_attrs = {:testsetting => 'newvalue'}
-      @config.stubs(:temp_attributes).returns(@temp_attrs)
-      @config.stubs(:persist_guard).yields
-    }
-    it 'should run callbacks' do
-      @config.expects(:run_callbacks).at_least_once.yields
-      @config.save
-    end
-    it 'should not run the validations if :validate => false is passed' do
-      @config.expects(:valid?).never
-      @config.save(:validate => false)
-    end
-    it 'should start a transaction' do
-      @config.expects(:persist_guard)
-      @config.save
-    end
-
-    it 'should persist the temp settings' do
-      @config.expects(:write_persist).with(:testsetting, 'newvalue')
-      @config.save
-    end
-
-    it 'should cache the temp settings' do
-      @config.expects(:write_cache).with(:testsetting, 'newvalue')
-      @config.save
-    end
-
-    it 'should clear the dirty status' do
-      @config.expects(:make_clean)
-      @config.save
-    end
-  end
-
-  describe 'update_attributes' do
-    before {
-      @config.stubs(:write_attribute)
-    }
-    it 'should store the new attributes' do
-      @config.stubs(:save)
-      @config.expects(:write_attribute).with(:testsetting, 'updatedvalue')
-      @config.update_attributes(:testsetting => 'updatedvalue')
-    end
-
-    it 'should attempt to save' do
-      @config.expects(:save)
-      @config.update_attributes(:testsetting => 'updatedvalue')
-    end
-  end
-end

data/spec/configure_me/persisting_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-
-describe ConfigureMe::Persisting, 'the class' do
-  subject { ConfigureMe::Base }
-  it { should respond_to(:persist_me) }
-  it { should respond_to(:persisting?) }
-
-  context 'when the persistence_klass is nil' do
-    before {
-      @persisting_klass = define_test_class('PersistingConfig', ConfigureMe::Base)
-      @persisting_klass.send(:persist_me)
-      ConfigureMe.stubs(:persistence_klass).returns(nil)
-    }
-    subject { @persisting_klass }
-    its(:persisting?) { should be_false }
-  end
-
-  describe 'persist_guard' do
-    before {
-      @persisting_klass = define_test_class('PersistingConfig', ConfigureMe::Base)
-    }
-    subject { @persisting_klass.instance }
-    context 'when transactions are supported' do
-      it 'should begin a transaction' do
-        @transaction_class = mock('TransactionClass') do
-          stubs(:transaction)
-        end
-        ConfigureMe.stubs(:persistence_klass).returns(@transaction_class)
-        @transaction_class.expects(:transaction)
-        subject.persist_guard
-      end
-    end
-
-    context 'when persisting with something else' do
-      it 'should just execute the block' do
-        @non_transaction_class = mock('NonTransactionClass')
-        ConfigureMe.stubs(:persistence_klass).returns(@non_transaction_class)
-        @testvalue = 'default'
-        subject.persist_guard do
-          @testvalue = 'changed'
-        end
-        @testvalue.should eql('changed')
-      end
-    end
-  end
-end
-
-describe ConfigureMe::Persisting, 'when persisting is enabled' do
-  before {
-    @persisting_class = define_test_class('PersistingConfig', ConfigureMe::Base)
-    @persisted_setting = mock('PersistedSetting') do
-      stubs(:value).returns('foo'.to_yaml)
-      stubs(:value=)
-      stubs(:save!)
-    end
-    @persistence_klass = mock('PersistenceKlass')
-    @persistence_klass.stubs(:find_or_create_by_key).returns(@persisted_setting)
-    @persistence_klass.stubs(:find_by_key).returns(@persisted_setting)
-    ConfigureMe.stubs(:persistence_klass).returns(@persistence_klass)
-    @persisting_class.send(:persist_me)
-  }
-  subject { @persisting_class.instance }
-
-  describe 'read_persist' do
-    it 'should read from the persistence store' do
-      @persistence_klass.expects(:find_by_key).once.returns(@persisted_setting)
-      subject.read_persist('persistedsetting')
-    end
-
-    context 'with a persisted value' do
-      it 'should return the converted value' do
-        subject.read_persist('persistedsetting').should eql('foo')
-      end
-    end
-
-    context 'with a non-persisted value' do
-      it 'should return nil' do
-        @persistence_klass.stubs(:find_by_key).returns(nil)
-        subject.read_persist('persistedsetting').should be_nil
-      end
-    end
-  end
-
-  describe 'write_persist' do
-    it 'should retrieve or create the setting' do
-      @persistence_klass.expects(:find_or_create_by_key).once.returns(@persisted_setting)
-      subject.write_persist('persistedsetting', 'newvalue')
-    end
-    it 'should update the value' do
-      @persisted_setting.expects(:value=).with('newvalue'.to_yaml)
-      subject.write_persist('persistedsetting', 'newvalue')
-    end
-    it 'should save the record' do
-      @persisted_setting.expects(:save!)
-      subject.write_persist('persistedsetting', 'newvalue')
-    end
-  end
-end
-
-describe ConfigureMe::Persisting, 'when persisting is disabled' do
-  before {
-    @persisting_class = define_test_class('PersistingConfig', ConfigureMe::Base)
-    @persisting_class.stubs(:persisting?).returns(false)
-  }
-  subject { @persisting_class.instance }
-
-  describe 'read_persist' do
-    it 'should not attempt to read from the persistence store' do
-      ConfigureMe.expects(:persistence_klass).never
-      subject.read_persist('persistedsetting')
-    end
-    it 'should return nil' do
-      subject.read_persist('persistedsetting').should be_nil
-    end
-  end
-
-  describe 'write_persist' do
-    it 'should not attempt to write to the persistence store' do
-      ConfigureMe.expects(:persistence_klass).never
-      subject.write_persist('persistedsetting', 'newvalue')
-    end
-  end
-end