dynamic_fieldsets 0.0.2

data/spec/dynamic_fieldsets_helper_spec.rb

@@ -0,0 +1,254 @@
+require 'spec_helper'
+include DynamicFieldsets
+
+describe DynamicFieldsetsHelper do
+  include DynamicFieldsetsHelper
+  include FieldsetHelper
+  describe ".dynamic_fieldset_renderer" do
+    before(:each) do
+      @fsa = mock_model(FieldsetAssociator)
+      @fsa.stub!(:fieldset).and_return mock_model(Fieldset)
+      @fsa.stub!(:field_values).and_return []
+      stub!(:fieldset_renderer).and_return []
+    end
+
+    it "should include a form object and a field set associator object" do
+      lambda { dynamic_fieldset_renderer(@fsa, "form") }.should_not raise_error
+    end
+
+    it "should call the fieldset_renderer with the fsa's root fieldset" do
+      @fsa.should_receive(:fieldset)
+      dynamic_fieldset_renderer(@fsa, "form")
+    end
+
+    it "should return a string of html" do
+      dynamic_fieldset_renderer(@fsa, "form").should be_a_kind_of String
+    end
+  end
+
+  describe "dynamic_fieldset_form_renderer method" do
+    it "should call dynamic_fieldset_renderer with 'form'" do
+      fsa = mock_model(FieldsetAssociator)
+      self.should_receive(:dynamic_fieldset_renderer).with(fsa, "form")
+      dynamic_fieldset_form_renderer(fsa)
+    end
+  end
+
+  describe "dynamic_fieldset_show_renderer" do
+    it "should call dynamic_fieldset_renderer with 'show'" do
+      fsa = mock_model(FieldsetAssociator)
+      self.should_receive(:dynamic_fieldset_renderer).with(fsa, "show")
+      dynamic_fieldset_show_renderer(fsa)
+    end
+  end
+
+  describe ".fieldset_renderer" do
+    before(:each) do
+      @fsa = mock_model(FieldsetAssociator)
+      @fieldset = Fieldset.new
+      @fieldset.stub!(:id).and_return 326
+      @values = {}
+      @form_type = "form"
+    end
+
+    it "should include the fsa object, fieldset object, and a values hash" do
+      lambda { fieldset_renderer(@fsa,@fieldset,@values, @form_type) }.should_not raise_error
+    end
+
+    it "should call the children method on the fieldset object" do
+      @fieldset.should_receive(:children).and_return []
+      fieldset_renderer(@fsa,@fieldset,@values, @form_type)
+    end
+    
+    it "should call the field_renderer method if the current child is a field" do
+      @field = mock_model(Field)
+      @fieldset.stub!(:children).and_return [@field]
+      self.should_receive(:field_renderer).and_return []
+      fieldset_renderer(@fsa,@fieldset,@values, @form_type)
+    end
+    
+    it "should call the fieldset_renderer recursively if the current child is a fieldset" do
+      @child_fieldset = mock_model(Fieldset)
+      @fieldset.stub!(:children).and_return [@child_fieldset]
+      self.should_receive(:fieldset_renderer)
+      fieldset_renderer(@fsa,@fieldset,@values, @form_type)
+    end
+
+    it "should include markup for the fieldset itself" do
+      fieldset_renderer(@fsa,@fieldset,@values, @form_type).should satisfy {
+        |x| !x.select{ |v| v =~ /id='fieldset-326'/ }.nil?
+      }
+    end
+    
+    it "should return a array of html elements" do
+      fieldset_renderer(@fsa,@fieldset,@values, @form_type).should be_a_kind_of Array
+    end
+  end
+
+  describe ".field_form_renderer" do
+    before(:each) do
+      @fsa = mock_model(FieldsetAssociator)
+      @field = Field.new
+      @field.stub!(:id).and_return 420
+      @field.stub!(:html_attributes).and_return []
+      @field.stub!(:has_default?).and_return false
+      @field.stub!(:default).and_return ""
+      @field.stub!(:field_type).and_return ""
+      @field.stub!(:options).and_return []
+      @values = []
+    end
+    
+    it "should include the form object, the field object, and an array of values" do
+      lambda { field_form_renderer(@fsa,@field,@values) }.should_not raise_error
+    end
+
+    it "should call the html_attributes method for the field" do
+      @field.should_receive(:field_html_attributes).and_return([])
+      field_form_renderer(@fsa,@field,@values)
+    end
+
+    it "should call the field_options method for the field if it is a select" do
+      @field.stub!(:field_type).and_return 'select'
+      @field.should_receive(:options)
+      field_form_renderer(@fsa,@field,@values)
+    end
+    
+    it "should call the field_options method for the field if it is a multiple select" do
+      @field.stub!(:field_type).and_return 'multiple_select'
+      @field.should_receive(:options)
+      field_form_renderer(@fsa,@field,@values)
+    end
+    
+    it "should call the field_options method for the field if it is a checkbox" do
+      @field.stub!(:field_type).and_return 'checkbox'
+      @field.should_receive(:options)
+      field_form_renderer(@fsa,@field,@values)
+    end
+    
+    it "should call the field_options method for the field if it is a radio" do
+      @field.stub!(:field_type).and_return 'radio'
+      @field.should_receive(:options)
+      field_form_renderer(@fsa,@field,@values)
+    end
+    
+    
+    ## HELPER TAGS
+    
+    it "should have a label tag" do
+      field_form_renderer(@fsa,@field,@values).should satisfy {
+        |x| !x.select{ |v| v =~ /<label for=/ }.nil?
+      }
+    end
+    
+    it "should call select_tag if the type is select" do
+      @field.stub!(:field_type).and_return 'select'
+      should_receive(:select_tag)
+      field_form_renderer(@fsa,@field,@values)
+    end
+    
+    it "should call select_tag if the type is multiple select" do
+      @field.stub!(:field_type).and_return 'multiple_select'
+      should_receive(:select_tag)
+      field_form_renderer(@fsa,@field,@values)
+    end
+    
+    it "should call text_field if the type is textfield" do
+      @field.stub!(:field_type).and_return 'textfield'
+      should_receive(:text_field)
+      field_form_renderer(@fsa,@field,@values)
+    end
+
+    it "should call check_box if the type is checkbox" do
+      option = mock_model(FieldOption)
+      option.stub!(:name).and_return ""
+      @field.stub!(:field_type).and_return 'checkbox'
+      @field.stub!(:options).and_return [option]
+      should_receive(:check_box)
+      field_form_renderer(@fsa,@field,@values)
+    end
+    
+    it "should call radio_button if the type is radio" do
+      option = mock_model(FieldOption)
+      option.stub!(:name).and_return ""
+      @field.stub!(:field_type).and_return 'radio'
+      @field.stub!(:options).and_return [option]
+      should_receive(:radio_button)
+      field_form_renderer(@fsa,@field,@values)
+    end
+    
+    it "should have a text_area tag if the type is textarea" do
+      field_form_renderer(@fsa,@field,@values).should satisfy {
+        |x| !x.select{ |v| v =~ /<textarea/ }.nil?
+      }
+    end
+
+    it "should call date_select if the type is date" do
+      @field.stub!(:field_type).and_return 'date'
+      should_receive(:date_select)
+      field_form_renderer(@fsa,@field,@values)
+    end
+
+    it "should call datetime_select if the type is datetime" do
+      @field.stub!(:field_type).and_return 'datetime'
+      should_receive(:datetime_select)
+      field_form_renderer(@fsa,@field,@values)
+    end
+
+
+    it "should return an array of html" do
+      field_form_renderer(@fsa,@field,@values).should be_a_kind_of Array
+    end
+  end
+
+  describe "field_show_renderer method" do
+    before(:each) do
+      @fsa = mock_model(FieldsetAssociator)
+      @field = Field.new
+      @field.stub!(:id).and_return 420
+      @values = []
+    end
+
+    it "should return an array of strings" do
+      result = field_show_renderer(@fsa, @field, @values)
+      result.should be_a_kind_of Array
+    end
+
+    it "should include the class dynamic_fieldsets_field" do
+      field_show_renderer(@fsa, @field, @values).join().should match /dynamic_fieldsets_field/
+    end
+
+    it "should include the class dynamic_fieldsets_field_label" do
+      field_show_renderer(@fsa, @field, @values).join().should match /dynamic_fieldsets_field_label/
+    end
+
+    it "should include the class dynamic_fieldsets_field_value" do
+      field_show_renderer(@fsa, @field, @values).join().should match /dynamic_fieldsets_field_value/
+    end
+
+    it "should return 'No answer given' if the field has no answer for the current fieldset associator" do
+      field_show_renderer(@fsa, @field, nil).join().should match /No answer given/
+    end
+  end
+  
+  describe "field_renderer method" do
+    before(:each) do
+      @fsa = mock_model(FieldsetAssociator)
+      @field = Field.new
+      @values = []
+    end
+    
+    it "should call the form helper if the form_type is form" do
+      self.should_receive(:field_form_renderer)
+      field_renderer(@fsa, @field, @values, "form")
+    end
+
+    it "should default to the show helper if the form_type is not form" do
+      self.should_receive(:field_show_renderer)
+      field_renderer(@fsa, @field, @values, "show")
+    end
+  end
+
+  describe "populate method" do
+    it "needs tests"
+  end
+end

