ns-options 0.4.1 → 1.0.0.rc1

data/test/unit/namespace_tests.rb

@@ -0,0 +1,205 @@
+require 'assert'
+require 'ns-options/namespace'
+
+class NsOptions::Namespace
+
+  class BaseTests < Assert::Context
+    desc "NsOptions::Namespace"
+    setup do
+      @name = "something"
+      @namespace = NsOptions::Namespace.new(@name)
+    end
+    subject{ @namespace }
+
+    should have_reader :__name__, :__data__
+    should have_imeths :option, :opt, :namespace, :ns
+    should have_imeths :option_type_class, :opt_type_class
+    should have_imeths :required_set?, :valid?
+    should have_imeths :has_option?, :has_namespace?
+    should have_imeths :define, :build_from, :reset, :apply, :to_hash, :each
+
+    should "know its name" do
+      assert_equal @name, subject.__name__
+    end
+
+    should "contain its name key in its inspect output" do
+      assert_included ":something", subject.inspect
+    end
+
+    should "contain its to_hash representation in its inspect output" do
+      assert_included subject.to_hash.inspect, subject.inspect
+    end
+
+    should "know its option type class" do
+      assert_equal Object, subject.option_type_class
+    end
+
+    should "set its option type class" do
+      subject.option_type_class(String)
+      assert_equal String, subject.option_type_class
+    end
+
+  end
+
+  class OptionTests < BaseTests
+    desc "when adding an option named `something`"
+    setup do
+      @added_opt = @namespace.option('something', String, { :default => true })
+    end
+
+    should "have added an option to the namespace" do
+      assert subject.has_option? :something
+
+      opt = subject.__data__.child_options[:something]
+      assert_equal 'something',  opt.name
+      assert_equal String,  opt.type_class
+      assert_equal true, opt.rules[:default]
+    end
+
+    should "return the option it added" do
+      assert_kind_of NsOptions::Option, @added_opt
+
+      option = subject.__data__.child_options[:something]
+      assert_equal option, @added_opt
+    end
+
+    should "advise on the option name" do
+      not_recommended_warn = NsOptions::TestOutput.capture do
+        subject.option 'to_hash'
+      end
+      assert_match 'WARNING: ', not_recommended_warn
+
+      subject.option 'opt1'
+      duplicate_warn = NsOptions::TestOutput.capture do
+        subject.option 'opt1'
+      end
+      assert_match 'WARNING: ', duplicate_warn
+    end
+
+    should "respond to a reader/writer named after the option name" do
+      assert_responds_to :something, subject
+      assert_responds_to :something=, subject
+    end
+
+    should "return the option using the reader" do
+      assert_equal subject.__data__.child_options.get(:something), subject.something
+    end
+
+    should "be writable through the defined writer" do
+      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 "123" }
+      assert_equal "123", subject.something
+    end
+
+  end
+
+  class NamespaceTests < BaseTests
+    desc "when adding a namespace named `something`"
+    setup do
+      @namespace.namespace('something') do
+        option :something_else
+      end
+    end
+
+    should "know that it has the child namespace" do
+      assert subject.has_namespace? :something
+
+      ns = subject.something
+      assert_kind_of NsOptions::Namespace, ns
+      assert_equal 'something', ns.__name__
+      assert ns.has_option? :something_else
+    end
+
+    should "respond to a reader named after the namespace name" do
+      assert_responds_to :something, subject
+    end
+
+    should "return the namespace using the reader" do
+      assert_equal subject.__data__.child_namespaces[:something], subject.something
+    end
+
+    should "define on the namespace if it is called with a block" do
+      ns = subject.something
+      assert_not ns.has_option? :defined_later
+
+      subject.something { option :defined_later }
+      assert ns.has_option? :defined_later
+    end
+
+    should "advise on the namespace name" do
+      not_recommended_warn = NsOptions::TestOutput.capture do
+        subject.namespace 'to_hash'
+      end
+      assert_match 'WARNING: ', not_recommended_warn
+
+      subject.namespace 'opt1'
+      duplicate_warn = NsOptions::TestOutput.capture do
+        subject.namespace 'opt1'
+      end
+      assert_match 'WARNING: ', duplicate_warn
+    end
+
+  end
+
+  class DynamicOptionNamespaceWriterTests < BaseTests
+
+    should "write non-pre-defined values as Object options" do
+      assert_not subject.has_option? :not_pre_defined
+      assert_responds_to     :not_pre_defined=, subject
+      assert_not_responds_to :not_pre_defined, subject
+
+      assert_nothing_raised { subject.not_pre_defined = 123 }
+
+      assert subject.has_option? :not_pre_defined
+      assert_responds_to :not_pre_defined, subject
+
+      assert_equal 123, subject.not_pre_defined
+      assert_equal Object, subject.__data__.child_options['not_pre_defined'].type_class
+    end
+
+    should "raise NoMethodError when writing namespace values" do
+      subject.namespace('something')
+
+      assert_raises NoMethodError do
+        subject.something = 'a value'
+      end
+      assert_raises NoMethodError do
+        subject.something = {:a => 'value'}
+      end
+    end
+
+  end
+
+  class EqualityTests < BaseTests
+    desc "when compared for equality"
+    setup do
+      @named_values = {:some => 'value', 'another' => 'value'}
+      @namespace.apply(@named_values)
+    end
+
+    should "be equal to another namespace with the same named values" do
+      other_ns = NsOptions::Namespace.new('other_something')
+      other_ns.apply(@named_values)
+
+      assert_equal other_ns, subject
+    end
+
+    should "not be equal to another namespace with different values" do
+      other_ns = NsOptions::Namespace.new('other_something')
+      other_ns.apply({:other => 'data'})
+
+      assert_not_equal other_ns, subject
+    end
+
+    should "not be equal to other things" do
+      assert_not_equal 1, subject
+      assert_not_equal @named_values, subject
+    end
+
+  end
+
+end

