ns-options 0.1.1 → 0.2.0

data/test/unit/ns-options/helper/advisor_test.rb

@@ -0,0 +1,144 @@
+require 'assert'
+
+class NsOptions::Helper::Advisor
+
+  module Output
+    module_function
+
+    def capture
+      out = StringIO.new
+      $stdout = out
+      yield
+      return out
+    ensure
+      $stdout = STDOUT
+    end
+  end
+
+  class BaseTest < Assert::Context
+    desc "NsOptions::Helper::Advisor"
+    setup do
+      @namespace = NsOptions::Namespace.new("something")
+      @advisor = NsOptions::Helper::Advisor.new(@namespace)
+    end
+    subject{ @advisor }
+
+    should have_accessors :namespace
+    should have_instance_methods :is_this_ok?, :is_this_option_ok?, :is_this_namespace_ok?,
+      :is_already_defined?, :bad_methods, :not_recommended_methods, :bad_method_message,
+      :duplicate_message, :not_recommended_method_message
+
+    should "return methods that cannot be overwritten with a call to #bad_methods" do
+      expected = [ :define, :namespace, :option, :options ].map(&:to_s).sort
+      assert_equal(expected, subject.bad_methods.map(&:to_s).sort)
+    end
+    should "return methods that shouldn't be overwritten with a call to #not_recommended_methods" do
+      expected = NsOptions::Namespace.instance_methods(false).map(&:to_sym)
+      assert_equal(expected, subject.not_recommended_methods)
+    end
+    should "return if an option/namespace is defined with a call to #is_already_defined?" do
+      assert_equal false, subject.is_already_defined?(:first)
+    end
+  end
+
+  class BadOptionTest < BaseTest
+    desc "with a bad option"
+    setup do
+      begin
+        @advisor.is_this_option_ok?("namespace")
+      rescue Exception => @exception
+      end
+    end
+
+    should "raise an exception when an option matches one of the bad methods" do
+      assert_kind_of NsOptions::Errors::InvalidName, @exception
+      expected = subject.bad_method_message("option", "namespace")
+      assert_equal expected, @exception.message
+    end
+  end
+
+  class DuplicateOptionTest < BaseTest
+    desc "with a duplicate option"
+    setup do
+      @namespace.option(:duplicate)
+      @output = Output.capture do
+        @advisor.is_this_option_ok?("duplicate")
+      end
+    end
+
+    should "output a message warning that they are re-defining an option" do
+      expected = subject.duplicate_message("duplicate")
+      assert_match expected, @output.string
+      assert_match "From: ", @output.string
+    end
+    should "return true with a call to #is_already_defined?" do
+      assert_equal true, subject.is_already_defined?(:duplicate)
+    end
+  end
+
+  class NotRecommendedOptionTest < BaseTest
+    desc "with a not recommended option"
+    setup do
+      @output = Output.capture do
+        @advisor.is_this_option_ok?("apply")
+      end
+    end
+
+    should "output a message warning using the method name as an option name" do
+      expected = subject.not_recommended_method_message("option", "apply")
+      assert_match expected, @output.string
+      assert_match "From: ", @output.string
+    end
+  end
+
+  class BadNamespaceTest < BaseTest
+    desc "with a bad namespace"
+    setup do
+      begin
+        @advisor.is_this_namespace_ok?("options")
+      rescue Exception => @exception
+      end
+    end
+
+    should "raise an exception when a namespace matches one of the bad methods" do
+      assert_kind_of NsOptions::Errors::InvalidName, @exception
+      expected = subject.bad_method_message("sub-namespace", "options")
+      assert_equal expected, @exception.message
+    end
+  end
+
+  class DuplicateNamespaceTest < BaseTest
+    desc "with a duplicate namespace"
+    setup do
+      @namespace.namespace(:duplicate)
+      @output = Output.capture do
+        @advisor.is_this_namespace_ok?("duplicate")
+      end
+    end
+
+    should "output a message warning that they are re-defining a namespace" do
+      expected = subject.duplicate_message("duplicate")
+      assert_match expected, @output.string
+      assert_match "From: ", @output.string
+    end
+    should "return true with a call to #is_already_defined?" do
+      assert_equal true, subject.is_already_defined?(:duplicate)
+    end
+  end
+
+  class NotRecommendedNamespaceTest < BaseTest
+    desc "with a not recommended namespace"
+    setup do
+      @output = Output.capture do
+        @advisor.is_this_namespace_ok?("apply")
+      end
+    end
+
+    should "output a message warning using the method name as a namespace name" do
+      expected = subject.not_recommended_method_message("sub-namespace", "apply")
+      assert_match expected, @output.string
+      assert_match "From: ", @output.string
+    end
+  end
+
+end