data/spec/dynamic_fieldsets_in_model_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+include DynamicFieldsets
+
+describe DynamicFieldsetsInModel do
+
+  it "should respond to acts_as_dynamic_fieldset" do
+    InformationForm.should respond_to :acts_as_dynamic_fieldset
+  end
+
+  it "should respond to fieldset_associator" do
+    InformationForm.new.should respond_to :fieldset
+  end
+
+  it "should respond to fieldset" do
+    InformationForm.new.should respond_to :fieldset_associator
+  end
+
+  describe "acts_as_dynamic_fieldset class method" do
+    before(:each) do
+      @model = InformationForm.new
+    end
+
+    it "should initialize the dynamic_fieldsets field" do
+      @model.should respond_to :dynamic_fieldsets
+    end
+
+    it "should include the instance methods" do
+      @model.should be_a_kind_of (DynamicFieldsets::DynamicFieldsetsInModel::InstanceMethods)
+    end
+  end
+
+  describe "method missing method" do
+    before(:each) do
+      @model = InformationForm.new
+      @model.stub!(:fieldset_associator)
+      @model.stub!(:fieldset)
+    end
+
+    it "should call match_fieldset_associator?" do
+      @model.should_receive(:match_fieldset_associator?).and_return(true)
+      @model.some_method
+    end
+
+    it "should call fieldset_associator if match_fieldset_associator? returns true" do
+      @model.stub!(:match_fieldset_associator?).and_return(true)
+      @model.should_receive(:fieldset_associator)
+      @model.some_method
+    end
+
+    it "should call match_fieldset?" do
+      @model.stub!(:match_fieldset_associator?).and_return(false)
+      @model.should_receive(:match_fieldset?).and_return(true)
+      @model.some_method
+    end
+
+    it "should call fieldset if match_fieldset? returns true" do
+      @model.stub!(:match_fieldset_associator?).and_return(false)
+      @model.stub!(:match_fieldset?).and_return(true)
+      @model.should_receive(:fieldset)
+      @model.some_method
+    end
+  end
+
+  describe "respond_to? method" do
+    before(:each) do
+      @model = InformationForm.new
+    end
+
+    it "should call match_fieldset_associator?" do
+      @model.should_receive(:match_fieldset_associator?)
+      @model.respond_to?(:some_method)
+    end
+
+    it "should call match_fieldset?" do
+      @model.stub!(:match_fieldset_associator?).and_return(false)
+      @model.should_receive(:match_fieldset?)
+      @model.respond_to?(:some_method)
+    end
+  end
+
+  describe "match_fieldset_associator? method" do
+    before(:each) do
+      @model = InformationForm.new
+      @model.stub!(:dynamic_fieldsets).and_return({:child_form => []})
+    end
+
+    it "should call dynamic_fieldsets" do
+      @model.should_receive(:dynamic_fieldsets).and_return({:child_form => []})
+      @model.match_fieldset_associator?(:some_method)
+    end
+
+    it "should return true if the sym parameter matches a key in dynamic_fieldsets" do
+      @model.match_fieldset_associator?(:child_form).should be_true
+    end
+
+    it "should return false if the sym parameter does not match a key in dynamic_fieldsets" do
+      @model.match_fieldset_associator?(:not_child_form).should be_false
+    end
+  end
+
+  # need to be abvle to call child_form_fieldset to get the fieldset object
+  # because child_form does not exist in the fsa model until after it is created
+  describe "match_fieldset? method" do
+    before(:each) do
+      @model = InformationForm.new
+      @model.stub!(:dynamic_fieldsets).and_return({:child_form => []})
+    end
+
+    it "should call dynamic_fieldsets if the calling method includes _fieldset" do
+      @model.should_receive(:dynamic_fieldsets).and_return({:child_form => []})
+      @model.match_fieldset?(:some_method_fieldset)
+    end
+
+    it "should return true if the sym parameter matches a key in dynamic_fieldsets followed by the word fieldset" do
+      @model.match_fieldset?(:child_form_fieldset).should be_true
+    end
+
+    it "should return false if the sym parameter does not match a key in dynamic_fieldsets followed by the word fieldset" do
+      @model.match_fieldset?(:not_child_form_fieldset).should be_false
+    end
+
+    it "should return false if the sym parameter matches a key in dynamic_fieldsets not followed by the word fieldset" do
+      @model.match_fieldset?(:child_form).should be_false
+    end
+  end
+
+  describe "fieldset_associator method" do
+    before(:each) do
+      @model = InformationForm.new
+      @model.stub!(:dynamic_fieldsets).and_return({:child_form => {:fieldset => :fingerprint_form}})
+      @fsa = DynamicFieldsets::FieldsetAssociator.new(:fieldset_model_id => 1234, :fieldset_model_type => "InformationForm", :fieldset_model_name => :child_form)
+      DynamicFieldsets::FieldsetAssociator.stub!(:find_by_fieldset_model_parameters).and_return(@fsa)
+    end
+
+    it "should return the fieldset associator object for the specified dynamic fieldset" do
+      DynamicFieldsets::FieldsetAssociator.should_receive(:find_by_fieldset_model_parameters).and_return([@fsa])
+      @model.fieldset_associator(:child_form).should == @fsa
+    end
+
+    it "should create a new fieldset associator object if one does not exist" do
+      DynamicFieldsets::FieldsetAssociator.stub!(:find_by_fieldset_model_parameters).and_return([])
+      DynamicFieldsets::FieldsetAssociator.stub!(:create).and_return(@fsa)
+
+      # don't know why I need this, should be handled by the create stub
+      @model.fieldset_associator(:child_form).should == @fsa
+    end
+
+    it "should return nil if the sym param does not match a key in the dynamic_fieldsets field" do
+      @model.fieldset_associator(:not_child_form).should be_nil
+    end
+  end
+
+  describe "fieldset method" do
+    before(:each) do
+      @model = InformationForm.new
+      @model.stub!(:dynamic_fieldsets).and_return({:child_form => {:fieldset => :fingerprint_form}})
+      @fieldset = DynamicFieldsets::Fieldset.new(:nkey => :fingerprint_form)
+      DynamicFieldsets::Fieldset.stub!(:find_by_nkey).and_return(@fieldset)
+    end
+
+    it "should call find_by_nkey for the fieldset model" do
+      DynamicFieldsets::Fieldset.should_receive(:find_by_nkey).and_return(@fieldset)
+      @model.fieldset(:child_form)
+    end
+
+    it "should return the fieldset object for the specified dynamic fieldset" do
+      @model.fieldset(:child_form).should == @fieldset
+    end
+      
+    it "should return nil if the sym param does not match a kyer in the dynamic_fieldsets field" do
+      @model.fieldset(:not_child_form).should be_nil
+    end
+  end
+end

