skn_utils 1.4.0

data/spec/lib/skn_utils/page_controls_spec.rb

@@ -0,0 +1,123 @@
+##
+# spec/lib/skn_utils/generic_bean_spec.rb
+#
+
+RSpec.describe SknUtils::PageControls, "PageControls Marshal'able Bean class " do
+  let(:object) {
+    SknUtils::PageControls.new({one: "one",
+                               two: "two",
+                               three: {four: 4, five: 5, six: {seven: 7, eight: "eight" }},
+                               four: {any_key: "any value"}, 
+                               five: [],
+                               six: [{any_key: "any value"},
+                                     {four: 4, 
+                                      five: 5, 
+                                      six: {seven: 7, eight: "eight" }, 
+                                      twenty:[{seven: 7, eight: 8 }, {nine: 9, ten: 10 }]
+                                     }
+                                    ]
+                              })
+  }
+
+  context "Internal Operations, assuming :dept => :multi_with_arrays and enable_serialization => true" do
+    it "Creates an empty bean if no params are passed" do
+      is_expected.to be
+    end
+    it "Can be Marshalled after dynamically adding a key/value." do
+        expect { object.fifty = {any_key: "any value"} }.not_to raise_error  
+        expect { object.sixty = 60 }.not_to raise_error
+        dmp = obj = ""  
+        expect { dmp =  Marshal.dump(object) }.not_to raise_error
+        expect { obj = Marshal.load(dmp) }.not_to raise_error
+        expect(obj).to be_a(SknUtils::PageControls)
+        expect( object.fifty.any_key).to eql "any value"  
+        expect( object.sixty).to eql 60
+    end
+    it "Initializes from a hash" do
+      expect(object).to be
+    end
+    it "Does not modify the base class, only singleton instance methods" do
+      obj1 = SknUtils::PageControls.new({one: "one", two: "two"})
+      obj2 = SknUtils::PageControls.new({three: "3", four: "4"})
+      expect(obj1.one).to eql "one"
+      expect(obj2.three).to eql "3"
+      expect(obj2.one?).to be false
+      expect(obj1.three?).to be false
+      expect { obj1.three }.to raise_error NoMethodError
+      expect { obj2.one }.to raise_error NoMethodError
+    end
+    it "Supports predicates(?)" do
+      expect(object.one?).to be true
+      expect(object.three.five?).to be true
+    end
+    it "Does not support - respond_to - methods, because it has no accessor methods" do
+      expect(object).not_to respond_to(:one)
+      expect(object.one).to eql "one"
+    end
+    it "nest objects if multi-level hash is given" do
+      expect(object.three).to be_a(SknUtils::PageControls)
+      expect(object.three.five).to eq(5)
+    end
+    it "nest objects if multi-level array of hashes is given" do
+      expect(object.six).to be_a(Array)
+      expect(object.six.first).to be_a(SknUtils::PageControls)
+      expect(object.six.last).to be_a(SknUtils::PageControls)
+      expect(object.six.last.six.eight).to eq('eight')
+    end
+    it "nest objects if multi-level array of hashes, and an element contains another array of hashes, is given" do
+      expect(object.six.first).to be_a(SknUtils::PageControls)
+      expect(object.six).to be_a(Array)
+      expect(object.six.last.twenty).to be_a(Array)
+      expect(object.six.last.twenty.first).to be_a(SknUtils::PageControls)
+      expect(object.six.last.twenty.last).to be_a(SknUtils::PageControls)
+      expect(object.six.last.twenty.first.eight).to eq(8)
+      expect(object.six.last.twenty.last.ten).to eq(10)
+    end
+    it "nest arrays of objects if array of hashes is dynamically given  (post-create)" do
+      expect { object.one_array = [{one: "one", two: "two"},{one: 1, two: 2}] }.not_to raise_error
+      expect(object.one_array.first.one).to eql("one")
+      expect(object.one_array.last.two).to eql(2)
+      expect(object.one_array[0]).to be_a(SknUtils::PageControls)
+    end
+    it "#attributes method returns a hash of all attributes and their values." do
+      expect(object.attributes).to be_a(Hash)
+      expect(object.attributes[:one]).to be_eql("one")
+      expect(object.attributes[:three]).to be_a(Hash)
+      expect(object.attributes[:six].last[:six][:eight]).to eql('eight')
+    end
+  end
+
+  shared_examples_for "retains initialization options" do
+    it "retains depth_level option flag" do
+      expect(@obj.depth_level).to eql(:multi_with_arrays)
+    end
+    it "retains serialization option flag" do
+      expect(@obj.serialization_required?).to be true
+    end    
+  end
+
+  context "Basic Operations without marshaling " do
+    before :each do
+      @obj = object
+    end
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "marshalable ruby pojo"
+  end  
+  context "Basic Operations after Yaml marshaling " do
+    before :each do
+      dmp = YAML::dump(object)
+      @obj = YAML::load(dmp)
+    end    
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "marshalable ruby pojo"
+  end
+  context "Basic Operations after Marshal marshaling " do
+    before :each do
+      dmp =  Marshal.dump(object)
+      @obj = Marshal.load(dmp)
+    end
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "marshalable ruby pojo"
+  end
+
+end