data/test/unit/namespaces_tests.rb

@@ -0,0 +1,99 @@
+require 'assert'
+require 'ns-options/namespaces'
+
+class NsOptions::Namespaces
+
+  class BaseTests < Assert::Context
+    desc "NsOptions::Namespaces"
+    setup do
+      @namespaces = NsOptions::Namespaces.new
+    end
+    subject{ @namespaces }
+
+    should have_accessor :[]
+    should have_imeths :keys, :each, :empty?
+    should have_imeths :add, :rm, :get, :required_set?
+
+    should "only use strings for keys (indifferent access)" do
+      subject['string_key'] = true
+      subject[:symbol_key]  = true
+
+      assert_includes 'string_key', subject.keys
+      assert_includes 'symbol_key', subject.keys
+      assert_not_includes :string_key, subject.keys
+    end
+
+    should "get items" do
+      subject[:a_key] = "a key"
+
+      assert_equal subject[:a_key], subject.get(:a_key)
+      assert_equal subject[:a_key], subject.get('a_key')
+    end
+
+  end
+
+  class AddTests < BaseTests
+    desc "add method"
+
+    should "add namespaces" do
+      assert_nil subject[:a_name]
+      subject.add(:a_name, NsOptions::Namespace.new(:a_name))
+      assert subject[:a_name]
+    end
+
+    should "should work with both string and symbol names" do
+      assert_nil subject[:a_name]
+      subject.add('a_name', NsOptions::Namespace.new('a_name'))
+      assert subject[:a_name]
+    end
+
+    should "return the option added" do
+      added_ns = subject.add(:a_name, NsOptions::Namespace.new(:a_name))
+      assert_kind_of NsOptions::Namespace, added_ns
+    end
+
+  end
+
+  class RmTests < BaseTests
+    desc "rm method"
+    setup do
+      @namespaces.add(:my_string, NsOptions::Namespace.new(:my_string))
+    end
+
+    should "remove the option definition from the collection" do
+      assert subject[:my_string]
+
+      subject.rm(:my_string)
+      assert_nil subject[:my_string]
+    end
+
+    should "should work with both string and symbol names" do
+      assert subject[:my_string]
+
+      subject.rm('my_string')
+      assert_nil subject[:my_string]
+    end
+
+  end
+
+  class RequiredSetTests < BaseTests
+    desc "with a namespace with :required options"
+    setup do
+      @namespace = NsOptions::Namespace.new :with_required do
+        option :required, :required => true
+      end
+      @namespaces[:with_required] = @namespace
+    end
+
+    should "know when its namespaces have all required set" do
+      assert_not subject.required_set?
+      @namespace.not_required = 'a value'
+      assert_not subject.required_set?
+
+      @namespace.required = 'something'
+      assert subject.required_set?
+    end
+
+  end
+
+end