data/spec/dynamic_fieldsets_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe DynamicFieldsets do
+  it "should be valid" do
+    DynamicFieldsets.should be_a(Module)
+  end
+end

data/spec/integration/navigation_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "Navigation" do
+  include Capybara
+  
+  it "should be a valid app" do
+    ::Rails.application.should be_a(Dummy::Application)
+  end
+end

data/spec/models/field_default_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+include DynamicFieldsets
+  
+describe FieldDefault do
+  include FieldDefaultHelper
+
+  it "should respond to field" do
+    field_default = FieldDefault.new
+    field_default.should respond_to :field
+  end
+  
+  describe "validations" do
+    before(:each) do
+      @field_default = FieldDefault.new
+    end
+
+    it "should be valid" do
+      @field_default.attributes = valid_attributes
+      @field_default.should be_valid
+    end
+
+    it "should require a label" do
+      @field_default.should have(1).error_on(:value)
+    end
+  end  
+end

data/spec/models/field_html_attribute_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+include DynamicFieldsets
+  
+describe FieldHtmlAttribute do
+  include FieldHtmlAttributeHelper
+
+  it "should respond to field" do
+    field_html_attribute = FieldHtmlAttribute.new
+    field_html_attribute.should respond_to :field
+  end
+  
+  describe "validations" do
+    before(:each) do
+      @field_html_attribute = FieldHtmlAttribute.new
+    end
+
+    it "should be valid" do
+      @field_html_attribute.attributes = valid_attributes
+      @field_html_attribute.should be_valid
+    end
+
+    it "should require an attribute" do
+      @field_html_attribute.should have(1).error_on(:attribute_name)
+    end
+    
+    it "should require a value" do
+      @field_html_attribute.should have(1).error_on(:value)
+    end
+  end  
+end