data/spec/lib/skn_utils/result_bean_spec.rb

@@ -0,0 +1,92 @@
+##
+# spec/lib/skn_utils/result_bean_spec.rb
+#
+
+RSpec.describe SknUtils::ResultBean, "Result Bean class - Basic useage." do
+  let(:object) {
+    SknUtils::ResultBean.new({one: "one",
+                             two: "two",
+                             three: {four: 4, five: 5, six: {seven: 7, eight: "eight" }},
+                             four: {any_key: "any value"}, 
+                             five: []
+                            })
+  }
+
+  context "Internal Operations, assuming :dept => :multi and enable_serialization => false" do
+    it "Creates an empty bean if no params are passed" do
+      is_expected.to be
+    end
+    it "Initializes from a hash" do
+      expect(SknUtils::ResultBean.new({one: "one", two: "two"})).to be
+    end
+    it "Does not modify the base class, only singleton instance methods" do
+      obj1 = SknUtils::ResultBean.new({one: "one", two: "two"})
+      obj2 = SknUtils::ResultBean.new({three: 3, four: "4"})
+      expect(obj1.one).to eql "one"
+      expect(obj2.three).to eql 3
+      expect(obj2.one?).to be false
+      expect(obj1.three?).to be false
+      expect { obj1.three }.to raise_error NoMethodError
+      expect { obj2.one }.to raise_error NoMethodError
+    end
+    it "Supports - respond_to - methods, because it has accessor methods" do
+      expect(object).to respond_to(:one)
+    end
+  end
+
+  shared_examples_for "retains initialization options" do
+    it "retains depth_level option flag" do
+      expect(@obj.depth_level).to eql(:multi)
+    end
+    it "retains serialization option flag" do
+      expect(@obj.serialization_required?).to be false
+    end    
+  end
+
+  context "Basic Operations after Marshal marshaling " do
+    it "Singleton objects (like ResultBean) cannot be marshaled" do
+      expect { Marshal.dump(object) }.to raise_error TypeError
+    end
+  end
+  context "Basic Operations without marshaling " do
+    before :each do
+      @obj = object
+    end
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "ruby pojo"
+  end
+  context "Basic Operations after Yaml marshaling " do
+    before :each do
+      dmp = YAML::dump(object)
+      @obj = YAML::load(dmp)
+    end
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "ruby pojo"
+  end
+  context "ResultBeans stripped of their internal singleton accessors can be Marshaled! " do
+    before :each do
+      dmp = YAML::dump(object)
+      obj = YAML::load(dmp)                        # Yaml'ing removes singleton accessor methods'
+                                                   # by initializing object without using its
+                                                   # initialize() method
+
+      dmp =  Marshal.dump(obj)                     # Now Marshal load/dump will work
+      @obj = Marshal.load(dmp)                     # Use GenericBean if Marshal support is needed
+    end
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "ruby pojo"
+  end
+  context "Basic Operations after Yaml marshaling via restored accessors " do
+    before :each do
+      dmp = YAML::dump(object)
+      @obj = YAML::load(dmp)
+      # Restore setters
+      @obj.attributes.keys.each do |k|
+        @obj.singleton_class.send(:attr_accessor, k)
+      end
+    end
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "ruby pojo"
+  end
+
+end

data/spec/lib/skn_utils/result_bean_with_errors_spec.rb

