rapid-core 0.1 → 0.2.1

data/spec/rapid/setting/namespace/instance_spec.rb

@@ -2,11 +2,314 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe Rapid::Setting::Namespace::Instance do
   
-  it "should alias root as _root by default" do
-    obj = mock(:default_empty => true, :scalars => [])
-    @instance = Rapid::Setting::Namespace::Instance.new "hi", obj
-    @instance.root.should == "hi"
-    @instance._root.should == "hi"
+  def root_instance value = {}
+    @namespace = Rapid::Setting::Namespace::Base.new(nil)
+    @parent = nil
+    @instance = Rapid::Setting::Namespace::Instance.new @namespace, @parent, value
+  end
+  
+  def child_instance name, value = {}
+    @namespace = Rapid::Setting::Namespace::Base.new(nil)
+    @child = Rapid::Setting::StringSetting.new(name, :namespace => @namespace)
+    
+    @parent = nil
+    
+    @instance = Rapid::Setting::Namespace::Instance.new @namespace, @parent, value
+  end
+  
+  def grandchild_instance name1, name2, value = {}
+    @namespace = Rapid::Setting::Namespace::Base.new(nil)
+    @child = Rapid::Setting::Namespace::Base.new(name1, :namespace => @namespace)
+    @grandchild = Rapid::Setting::StringSetting.new(name2, :namespace => @child)
+    
+    @parent = nil
+    
+    @instance = Rapid::Setting::Namespace::Instance.new @namespace, @parent, value
+  end
+  
+  it "should know on? and empty" do
+    @instance = root_instance
+    
+    @instance.on?.should be_true
+    @instance.on.should be_true
+    @instance.empty?.should be_true
+  end
+  
+  it "should accept on=" do
+    @instance = root_instance
+    
+    @instance.on?.should == true
+    @instance.on = nil
+    @instance.on?.should == false
+  end
+  
+  it "should turn on when a child setting is set" do
+    @instance = grandchild_instance 'foo', 'bar'
+    @instance['foo'].on?.should == false
+    
+    @instance['foo.bar'] = 'hi'
+    
+    @instance['foo'].on?.should == true
+  end
+  
+  it "should expose namespaces and scalars" do
+    @instance = child_instance 'foo'
+    @instance['foo'] = "hi"
+    
+    @instance.namespaces.should == []
+    @instance.scalars.should == ["hi"]
+  end
+  
+  it "should know its parent" do
+    @instance = child_instance 'foo'
+    @instance.send(:_parent).should == nil
+  end
+  
+  describe "[]" do
+    
+    it "should not find child if the setting does not exist" do
+      @instance = root_instance 'foo' => 'bar'
+      @instance['foo'].should == nil
+    end
+    
+    it "should try a manually implemented method if the setting does not exist" do
+      @instance = root_instance 'freeze' => 'hi'
+      @instance.freeze.should == @instance
+      @instance['freeze'].should == @instance
+    end
+    
+    it "should not find the grandchild if the setting does not exist" do
+      @instance = root_instance 'foo' => {'bar' => 'nuts'}
+      @instance['foo.bar'].should == nil
+    end
+    
+    it "should get the setting when it exists even if there's an implemented method" do
+      @instance = child_instance 'freeze', 'freeze' => 'hi'
+      @instance['freeze'].should == 'hi'
+    end
+    
+    it "should find child" do
+      @instance = child_instance 'foo', 'foo' => 'bar'
+      @instance['foo'].should == 'bar'
+    end
+    
+    it "should find the grandchild if the settings exist" do
+      @instance = grandchild_instance 'foo', 'bar', 'foo' => {'bar' => 'nuts'}
+      @instance['foo.bar'].should == 'nuts'
+    end
+    
+    it "should not find a value that's not there" do
+      @instance = root_instance
+      @instance['foo.bar'].should == nil
+      @instance['foo'].should == nil
+    end
+    
+  end
+  
+  describe "[]=" do
+    
+    describe "child settings" do
+      
+      it "should set the setting" do
+        @instance = child_instance 'foo'
+        @instance['foo'].should == nil
+        @instance['foo'] = 'bar'
+        @instance['foo'].should == 'bar'
+      end
+      
+      it "should remember an assignment error when the setting does not exist" do
+        @instance = root_instance
+        @instance['foo'] = 'bar'
+        @instance.valid?.should be_false
+        @instance.errors['foo'].should == ["can't be found"]
+      end
+      
+      it "should try a manually implemented method if the setting does not exist" do
+        @instance = root_instance
+        @instance['taguri'] = "5"
+        @instance.taguri.should == "5"
+      end
+      
+      it "should not try the manually implemented method if the setting exists" do
+        @instance = child_instance 'taguri'
+        @instance.should_not_receive(:taguri=)
+        
+        @instance['taguri'] = 'bar'
+        @instance['taguri'].should == 'bar'
+      end
+      
+      it "should accept values for a child namespace" do
+        @instance = grandchild_instance 'foo', 'bar'
+        @instance['foo'] = {'bar' => 'hi'}
+        @instance['foo.bar'].should == 'hi'
+      end
+      
+    end
+    
+    describe "child namespaces" do
+      
+      it "should set a child namespace" do
+        @instance = grandchild_instance 'foo', 'bar'
+        @instance['foo.bar'] = 'nuts'
+        @instance.valid?.should == true
+        @instance.errors['foo.bar'].should == []
+      end
+      
+      it "should recognize a bad value for a child namespace" do
+        @instance = child_instance 'foo'
+        @instance['foo.bar'] = 'nuts'
+        @instance.valid?.should == false
+        @instance.errors['foo.bar'].should == ["doesn't allow values of that type"]
+      end
+      
+      it "should recognize an non-existing child namespace" do
+        @instance = root_instance
+        @instance['foo.bar'] = 'hi'
+        @instance.valid?.should == false
+        @instance.errors['foo.bar'].should == ["can't be found"]
+      end
+      
+      it "should reload a child namespace without overriding existing values" do
+        @namespace = Rapid::Setting::Namespace::Base.new(nil)
+        @child = Rapid::Setting::Namespace::Base.new('foo', :namespace => @namespace)
+        @grandchild = Rapid::Setting::Namespace::Base.new('bar', :namespace => @child)
+        @string = Rapid::Setting::StringSetting.new('nuts', :namespace => @grandchild)
+        @string = Rapid::Setting::StringSetting.new('squirrel', :namespace => @grandchild)
+        
+        @parent = nil
+        
+        @instance = Rapid::Setting::Namespace::Instance.new @namespace, @parent, {}
+        
+        @instance['foo.bar.nuts'].should == nil
+        @instance['foo.bar.squirrel'].should == nil
+        
+        @instance['foo.bar.nuts'] = 'hi'
+        @instance['foo.bar.squirrel'] = 'Alvin'
+        
+        @instance['foo.bar.nuts'].should == 'hi'
+        @instance['foo.bar.squirrel'].should == 'Alvin'
+        
+        @instance['foo'] = {'bar' => {'nuts' => 'hey'}}
+        
+        @instance['foo.bar.nuts'].should == 'hey'
+        @instance['foo.bar.squirrel'].should == 'Alvin'
+      end
+      
+    end
+    
+  end
+  
+  describe "values" do
+    
+    before do
+      @namespace = Rapid::Setting::Namespace::Base.new(nil)
+      @parent = nil
+    end
+    
+    def load value
+      @instance = Rapid::Setting::Namespace::Instance.new @namespace, @parent, value
+    end
+    
+    it "should accept false" do
+      load false
+      
+      @instance.on?.should == false
+      @instance.empty?.should == true
+    end
+    
+    it "should accept nil" do
+      load nil
+      
+      @instance.on?.should == false
+      @instance.empty?.should == true
+    end
+    
+    it "should accept true" do
+      load true
+      
+      @instance.on?.should == true
+      @instance.empty?.should == true
+    end
+    
+    it "should accept {}" do
+      load({})
+      
+      @instance.on?.should == true
+      @instance.empty?.should == true
+    end
+    
+    it "should accept {...}" do
+      load :foo => 'hi'
+      
+      @instance.on?.should == true
+      @instance.empty?.should == false
+    end
+    
+    it "should not accept integers" do
+      lambda { load(3) }.should raise_error(Rapid::InvalidSettingError)
+    end
+    
+    it "should not accept []" do
+      lambda { load([]) }.should raise_error(Rapid::InvalidSettingError)
+    end
+    
+  end
+  
+  describe "defaults" do
+    
+    def child_instance name, value = {}
+      @namespace = Rapid::Setting::Namespace::Base.new(nil)
+      @child = Rapid::Setting::StringSetting.new(name, :namespace => @namespace, :default => 'hi')
+      
+      @parent = nil
+      
+      @instance = Rapid::Setting::Namespace::Instance.new @namespace, @parent, value
+    end
+    
+    it "should use setting defaults" do
+      @instance = child_instance 'foo'
+      @instance['foo'].should == 'hi'
+    end
+    
+  end
+  
+  describe "to_hash" do
+    
+    it "should drop blank namespaces" do
+      @instance = grandchild_instance 'foo', 'bar'
+      @instance.to_hash.should == {}
+      
+      @instance = grandchild_instance 'foo', 'bar', 'foo' => {}
+      @instance.to_hash.should == {}
+    end
+    
+    it "should not drop namespaces with values" do
+      @instance = grandchild_instance 'foo', 'bar', 'foo' => {'bar' => 'hi'}
+      @instance.to_hash.should == {'foo' => {'bar' => 'hi'}}
+    end
+    
+  end
+  
+  describe "set?" do
+    
+    it "should be true when child setting is set" do
+      @instance = child_instance 'foo'
+      
+      @instance.set?('foo').should == false
+      @instance['foo'] = 'hi'
+      @instance.set?('foo').should == true
+    end
+    
+    it "should be true when grandchild setting is set" do
+      @instance = grandchild_instance 'foo', 'bar'
+      
+      @instance.set?('foo.bar').should == false
+      @instance.set?('foo').should == false
+      @instance['foo.bar'] = 'hi'
+      @instance.set?('foo.bar').should == true
+      @instance.set?('foo').should == true
+    end
+    
   end
   
 end