data/spec/models/field_option_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+include DynamicFieldsets
+  
+describe FieldOption do
+  include FieldOptionHelper
+
+  it "should respond to field" do
+    field_option = FieldOption.new
+    field_option.should respond_to :field
+  end
+  
+  describe "validations" do
+    before(:each) do
+      @field_option = FieldOption.new
+    end
+
+    it "should be valid" do
+      @field_option.attributes = valid_attributes
+      @field_option.should be_valid
+    end
+
+    it "should require a name" do
+      @field_option.should have(1).error_on(:name)
+    end
+    it "should require enabled is a boolean value" do
+      @field_option.enabled = nil 
+      @field_option.should have(1).error_on(:enabled)
+    end
+  end  
+
+  describe "enabled scope" do
+    before(:each) do
+      @field_option1 = FieldOption.new
+      @field_option1.attributes = valid_attributes
+      @field_option1.enabled = true
+      @field_option1.save
+
+      @field_option2 = FieldOption.new
+      @field_option2.attributes = valid_attributes
+      @field_option2.enabled = false
+      @field_option2.save
+    end
+
+    it "should return enabled field options" do
+      FieldOption.enabled.should include @field_option1
+    end
+
+    it "should not return disabled field options" do
+      FieldOption.enabled.should_not include @field_option2
+    end
+  end
+end

data/spec/models/field_record_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+include DynamicFieldsets
+
+describe FieldRecord do
+  include FieldRecordHelper
+
+  it "should respond to field" do
+    FieldRecord.new.should respond_to :field
+  end
+
+  it "should respond to fieldset_associator" do
+    FieldRecord.new.should respond_to :fieldset_associator
+  end
+
+  describe "validations" do
+    before(:each) do
+      @field_record = FieldRecord.new
+    end
+    
+    it "should be valid" do
+      @field_record.field = Field.new
+      @field_record.fieldset_associator = FieldsetAssociator.new
+      @field_record.value = "42"
+      @field_record.should be_valid
+    end
+
+    it "should require field" do
+      @field_record.should have(1).error_on(:field)
+    end
+
+    it "should require fieldset_associator" do
+      @field_record.should have(1).error_on(:fieldset_associator)
+    end
+
+    it "should require value" do
+      @field_record.should have(1).error_on(:value)
+    end
+
+    it "should not error if value is a blank string" do
+      @field_record.value = ""
+      @field_record.should have(0).error_on(:value)
+    end
+  end
+end