@@ -0,0 +1,178 @@
+##
+# spec/lib/skn_utils/result_bean_with_errors_spec.rb
+#
+
+RSpec.describe SknUtils::ResultBeanWithErrors, "Result Bean class with ActiveModel::Errors object " do
+  let(:object) {
+    SknUtils::ResultBeanWithErrors.new({one: "one",
+                             two: "two",
+                             three: {four: 4, five: 5, six: {seven: 7, eight: "eight" }},
+                             four: {any_key: "any value"}, 
+                             five: []
+                            })
+  }
+
+  context "Internal Operations, assuming :dept => :multi and enable_serialization => false" do
+    it "Creates an empty bean if no params are passed" do
+      is_expected.to be
+      expect(subject.errors).to be
+    end
+    it "Initializes from a hash that DOES NOT include an errors.object " do
+      expect(SknUtils::ResultBeanWithErrors.new({one: "one", two: "two"})).to be
+    end
+    it "Initializes from a hash that DOES include an errors.object " do
+      errors = ActiveModel::Errors.new(self)  ## VERY BAD IDEAL
+      expect(SknUtils::ResultBeanWithErrors.new({one: "one", two: "two", errors: errors})).to be
+    end
+    it "Does not modify the base class, only singleton instance methods" do
+      obj1 = SknUtils::ResultBeanWithErrors.new({one: "one", two: "two"})
+      obj2 = SknUtils::ResultBeanWithErrors.new({three: "3", four: "4"})
+      expect(obj1.one).to eql "one"
+      expect(obj2.three).to eql "3"
+      expect(obj2.one?).to be_falsey
+      expect(obj1.three?).to be_falsey
+      expect { obj1.three }.to raise_error NoMethodError
+      expect { obj2.one }.to raise_error NoMethodError
+    end
+    it "Supports - respond_to - methods, because it has accessor methods" do
+      expect(object).to respond_to(:one)
+    end
+  end
+
+  shared_examples_for "retains initialization options" do
+    it "retains depth_level option flag" do
+      expect(@obj.depth_level).to eql(:multi)
+    end
+    it "retains serialization option flag" do
+      expect(@obj.serialization_required?).to be false
+    end    
+  end
+
+  context "ActiveModel:Errors object" do
+    it "#errors method returns an ActiveModel::Errors object" do
+      obj = SknUtils::ResultBeanWithErrors.new({one: "one", two: "two"})
+      expect(obj.errors).to be_an_instance_of(ActiveModel::Errors)
+    end
+
+    it "#errors method accepts additional errors" do
+      obj = SknUtils::ResultBeanWithErrors.new({one: "one", two: "two"})
+      obj.errors.add(:one,"must be numeric.")
+      expect(obj.errors.size).to be 1
+    end
+
+    it "#errors.full_messages method returns messages" do
+      obj = SknUtils::ResultBeanWithErrors.new({one: "one", two: "two"})
+      obj.errors.add(:one,"must be numeric.")
+      expect(obj.errors.full_messages.first).to include("numeric")
+    end
+
+    it "#errors.add_on_empty method correctly adds new errors" do
+      obj = SknUtils::ResultBeanWithErrors.new({one: "one", two: ""})
+      obj.errors.add_on_empty(:two)
+      expect(obj.errors.count).to be 1
+    end
+
+    it "#errors.add_on_blank method correctly adds new errors" do
+      obj = SknUtils::ResultBeanWithErrors.new({one: "one", two: ""})
+      obj.errors.add_on_blank(:two)
+      expect(obj.errors.count).to be 1
+    end
+
+    it "#errors.get method correctly retrieves existing message by attribute" do
+      obj = SknUtils::ResultBeanWithErrors.new({one: "one", two: ""})
+      obj.errors.add_on_blank(:two)
+      expect(obj.errors.get(:two).first).to include("blank")
+    end
+
+    it "#errors[] method correctly retrieves existing message by attribute" do
+      obj = SknUtils::ResultBeanWithErrors.new({one: "one", two: ""})
+      obj.errors.add_on_blank(:two)
+      expect(obj.errors[:two].first).to include("blank")
+    end
+
+    it "#errors.set method correctly adds sets message on attribute" do
+      obj = SknUtils::ResultBeanWithErrors.new({one: "one", two: ""})
+      obj.errors.set(:two, "Required value, must not be empty")
+      expect(obj.errors.get(:two)).to include("Required")
+    end
+
+    it "#errors.include? method correctly determines that an error exists for the given key" do
+      obj = SknUtils::ResultBeanWithErrors.new({one: "one", two: ""})
+      obj.errors.add(:two, "Required value, must not be empty")
+      result = obj.errors.include?(:two)
+      expect(result).to be_truthy
+      result = obj.errors.include?(:one)
+      expect(result).to be_falsey
+    end
+
+    it "#errors.delete method correctly removes an error for the given key" do
+      obj = SknUtils::ResultBeanWithErrors.new({one: "one", two: ""})
+      obj.errors.add(:two, "Required value, must not be empty")
+      result = obj.errors.include?(:two)
+      expect(result).to be_truthy
+      obj.errors.delete(:two)
+      result = obj.errors.include?(:two)
+      expect(result).to be_falsey
+    end
+  end
+
+  context "Serialization" do
+    before :each do
+      @obj = object
+    end
+    it "Serialization does not include the errors object." do
+      expect(@obj.to_hash[:errors]).not_to be
+      expect(@obj.errors).to be_a(ActiveModel::Errors)
+    end
+
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "ruby pojo"    
+  end
+
+  context "Basic Operations after Marshal marshaling " do
+    it "Singleton objects (like ResultBean) cannot be marshaled" do
+      expect { Marshal.dump(object) }.to raise_error TypeError
+    end
+  end
+  context "Basic Operations without marshaling " do
+    before :each do
+      @obj = object
+    end
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "ruby pojo"
+  end
+  context "Basic Operations after Yaml marshaling " do
+    before :each do
+      dmp = YAML::dump(object)
+      @obj = YAML::load(dmp)
+    end
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "ruby pojo"
+  end
+  context "ResultBeans stripped of their internal singleton accessors can be Marshaled! " do
+    before :each do
+      dmp = YAML::dump(object)
+      obj = YAML::load(dmp)                        # Yaml'ing removes singleton accessor methods'
+                                                   # by initializing object without using its
+                                                   # initialize() method
+
+      dmp =  Marshal.dump(obj)                     # Now Marshal load/dump will work
+      @obj = Marshal.load(dmp)                     # Use GenericBean if Marshal support is needed
+    end
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "ruby pojo"
+  end
+  context "Basic Operations after Yaml marshaling via restored accessors " do
+    before :each do
+      dmp = YAML::dump(object)
+      @obj = YAML::load(dmp)
+      # Restore setters
+      @obj.attributes.keys.each do |k|
+        @obj.singleton_class.send(:attr_accessor, k)
+      end
+    end
+    it_behaves_like "retains initialization options"    
+    it_behaves_like "ruby pojo"
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'active_model'
+require 'skn_utils'
+require 'rspec'
+
+# Shared Examples and Support Routines
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f}
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  Kernel.srand config.seed
+
+  config.order = :random
+  config.color = true
+  config.tty = false
+  config.formatter = :progress  #:html, :textmate, :documentation
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  config.disable_monkey_patching!  # -- breaks rspec runtime
+  config.warnings = true
+  # config.profile_examples = 10
+
+  if config.files_to_run.one?
+    config.formatter = :documentation 
+  end
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+  
+end