data/spec/rapid/setting/string_setting_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rapid::Setting::StringSetting do
+  
+  describe "load" do
+    
+    before do
+      @setting = Rapid::Setting::StringSetting.new("foo")
+    end
+    
+    it "should know nil is nil" do
+      @setting.load(nil).should == nil
+    end
+    
+    it "should know false as nil" do
+      @setting.load(false).should == nil
+    end
+    
+    it "should know strings" do
+      @setting.load("hi").should == "hi"
+      @setting.load("false").should == "false"
+      @setting.load(true).should == "true"
+    end
+    
+    it "should know integers" do
+      @setting.load(3).should == "3"
+    end
+    
+    it "should know floats" do
+      @setting.load(3.5).should == "3.5"
+    end
+    
+    it "should not know arrays" do
+      lambda { @setting.load([]) }.should raise_error(Rapid::InvalidSettingError)
+    end
+    
+    it "should not know hashes" do
+      lambda { @setting.load({}) }.should raise_error(Rapid::InvalidSettingError)
+    end
+    
+  end
+  
+end

data/spec/rapid/settings_spec.rb

@@ -8,6 +8,7 @@ describe Rapid::Settings do
         include Rapid::Settings
         
         setting.string 'foo'
+        attr_accessor :nuts
       end
     end
     