data/test/unit/ns-options/helper_test.rb

@@ -9,54 +9,43 @@ module NsOptions::Helper
     end
     subject{ @module }
 
-    should have_instance_methods :new_namespace, :new_child_namespace, :fetch_and_define_option
-
+    should have_instance_methods :find_and_define_namespace, :find_and_define_option,
+      :define_namespace_methods, :define_option_methods, :advisor
+      
+    should "return an instance of NsOptions::Helper::Advisor with a call to #advisor" do
+      advisor = subject.advisor(NsOptions::Namespace.new("something"))
+      assert_instance_of NsOptions::Helper::Advisor, advisor
+    end
   end
-
-  class NewNamespaceTest < BaseTest
-    desc "new_namespace method"
+  
+  class FindAndDefineOptionTest < BaseTest
+    desc "find_and_define_option method"
     setup do
-      @parent = @module.new_namespace("parent")
-      @child = @module.new_namespace("child", @parent) do
-        option :something
-      end
+      @namespace = NsOptions::Namespace.new("something")
+      @option = @namespace.options.add(:anything)
+      @result = @module.find_and_define_option(@namespace, @option.name)
     end
-
-    should "have created a parent namespace" do
-      assert_equal "parent", @parent.options.key
-    end
-    should "have created a child namespace" do
-      assert_equal "child", @child.options.key
-      assert_equal @parent, @child.options.parent
-      assert @child.options[:something]
+    subject{ @namespace }
+    
+    should "have defined reader/writer methods for the option and returned the option" do
+      assert_respond_to @option.name, subject
+      assert_respond_to "#{@option.name}=", subject
+      assert_equal @option, @result
     end
-  end
+  end 
   
-  class NewChildNamespaceTest < BaseTest
-    desc "new_child_namespace method"
+  class FindAndDefineNamespaceTest < BaseTest
+    desc "find_and_define_namespace method"
     setup do
-      @parent = @module.new_namespace("parent")
-      @mock_class = mock()
-      @mock_class.stubs(:super_settings).returns(@parent)
-      @first_owner = mock()
-      @first_owner.stubs({ :class => @mock_class })
-      @first = @module.new_child_namespace(@first_owner, "super_settings") do
-        option :something
-      end
-      @second_owner = User.new
-      @second = @module.new_child_namespace(@second_owner, "preferences")
+      @namespace = NsOptions::Namespace.new("something")
+      @namespace.options.add_namespace(:else, "something:else")
+      @result = @module.find_and_define_namespace(@namespace, :else)
     end
+    subject{ @namespace }
     
-    should "have created a child namespace" do
-      class_name = @mock_class.to_s.split('::').last.downcase
-      key = "#{@parent.options.key}:#{class_name}_#{@first_owner.object_id}"
-      assert_equal key, @first.options.key
-      assert_equal @parent, @first.options.parent
-      assert @first.options[:something]
-    end    
-    should "have created a second child namespace" do
-      key = "#{@second.options.parent.options.key}:#{@second_owner.preferences_key}"
-      assert_equal key, @second.options.key
+    should "have defined reader method for the namespace and returned the namespace" do
+      assert_respond_to :else, subject
+      assert_equal subject.options.get_namespace(:else), @result
     end
   end
 

data/test/unit/ns-options/namespace_test.rb

@@ -5,33 +5,43 @@ class NsOptions::Namespace
   class BaseTest < Assert::Context
     desc "NsOptions::Namespace"
     setup do
-      @key = "options"
+      @key = "something"
       @namespace = NsOptions::Namespace.new(@key)
     end
     subject{ @namespace }
 
     should have_accessors :metaclass, :options
-    should have_instance_methods :option, :namespace, :required_set?, :define
+    should have_instance_methods :option, :namespace, :required_set?, :define, :apply, :valid?
+    should have_instance_methods :to_hash, :each
 
     should "have set it's metaclass accessor" do
       assert subject.metaclass
     end
+
     should "have created a new options collection and set it's options accessor" do
       assert subject.options
       assert_kind_of NsOptions::Options, subject.options
       assert_equal @key, subject.options.key
       assert_nil subject.options.parent
     end
+
+    should "contain its options key in its inspect output" do
+      assert_included ":#{subject.options.key}", subject.inspect
+    end
+
   end
 
   class OptionTest < BaseTest
     desc "option method"
     setup do
       @name = :something