data/spec/support/shared_example_marshalable_ruby_pojo.rb

@@ -0,0 +1,55 @@
+##
+# <root>/spec/support/shared_example_marshalable_ruby_pojo.rb
+#
+# refs: page_controls, generic_bean
+#
+
+RSpec.shared_examples "marshalable ruby pojo" do
+  it "provides getters" do
+    expect(@obj.one).to be_eql("one")
+    expect(@obj.two).to be_eql("two")
+  end
+  it "provides setters" do
+    @obj.one = "1"
+    @obj.two = "2"
+    expect(@obj.two).to be_eql("2")
+    expect(@obj.one).to be_eql("1")
+  end
+  it "#clear_attribute sets given attribute to nil." do
+    expect(@obj.two).to be_eql("two")
+    expect(@obj.clear_two).to be_nil
+  end
+  it "#attribute? returns true or false based on contents of attribute." do
+    expect(@obj.two?).to be true
+    @obj.two = false
+    expect(@obj.two?).to be false
+    @obj.clear_two
+    expect(@obj.two?).to be false
+    expect(@obj.three?).to be true
+    expect(@obj.four?).to be true
+    @obj.clear_three
+    expect(@obj.three?).to be false
+    @obj.clear_four
+    expect(@obj.four?).to be false
+  end
+  it "#attribute? returns false when attribute is not defined or unknown" do
+    expect(@obj.address?).to be false
+  end
+  it "raises an 'NoMethodError' error when attribute does not exist" do
+    expect { @obj.address }.to raise_error NoMethodError
+  end
+  context "transformations are enabled with " do
+    it "#to_json method returns a serialized version of this object." do
+      expect(object.to_json).to include(":\"")
+    end
+    it "#to_xml method returns a serialized version of this object." do
+      expect(object.to_xml).to include("xml version")
+    end
+    it "#to_hash method returns a serialized version of this object." do
+      expect(object.to_hash).to be_a(Hash)
+    end
+    it "#attributes method returns original input hash." do
+      expect(object.attributes).to be_a(Hash)
+    end
+  end
+end