@@ -18,34 +19,81 @@ describe Rapid::Settings do
     Object.send(:remove_const, :MyClass) rescue nil
   end
   
-  describe "extract_nested_namespace" do
+  it "should expose the setting's bindings by default" do
+    @instance.get_binding.should_not be_nil
+  end
+  
+  describe "class settings" do
     
-    it "should return the namespace and rest" do
-      Rapid::Settings.extract_nested_namespace("foo.bar").should == ["foo", "bar"]
+    it "should expose the class settings" do
+      MyClass.settings['foo'].class.should == Rapid::Setting::StringSetting
     end
     
-    it "should return nil and original when not namespaced" do
-      Rapid::Settings.extract_nested_namespace("foo").should == [nil, "foo"]
+  end
+  
+  describe "array-like properties" do
+    
+    it "should work with settings" do
+      @instance['foo'] = 'hi'
+      @instance['foo'].should == 'hi'
+      @instance.foo.should == 'hi'
     end
     
-    it "should handle nil" do
-      Rapid::Settings.extract_nested_namespace(nil).should == [nil, nil]
+    it "should handle accessors" do
+      @instance['nuts'] = 5
+      @instance['nuts'].should == 5
     end
     
-    it "should handle a symbol" do
-      Rapid::Settings.extract_nested_namespace(:foo).should == [nil, 'foo']
+    it "should not break when accessing unknown settings" do
+      @instance['boo.foo'].should == nil
+    end
+    
+    it "should not be valid after assigning an invalid setting" do
+      @instance.valid?.should be_true
+      
+      @instance['bar'] = 4
+      
+      @instance['bar'].should == nil
+      @instance.valid?.should be_false
+      @instance.errors['bar'].should == ["can't be found"]
+    end
+    
+    it "should not be valid after assigning an invalid child setting" do
+      @instance.valid?.should be_true
+      
+      @instance['nuts.squirrel'] = 'hi'
+      
+      @instance.valid?.should be_false
+      @instance.errors['nuts.squirrel'].should == ["can't be found"]
+    end
+    
+    it "should not be valid after assigning an invalid value to an existing setting" do
+      @instance['foo.bar'] = 4
+      @instance.valid?.should be_false
+      @instance.errors['foo.bar'].should == ["doesn't allow values of that type"]
     end
     
   end
   
-  it "should expose the setting's bindings by default" do
-    @instance.get_binding.should_not be_nil
-  end
-  
-  it "should provide array-like access" do
-    @instance['foo'] = 'hi'
-    @instance['foo'].should == 'hi'
-    @instance.foo.should == 'hi'
+  describe "nested validations" do
+    
+    before do
+      @definer = MyClass.send(:setting)
+    end
+    
+    it "should validate presence if a child setting is present" do
+      @definer.integer "app.emails.smtp.port"
+      @definer.string "app.name"
+      
+      MyClass.validates_presence_of "app.emails.smtp.port", :if => '_root.app.name'
+      
+      MyClass.new.valid?.should == true
+      @instance = MyClass.new
+      @instance.settings = {'app.name' => 'hi'}
+      @instance.valid?.should == false
+      @instance.errors['app.emails.smtp.port'].should == ["can't be blank"]
+    end
+    
   end
   
 end