-      @type = NsOptions::Option::Boolean
+      @type = String
       @rules = { :default => true }
       @namespace.option(@name, @type, @rules)
     end
+    teardown do
+      NsOptions::Helper.unstub(:advisor)
+    end
     subject{ @namespace }
 
     should "have added the option to the namespace's options collection" do
@@ -40,6 +50,15 @@ class NsOptions::Namespace
       assert_equal @type, option.type_class
       assert_equal @rules, option.rules
     end
+    
+    should "check if the option name is ok" do
+      advisor = NsOptions::Helper::Advisor.new(@namespace)
+      NsOptions::Helper.expects(:advisor).with(@namespace).returns(advisor)
+      advisor.expects(:is_this_option_ok?)
+      assert_nothing_raised do
+        @namespace.option(:amazing)
+      end
+    end
   end
 
   class OptionWithNoTypeTest < BaseTest
@@ -50,10 +69,11 @@ class NsOptions::Namespace
     end
     subject{ @namespace }
 
-    should "default the type to String" do
+    should "default the type to Object" do
       assert(option = subject.options[@name])
-      assert_equal String, option.type_class
+      assert_equal Object, option.type_class
     end
+
   end
 
   class OptionMethodsTest < OptionTest
@@ -62,13 +82,15 @@ class NsOptions::Namespace
     should have_instance_methods :something, :something=
 
     should "be writable through the defined writer" do
-      assert_nothing_raised{ subject.something = false }
-      assert_equal false, subject.something
+      assert_nothing_raised{ subject.something = "abc" }
+      assert_equal "abc", subject.something
     end
+
     should "be writable through the reader with args" do
-      assert_nothing_raised{ subject.something true }
-      assert_equal true, subject.something
+      assert_nothing_raised{ subject.something "123" }
+      assert_equal "123", subject.something
     end
+
   end
 
   class NamespaceTest < BaseTest
@@ -79,6 +101,9 @@ class NsOptions::Namespace
       end
       @namespace.namespace(:another, "special_key")
     end
+    teardown do
+      NsOptions::Helper.unstub(:advisor)
+    end
     subject{ @namespace }
 
     should "have added a namespace to the namespace's options collection" do
@@ -87,10 +112,21 @@ class NsOptions::Namespace
       assert_equal subject, namespace.options.parent
       assert namespace.options[:something_else]
     end
+
     should "allow passing a special key to the namespace" do
       assert(namespace = subject.options.namespaces[:another])
       assert_equal "#{subject.options.key}:special_key", namespace.options.key
     end
+    
+    should "check if the namespace name is ok" do
+      advisor = NsOptions::Helper::Advisor.new(@namespace)
+      NsOptions::Helper.expects(:advisor).with(@namespace).returns(advisor)
+      advisor.expects(:is_this_namespace_ok?)
+      assert_nothing_raised do
+        @namespace.namespace(:yet_another)
+      end
+    end
+
   end
 
   class NamespaceMethodsTest < NamespaceTest
@@ -101,12 +137,14 @@ class NsOptions::Namespace
     should "be return the namespace using the reader" do
       assert_equal subject.options.namespaces[:something], subject.something
     end
+
     should "define the namespace with the reader and a block" do
       subject.something do
         option :another
       end
       assert subject.something.options[:another]
     end
+
   end
 
   class DefineTest < BaseTest
@@ -146,10 +184,9 @@ class NsOptions::Namespace
   class MethodMissingTest < BaseTest
     desc "method missing"
     setup do
-      @parent = @namespace
-      @parent.options.add(:something)
-      @parent.options.set(:something, "amazing")
-      @namespace = NsOptions::Namespace.new("child", @parent)
+      @namespace = NsOptions::Namespace.new("strange")
+      @namespace.options.add(:something)
+      @namespace.options.set(:something, "amazing")
     end
 
     class ReaderForAKnownOptionTest < MethodMissingTest
@@ -184,6 +221,8 @@ class NsOptions::Namespace
         @namespace.something_not_defined = "you know it"
         @namespace.another_not_defined = true
         @namespace.even_more_not_defined = 12
+        @namespace.just_one_more_not_defined = nil
+        @namespace.proc_opt_not_defined = Proc.new { "imma proc!" }
       end
 
       should "have defined the accessors and added the option" do
@@ -193,11 +232,20 @@ class NsOptions::Namespace
         assert_includes :something_not_defined=, defined_methods
         assert_equal "you know it", subject.something_not_defined
       end
