ns-options 0.4.1 → 1.0.0.rc1

data/test/integration/user_test.rb

@@ -1,94 +0,0 @@
-require 'assert'
-
-class User
-
-  class BaseTest < Assert::Context
-    desc "the User class"
-    setup do
-      @class = User
-    end
-    subject{ @class }
-
-    should have_instance_methods :options, :preferences
-
-  end
-
-  class ClassPreferencesTest < BaseTest
-    desc "preferences"
-    subject{ @class.preferences }
-
-    should have_instance_methods :namespace, :option, :define, :options, :metaclass
-    should have_accessors :home_url, :show_messages, :font_size
-
-  end
-
-  class InstanceTest < BaseTest
-    desc "instance"
-    setup do
-      @instance = @class.new
-      @class_preferences = @class.preferences
-      @class_preferences.home_url = "/something"
-      @preferences = @instance.preferences
-    end
-    subject{ @instance }
-
-    should have_instance_methods :preferences
-
-    should "have a new namespace that is a different object than the class namespace" do
-      assert_equal @class_preferences.options.key, @preferences.options.key
-      assert_equal @class_preferences.options.parent, @preferences.options.parent
-      assert_not_same @class_preferences, @preferences
-    end
-    should "have the same options as the class namespace, but different objects" do
-      @class_preferences.options.each do |key, class_option|
-        option = @preferences.options[key]
-        assert_equal class_option.name, option.name
-        assert_equal class_option.type_class, option.type_class
-        assert_equal class_option.rules, option.rules
-        assert_not_same class_option, option
-      end
-      assert_not_equal @class_preferences.home_url, @preferences.home_url
-    end
-    should "have the same namespaces as the class namespace, but different objects" do
-      @class_preferences.options.namespaces.each do |name, class_namespace|
-        namespace = @preferences.options.namespaces[name]
-        assert_equal class_namespace.options.key, namespace.options.key
-        assert_equal class_namespace.options.parent, namespace.options.parent
-        assert_not_same class_namespace, namespace
-      end
-    end
-  end
-
-  class PreferencesTest < InstanceTest
-    desc "preferences"
-    setup do
-      @preferences = @instance.preferences
-      @preferences.home_url = "/home"
-      @preferences.show_messages = false
-      @preferences.font_size = 15
-      @preferences.view.color = "green"
-    end
-    subject{ @preferences }
-
-    should have_accessors :home_url, :show_messages, :font_size
-    should have_instance_methods :namespace, :option, :define, :options, :metaclass
-    should have_instance_methods :view
-
-    should "have set the home_url" do
-      assert_equal "/home", subject.home_url
-    end
-
-    should "have set show_messages" do
-      assert_equal false, subject.show_messages
-    end
-
-    should "have set the font_size" do
-      assert_equal 15, subject.font_size
-    end
-
-    should "have set the color option on the view sub namespace" do
-      assert_equal "green", subject.view.color
-    end
-  end
-
-end

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

@@ -1,90 +0,0 @@
-require 'assert'
-
-module NsOptions::HasOptions
-
-  class BaseTest < Assert::Context
-    desc "NsOptions::HasOptions"
-    setup do
-      @class = Class.new do
-        include NsOptions::HasOptions
-
-        def configs_key
-          "random_class_#{self.object_id}"
-        end
-      end
-      @instance = @class.new
-    end
-    subject{ @instance }
-
-    should have_class_methods :options, :opts
-
-  end
-
-  class OptionsTests < BaseTest
-    desc "options method"
-
-    class WithAKeyTest < OptionsTests
-      desc "with a key"
-      setup do
-        @key = "configs-key"
-        @class.options(:configs, @key) do
-          option :something
-        end
-        @instance = @class.new
-      end
-      subject{ @instance }
-
-      should have_class_method :configs
-      should have_instance_method :configs
-
-      should "have used the provided key when creating the namespace" do
-        assert_kind_of NsOptions::Namespace, subject.class.configs
-        assert_kind_of NsOptions::Namespace, subject.configs
-        assert_equal @key, subject.class.configs.options.key
-        assert_match @key, subject.configs.options.key
-      end
-
-      should "have used the provided block to define the namespace" do
-        assert_respond_to :something, subject.configs
-        assert_respond_to :something=, subject.configs
-        assert subject.configs.options.fetch(:something)
-      end
-
-    end
-
-    class WithoutAKeyTest < OptionsTests
-      desc "without a key"
-      setup do
-        @name = "configs"
-        @class.options(@name.to_sym)
-        @instance = @class.new
-      end
-      subject{ @instance }
-
-      should "have used the name for the key when creating the namespace" do
-        assert_equal @name, subject.class.configs.options.key
-        assert_match @name, subject.configs.options.key
-      end
-
-    end
-
-    class AdvisorTests < OptionsTests
-      desc "creating a root namespace with a bad name"
-      setup do
-        @ns_name = "options"
-        @output = NsOptions::TestOutput.capture do
-          @ns = @class.options(@ns_name.to_sym)
-        end
-        @advisor = NsOptions::Helper::Advisor.new(@ns)
-      end
-
-      should "output a message warning using the method name as a namespace name" do
-        expected = @advisor.not_recommended_method_message("namespace", "options")
-        assert_match expected, @output.string
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,148 +0,0 @@
-require 'assert'
-
-class NsOptions::Helper::Advisor
-
-  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_sub_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 = NsOptions::TestOutput.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 = NsOptions::TestOutput.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 NotRecommendedNamespaceTest < BaseTest
-    desc "with a not recommended root namespace"
-    setup do
-      @output = NsOptions::TestOutput.capture do
-        @advisor.is_this_namespace_ok?("options")
-      end
-    end
-
-    should "output a message warning using the method name as a namespace name" do
-      expected = subject.not_recommended_method_message("namespace", "options")
-      assert_match expected, @output.string
-      assert_match "From: ", @output.string
-    end
-  end
-
-  class NotRecommendedSubNamespaceTest < BaseTest
-    desc "with a not recommended sub namespace"
-    setup do
-      @output = NsOptions::TestOutput.capture do
-        @advisor.is_this_sub_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
-
-  class BadSubNamespaceTest < BaseTest
-    desc "with a bad sub namespace"
-    setup do
-      begin
-        @advisor.is_this_sub_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 DuplicateSubNamespaceTest < BaseTest
-    desc "with a duplicate sub namespace"
-    setup do
-      @namespace.namespace(:duplicate)
-      @output = NsOptions::TestOutput.capture do
-        @advisor.is_this_sub_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
-
-end

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

@@ -1,56 +0,0 @@
-require 'assert'
-
-module NsOptions::Helper
-
-  class BaseTest < Assert::Context
-    desc "NsOptions::Helper"
-    setup do
-      @module = NsOptions::Helper
-    end
-    subject{ @module }
-
-    should have_instance_method :find_and_define_namespace
-    should have_instance_method :find_and_define_option
-    should have_instance_method :define_namespace_methods
-    should have_instance_method :define_option_methods
-    should have_instance_method :advisor
-    should have_instance_method :define_root_namespace_methods
-
-    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 FindAndDefineOptionTest < BaseTest
-    desc "find_and_define_option method"
-    setup do
-      @namespace = NsOptions::Namespace.new("something")
-      @option = @namespace.options.add(:anything)
-      @result = @module.find_and_define_option(@namespace, @option.name)
-    end
-    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
-
-  class FindAndDefineNamespaceTest < BaseTest
-    desc "find_and_define_namespace method"
-    setup do
-      @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 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
-
-end