-      should "use the class of the value for the option's type class" do
-        assert_equal String, subject.options[:something_not_defined].type_class
-        assert_equal Integer, subject.options[:even_more_not_defined].type_class
-        assert_equal NsOptions::Option::Boolean, subject.options[:another_not_defined].type_class
+
+      should "use Object for the option's type class, no matter what the value is" do
+        assert_equal Object, subject.options[:something_not_defined].type_class
+        assert_equal Object, subject.options[:another_not_defined].type_class
+        assert_equal Object, subject.options[:even_more_not_defined].type_class
+        assert_equal Object, subject.options[:just_one_more_not_defined].type_class
+        assert_equal Object, subject.options[:proc_opt_not_defined].type_class
+      end
+
+      should "return the Proc return val when an unknow option is set to a Proc" do
+        assert_not_kind_of Proc, subject.options[:proc_opt_not_defined].type_class
+        assert_equal "imma proc!", subject.proc_opt_not_defined
       end
+
     end
   end
 
@@ -229,4 +277,125 @@ class NsOptions::Namespace
     end
   end
 
+
+
+  class HandlingTests < BaseTest
+    setup do
+      @namespace.define do
+        option :first
+        option :second
+        option :third
+        namespace(:child_a) do
+          option(:fourth)
+          option(:fifth)
+          namespace(:child_b) do
+            option(:sixth)
+          end
+        end
+      end
+
+      @named_values = {
+        :first => "1", :second => "2", :third => "3", :twenty_one => "21",
+        :child_a => {
+          :fourth => "4", :fifth => "5",
+          :child_b => { :sixth => "6" }
+        },
+        :child_c => { :what => "?" }
+      }
+    end
+
+  end
+
+
+
+  class ApplyTest < HandlingTests
+    desc "apply method"
+    setup do
+      @namespace.apply(@named_values)
+    end
+
+    should "have mass set all the defined options" do
+      assert_equal @named_values[:first], subject.first
+      assert_equal @named_values[:second], subject.second
+      assert_equal @named_values[:third], subject.third
+      assert_equal @named_values[:child_a][:fourth], subject.child_a.fourth
+      assert_equal @named_values[:child_a][:fifth], subject.child_a.fifth
+      assert_equal @named_values[:child_a][:child_b][:sixth], subject.child_a.child_b.sixth
+    end
+    should "have dynamically added options for the undefined keys" do
+      assert_equal @named_values[:twenty_one], subject.twenty_one
+      assert_equal @named_values[:child_c], subject.child_c
+    end
+
+  end
+
+
+
+  class ToHashTests < HandlingTests
+    desc "when to_hash"
+    subject { @namespace.to_hash }
+
+    should "return a Hash representation for the namespace" do
+      assert_equal({
+        :first => nil,
+        :second => nil,
+        :third => nil,
+        :child_a => {
+          :fourth => nil,
+          :fifth => nil,
+          :child_b => {
+            :sixth => nil
+          }
+        }
+      }, subject)
+
+      @namespace.first = "first"
+      assert_equal({
+        :first => "first",
+        :second => nil,
+        :third => nil,
+        :child_a => {
+          :fourth => nil,
+          :fifth => nil,
+          :child_b => {
+            :sixth => nil
+          }
+        }
+      }, subject)
+
+      @namespace.apply(@named_values)
+      assert_equal @named_values, subject
+    end
+
+    should "contain its to_hash representation in its inspect output" do
+      assert_included subject.inspect, @namespace.inspect
+    end
+
+  end
+
+
+  class EachTests < HandlingTests
+    desc "iterated with the each method"
+    setup do
+      @namespace.apply(@named_values)
+      @exp = "".tap do |exp|
+        @namespace.to_hash.each do |k,v|
+          exp << "#{k}=#{v};"
+        end
+      end
+      @act = "".tap do |exp|
+        @namespace.each do |k,v|
+          exp << "#{k}=#{v};"
+        end
+      end
+    end
+
+    should "yield k/v pairs by iterating over the #to_hash" do
+      assert_equal @exp, @act
+    end
+
+  end
+
+
+
 end

data/test/unit/ns-options/namespaces_test.rb

@@ -45,7 +45,7 @@ class NsOptions::Namespaces
 
   class GetTest < AddTest
     desc "get method"
-    
+
     should "return the namespace matching the name" do
       assert(namespace = subject.get("a_name"))
       assert_equal subject[:a_name], namespace