dynamic_fieldsets 0.0.3 → 0.0.4

data/spec/models/fieldset_associator_spec.rb

@@ -77,56 +77,169 @@ describe FieldsetAssociator do
     before(:each) do
       @fsa = FieldsetAssociator.new
 
-      @field = mock_model(DynamicFieldsets::Field)
-      @field.stub!(:id).and_return(37)
+      @field = mock_model DynamicFieldsets::Field
+      @fieldset_child = mock_model DynamicFieldsets::FieldsetChild
+      @fieldset_child.stub!(:child).and_return @field
+      @fieldset_child.stub!(:id).and_return 37
 
-      @field_record = mock_model(DynamicFieldsets::FieldRecord)
-      @field_record.stub!(:field).and_return(@field)
-      @field_record.stub!(:value).and_return("forty two")
-      @field_record.stub!(:id).and_return(42)
+      @field_record = mock_model DynamicFieldsets::FieldRecord
+      @field_record.stub!(:fieldset_child).and_return @fieldset_child
+      @field_record.stub!(:value).and_return 42
 
-      @fsa.stub!(:field_records).and_return([@field_record, @field_record])
+      @fsa.stub!(:field_records).and_return [@field_record, @field_record]
     end
 
-    it "should return a hash"  do
-      @field.stub!(:field_type).and_return("")
+    it "returns a hash" do
+      @fieldset_child.child.stub!(:field_type).and_return ''
       @fsa.field_values.should be_a_kind_of Hash
     end
 
-    it "should call field_records" do
-      @fsa.should_receive(:field_records).and_return([])
+    it "calls field_records" do
+      @fsa.should_receive(:field_records).and_return []
       @fsa.field_values
     end
 
     # I am aware these two tests aren't really realistic because ids should be different
     # Results should be consistent with these when ids are different
-    it "should return multiple select values as an array of ids" do
-      pending "Pending for 0.0.3 release"
-      @field.stub!(:field_type).and_return("multiple_select")
+    it "returns multiple select values as an array of ids" do
+      @fieldset_child.child.stub!(:field_type).and_return 'multiple_select'
       @fsa.field_values.should == { 37 => [42, 42] }
     end
 
-    it "should return checkboxes values as an array of ids" do
-      pending "Pending for 0.0.3 release"
-      @field.stub!(:field_type).and_return("checkbox")
+    it "returns checkboxes values as an array of ids" do
+      @field.stub!(:field_type).and_return 'checkbox'
       @fsa.field_values.should == { 37 => [42, 42] }
     end
 
-    it "should return select values as an id" do
-      pending "Pending for 0.0.3 release"
-      @field.stub!(:field_type).and_return("select")
+    it "returns select values as an id" do
+      @field.stub!(:field_type).and_return 'select'
       @fsa.field_values.should == { 37 => 42 }
     end
 
-    it "should return radio values as an id" do
-      pending "Pending for 0.0.3 release"
-      @field.stub!(:field_type).and_return("radio")
+    it "returns radio values as an id" do
+      @field.stub!(:field_type).and_return 'radio'
       @fsa.field_values.should == { 37 => 42 }
     end
 
-    it "should return all other field types as strings" do
-      @field.stub!(:field_type).and_return("text")
+    it "returns all other field types as strings" do
+      @field.stub!(:field_type).and_return 'textfield'
+      @field_record.stub!(:value).and_return 'forty two'
       @fsa.field_values.should == { 37 => "forty two" }
     end
   end
+
+  describe "dependency_child_hash and look_for_dependents" do
+    before(:each) do
+      @fsa = FieldsetAssociator.new
+
+      @fieldset1 = Fieldset.new
+      @fieldset1.stub!(:id).and_return(100)
+      @fieldset2 = Fieldset.new
+      @fieldset2.stub!(:id).and_return(200)
+
+      @field1 = Field.new
+      @field1.stub!(:id).and_return(100)
+      @field2 = Field.new
+      @field2.stub!(:id).and_return(200)
+
+      @fsa.stub!(:fieldset_id).and_return(100)
+      @fsa.stub!(:fieldset).and_return(@fieldset1)
+
+      @fsc1 = FieldsetChild.new
+      @fsc1.stub!(:id).and_return(100)
+      @fsc1.stub!(:fieldset_id).and_return(@fieldset1.id)
+      @fsc1.stub!(:child_id).and_return(@fieldset2.id)
+      @fsc1.stub!(:child_type).and_return("DynamicFieldsets::Fieldset")
+      @fsc1.stub!(:child).and_return(@fieldset2)
+      @fieldset1.stub!(:fieldset_children).and_return([@fsc1])
+
+      @fsc2 = FieldsetChild.new
+      @fsc2.stub!(:id).and_return(200)
+      @fsc2.stub!(:fieldset_id).and_return(@fieldset2.id)
+      @fsc2.stub!(:child_id).and_return(@field1.id)
+      @fsc2.stub!(:child_type).and_return("DynamicFieldsets::Field")
+      @fsc2.stub!(:child).and_return(@field1)
+
+      @fsc3 = FieldsetChild.new
+      @fsc3.stub!(:id).and_return(300)
+      @fsc3.stub!(:fieldset_id).and_return(@fieldset2.id)
+      @fsc3.stub!(:child_id).and_return(@field2.id)
+      @fsc3.stub!(:child_type).and_return("DynamicFieldsets::Field")
+      @fsc3.stub!(:child).and_return(@field2)
+
+      @fieldset2.stub!(:fieldset_children).and_return([@fsc2, @fsc3])
+
+      @group = DependencyGroup.new
+      @group.stub!(:id).and_return(100)
+      @group.stub!(:fieldset_child_id).and_return(@fsc3.id)
+      @group.stub!(:fieldset_child).and_return(@fsc3)
+      @group.stub!(:action).and_return("show")
+
+      @clause = DependencyClause.new
+      @clause.stub!(:id).and_return(100)
+      @clause.stub!(:dependency_group).and_return(@group)
+      @clause.stub!(:dependency_group_id).and_return(@group.id)
+      @group.stub!(:dependency_clauses).and_return([@clause])
+
+      @dependency = Dependency.new
+      @dependency.stub!(:id).and_return(100)
+      @dependency.stub!(:value).and_return(5)
+      @dependency.stub!(:relationship).and_return("equals")
+      @dependency.stub!(:dependency_clause).and_return(@clause)
+      @dependency.stub!(:dependency_clause_id).and_return(@clause.id)
+      @dependency.stub!(:fieldset_child).and_return(@fsc2)
+      @dependency.stub!(:fieldset_child_id).and_return(@fsc2.id)
+      @fsc2.stub!(:dependencies).and_return([@dependency])
+      @clause.stub!(:dependencies).and_return([@dependency])
+    end
+
+    # The next two tests are specifically for look_for_dependents
+
+    it "should update the correct array" do
+      pending
+      @fieldset_child_collection = []
+      look_for_dependents(@fieldset1)
+      @fieldset_child_collection.empty?.should be_false
+    end
+
+    it "should update the array to appropriate value" do
+      pending
+      @fieldset_child_collection = []
+      expected_results = [@fsc2]
+      look_for_dependents(@fieldset1)
+      @fieldset_child_collection.should == expected_results
+    end 
+
+    # The next few tests are specifically for dependency_child_hash
+
+    it "should return a hash" do
+      stub!(:look_for_dependents).and_return([@fsc1])
+      @fsa.dependency_child_hash.should be_a_kind_of Hash
+    end
+
+    it "should have a precise response" do
+      stub!(:look_for_dependents).and_return([@fsc1])
+      expected_results = {
+        @fsc2.id => {
+          @group.id => {
+            "action" => "show",
+            "fieldset_child_id" => @fsc3.id,
+            "field_id" => @field2.id,
+            "clause" => {
+              @clause.id => {
+                  @dependency.id => {
+                    "fieldset_child_id" => @fsc2.id,
+                    "relationship" => "equals",
+                    "value" => 5
+                  }
+              }
+            }
+          }
+        }
+      }
+      @fsa.dependency_child_hash.should == expected_results
+    end
+
+  end
+
 end

data/spec/models/fieldset_child_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+include DynamicFieldsets
+
+describe FieldsetChild do
+  include FieldsetChildHelper
+
+  it "should respond to fieldset" do
+    FieldsetChild.new.should respond_to :fieldset
+  end
+
+  it "should respond to child" do
+    FieldsetChild.new.should respond_to :child
+  end
+
+  it "should respond to dependency_group" do
+    FieldsetChild.new.should respond_to :dependency_group
+  end
+
+  it "should respond to field_records" do
+    FieldsetChild.new.should respond_to :field_records
+  end
+
+  it "should respond to order_num" do
+    FieldsetChild.new.should respond_to :order_num
+  end
+
+  describe "validations" do
+    before(:each) do
+      @fieldset_child = FieldsetChild.new
+    end
+    it "are valid" do
+      @fieldset_child.attributes = valid_attributes
+      @fieldset_child.should be_valid
+    end
+    
+    it "require fieldset" do
+      @fieldset_child.should have(1).error_on(:fieldset_id)
+    end
+
+    it "require child" do
+      @fieldset_child.should have(1).error_on(:child_id)
+      @fieldset_child.should have(1).error_on(:child_type)
+    end
+
+    it "require order_num" do
+      @fieldset_child.stub!(:assign_order)
+      @fieldset_child.should have(1).error_on(:order_num)
+    end
+
+    it "should allow a child type of 'DynamicFieldsets::Field'" do
+      @fieldset_child.child_type = "DynamicFieldsets::Field"
+      @fieldset_child.should have(0).error_on(:child_type)
+    end
+
+    it "should allow a child type of 'DynamicFieldsets::Fieldset'" do
+      @fieldset_child.child_type = "DynamicFieldsets::Fieldset"
+      @fieldset_child.should have(0).error_on(:child_type)
+    end
+
+    it "should not allow a child type if not 'DynamicFieldsets::Field' or 'DynamicFieldsets::Fieldset'" do
+      @fieldset_child.child_type = "Not Field or Fieldset"
+      @fieldset_child.should have(1).error_on(:child_type)
+    end
+ 
+    it "should not allow duplicate pairings of fieldsets and fields" do
+      fieldset = Fieldset.new
+      field = Field.new
+      field.stub!(:id).and_return(100)
+      fieldset_child1 = FieldsetChild.new(:fieldset => fieldset, :child => field, :order_num => 1)
+      fieldset_child1.stub!(:id).and_return(100)
+      fieldset_child2 = FieldsetChild.new(:fieldset => fieldset, :child => field, :order_num => 2)
+      FieldsetChild.stub!(:where).and_return([fieldset_child1])
+      fieldset_child2.should have(1).error_on(:child_id)
+    end
+
+    # this should have two errors, because it's also a loop
+    it "cannot be it's own parent" do
+      fieldset = Fieldset.new
+      fieldset.stub!(:id).and_return(100)
+      fieldset_child = FieldsetChild.new(:fieldset_id => fieldset.id, :child => fieldset, :order_num => 1)
+      fieldset_child.should have(2).error_on(:child_id)
+    end
+  
+    it "should not allow a parent fieldset when it would create a cycle" do
+      fieldset1 = Fieldset.new
+      fieldset1.stub!(:id).and_return(100)
+      fieldset2 = Fieldset.new
+      fieldset2.stub!(:id).and_return(200)
+      fieldset3 = Fieldset.new
+      fieldset3.stub!(:id).and_return(300)
+      fieldset_child1 = FieldsetChild.create(:fieldset_id => fieldset1.id, :child => fieldset2, :order_num => 1)
+      fieldset_child2 = FieldsetChild.create(:fieldset_id => fieldset2.id, :child => fieldset3, :order_num => 1)
+      fieldset_child3 = FieldsetChild.new(:fieldset_id => fieldset3.id, :child => fieldset1, :order_num => 1)
+      fieldset_child3.should have(1).error_on(:child_id)
+    end
+  end
+
+  describe "to_hash method" do
+    it "needs specs"
+  end
+
+  describe "root_fieldset method" do
+    before(:each) do
+      # too many issues with stubbing, getting lazy and saving
+      # could be refactored at some point
+
+      @field = Field.create({ :name => "Test field name", :label => "Test field label", :field_type => "textfield", :required => true, :enabled => true, })
+      @fieldset = Fieldset.create({:name => "Hire Form", :description => "Hire a person for a job", :nkey => "hire_form"})
+      @root_fieldset = Fieldset.create({:name => "Hire Form2", :description => "Hire a person for a job2", :nkey => "hire_form2"})
+
+      @field_child = FieldsetChild.create(:child => @child, :fieldset => @fieldset, :order_num => 1)
+      @child = FieldsetChild.create(:child => @fieldset, :fieldset => @root_fieldset, :order_num => 2)
+    end
+    it "should return a fieldset if it is not present as the child in fieldset child" do
+      @child.root_fieldset.should == @root_fieldset
+    end
+
+    it "should recurse if the fieldset is present as a child in a fieldset child" do
+      @field_child.root_fieldset.id.should == @root_fieldset.id
+    end
+  end
+end

data/spec/models/fieldset_spec.rb

@@ -4,19 +4,16 @@ include DynamicFieldsets
 describe Fieldset do
   include FieldsetHelper
 
-  it "should respond to fields" do
-    fieldset = Fieldset.new
-    fieldset.should respond_to :fields
+  it "should respond to parent" do 
+    Fieldset.new.should respond_to :parent
   end
 
-  it "should respond to parent_fieldset" do 
-    fieldset = Fieldset.new
-    fieldset.should respond_to :parent_fieldset
+  it "should respond to child_fields" do
+    Fieldset.new.should respond_to :child_fields
   end
 
   it "should respond to child_fieldsets" do
-    fieldset = Fieldset.new
-    fieldset.should respond_to :child_fieldsets
+    Fieldset.new.should respond_to :child_fieldsets
   end
   
   describe "validations" do
@@ -24,18 +21,11 @@ describe Fieldset do
       @fieldset = Fieldset.new
     end
 
-    it "should be valid as a top level fieldset" do
-      @fieldset.attributes = valid_root_attributes
+    it "should be valid" do
+      @fieldset.attributes = valid_attributes
       @fieldset.nkey = "top_level_nkey"
       @fieldset.should be_valid
     end
-
-    it "should be valid as a child fieldset" do
-      @fieldset.attributes = valid_child_attributes
-      @fieldset.nkey = "child_level_nkey"
-      @fieldset.should be_valid
-    end
-
     it "should require a name" do
       @fieldset.should have(1).error_on(:name)
     end
@@ -49,51 +39,60 @@ describe Fieldset do
     end
 
     it "should require a unique nkey" do
-      Fieldset.create(valid_root_attributes)
-      @fieldset.attributes = valid_root_attributes
+      Fieldset.create(valid_attributes)
+      @fieldset.attributes = valid_attributes
       @fieldset.should have(1).error_on(:nkey)
     end
-
-    it "should not require an order number if there is no parent fieldset" do
-      @fieldset.should have(0).error_on(:order_num)
-    end
-
-    it "should require an order number if there is a parent fieldset" do
-      @fieldset.parent_fieldset = Fieldset.new
-      @fieldset.should have(1).error_on(:order_num)
-    end
-  
-    it "should not allow a parent fieldset when it would create a cycle" do
-      fieldset1 = Fieldset.new(:nkey => "fieldset1")
-      fieldset2 = Fieldset.new(:parent_fieldset => fieldset1, :nkey => "fieldset2")
-      fieldset3 = Fieldset.new(:parent_fieldset => fieldset2, :nkey => "fieldset3")
-      fieldset1.parent_fieldset = fieldset3
-
-      fieldset1.should have(1).error_on(:parent_fieldset)
-    end
   end
 
-  describe "roots scope" do
+  describe ".roots scope" do
     before(:each) do
-      @root_fieldset = Fieldset.new( valid_root_attributes )
+      # we could stub this one but I am not convinced the polymorphic relationships actually work
+      @root_fieldset = Fieldset.new( valid_attributes )
       @root_fieldset.save
 
-      @child_fieldset = Fieldset.new( valid_child_attributes )
+      @child_fieldset = Fieldset.new( valid_attributes )
+      @child_fieldset.nkey = "something_else" # need to pass validations
       @child_fieldset.save
+
+      @fieldset_children = FieldsetChild.new(:child => @child_fieldset, :fieldset => @root_fieldset, :order_num => 1)
+      @fieldset_children.save
     end
     
-    it "should respond to roots scope" do
+    it ": Fieldset responds to .roots" do
       Fieldset.should respond_to :roots
     end
     
-    it "should return fieldsets with no parent fieldset" do
+    it "returns fieldsets with no parent" do
       roots = Fieldset.roots
-      roots.select{ |f| f.parent_fieldset.nil? }.should have(1).fieldset
+      roots.each do |root|
+        root.parent.should be_nil
+      end
     end
     
-    it "should not return fieldsets with a parent fieldset" do
+    it "does not return fieldsets with a parent" do
       roots = Fieldset.roots
-      roots.select{ |f| !f.parent_fieldset.nil? }.should have(0).fieldset
+      roots.should_not include @child_fieldset
+    end
+  end
+
+  describe ".root? method" do
+    before(:each) do
+      @fieldset = Fieldset.new
+    end
+
+    it "calls parent" do  
+      @fieldset.should_receive(:parent).and_return nil
+      @fieldset.root?
+    end
+
+    it "returns true if parent is nil" do
+      @fieldset.stub!(:parent).and_return nil
+      @fieldset.root?.should be_true
+    end
+    it "returns false if parent is not nil" do
+      @fieldset.stub!(:parent).and_return "some object goes here"
+      @fieldset.root?.should be_false
     end
   end
 
@@ -105,63 +104,62 @@ describe Fieldset do
     end
   end
 
+  # gave up on stubs and mocks on this one due to how the data is constantized
   describe "children method" do
     before(:each) do
-      @root_fieldset = Fieldset.new( valid_root_attributes )
+      @root_fieldset = Fieldset.new( valid_attributes )
+      @root_fieldset.stub!(:id).and_return(1234)
       
-      @child_fieldset = mock_model Fieldset
-      @child_fieldset.stub!(:id).and_return 2
-      @child_fieldset.stub!(:order_num).and_return 1
-      @child_fieldset.stub!(:name).and_return
+      @child_fieldset = Fieldset.new( valid_attributes )
+      @child_fieldset.nkey = "child_fieldset"
+      @child_fieldset.save
+      @cfs = FieldsetChild.new(:child => @child_fieldset, :fieldset => @root_fieldset, :order_num => 1)
       
-      @field1 = mock_model Field
-      @field1.stub!(:id).and_return 1
-      @field1.stub!(:order_num).and_return 2
-      @field1.stub!(:name).and_return 'z-field'
-      @field1.stub!(:enabled).and_return true
+      @field1 = Field.new(
+        :name => "Test field name",
+        :label => "Test field label",
+        :field_type => "textfield",
+        :required => true,
+        :enabled => true)
+      @field1.save
+      @cf1 = FieldsetChild.new(:child => @field1, :fieldset => @root_fieldset, :order_num => 2)
       
-      @field2 = mock_model Field
-      @field2.stub!(:id).and_return 2
-      @field2.stub!(:order_num).and_return 2
-      @field2.stub!(:name).and_return 'a-field'
-      @field2.stub!(:enabled).and_return true
+      @field2 = Field.new(
+        :name => "Test field name",
+        :label => "Test field label",
+        :field_type => "textfield",
+        :required => true,
+        :enabled => false)
+      @field2.save
+      @cf2 = FieldsetChild.new(:child => @field2, :fieldset => @root_fieldset, :order_num => 3)
       
+      @root_fieldset_children = [@cfs, @cf1, @cf2]
+      @root_fieldset.stub!(:fieldset_children).and_return(@root_fieldset_children)
     end
     
     it "should respond to children" do
       @root_fieldset.should respond_to :children
     end
     
-    it "should call fields and return them" do
-      @root_fieldset.should_receive(:fields).and_return [@field1]
-      @root_fieldset.children.should include @field1
-    end
-    
-    it "should call child_fieldsets and return them" do
-      @root_fieldset.should_receive(:child_fieldsets).and_return [@child_fieldset]
-      @root_fieldset.children.should include @child_fieldset
+    it "should call fieldset children" do
+      @root_fieldset.should_receive(:fieldset_children).and_return(@root_fieldset_children)
+      children = @root_fieldset.children
     end
-    
+
     it "should return a mixture of fieldsets and fields" do
-      @root_fieldset.stub!(:fields).and_return [@field1]
-      @root_fieldset.stub!(:child_fieldsets).and_return [@child_fieldset]
       children = @root_fieldset.children
       children.should include @field1
       children.should include @child_fieldset
     end
-    
-    it "should maintain the order of the children regardless of class" do
-      @root_fieldset.stub!(:fields).and_return [@field1]
-      @root_fieldset.stub!(:child_fieldsets).and_return [@child_fieldset]
+
+    it "should not include disabled fields" do
       children = @root_fieldset.children
-      children.first.should == @child_fieldset
-      children.last.should == @field1
+      children.should_not include @field2
     end
     
-    it "should handle duplicate order numbers by alphabetical order of name" do
-      @root_fieldset.stub!(:fields).and_return [@field1, @field2]
+    it "should maintain the order of the children regardless of class" do
       children = @root_fieldset.children
-      children.first.should == @field2
+      children.first.should == @child_fieldset
       children.last.should == @field1
     end
   end

data/spec/support/dependency_group_helper.rb

@@ -0,0 +1,9 @@
+# Helper for the dependency group model to create valid attributes
+module DependencyGroupHelper 
+  def valid_attributes
+    {
+      :fieldset_child_id => 42,
+      :action => "show",
+    }
+  end
+end

data/spec/support/dependency_helper.rb

@@ -0,0 +1,13 @@
+# Helper for the field model to create valid attributes
+module DependencyHelper
+  # this has issues with not being able to set type
+  # I am manually setting it where it is needed to avoid problems
+  def valid_attributes
+    {
+      :fieldset_child_id => 100,
+      :relationship => "equals",
+      :value => "test string",
+      :dependency_clause_id => 100
+    }
+  end
+end

data/spec/support/field_helper.rb

@@ -4,13 +4,11 @@ module FieldHelper
   # I am manually setting it where it is needed to avoid problems
   def valid_attributes
     {
-      :fieldset_id => 1,
       :name => "Test field name",
       :label => "Test field label",
       :field_type => "textfield",
       :required => true,
       :enabled => true,
-      :order_num => 1
     }
   end
 end

data/spec/support/fieldset_child_helper.rb

@@ -0,0 +1,10 @@
+module FieldsetChildHelper
+  def valid_attributes
+    {
+      :child_id => 1,
+      :child_type => "DynamicFieldsets::Field",
+      :fieldset_id => 1,
+      :order_num => 1
+    }
+  end
+end

data/spec/support/fieldset_helper.rb

@@ -1,28 +1,12 @@
 # Helper for the fieldset to create valid attributes and other data used in multiple tests
 module FieldsetHelper
-  # attributes for a root fieldset with no parent
+  # attributes for a fieldset
   # @returns [Hash] all attributes needed to pass validations
-  def valid_root_attributes
+  def valid_attributes
     {
-      :id => 1,
       :name => "Hire Form",
       :description => "Hire a person for a job",
       :nkey => "hire_form"
     }
   end
-
-  # attributes for a child fieldset with a parent
-  # the parent_fieldset may be wrong
-  # @returns [Hash] all attributes needed to pass validations
-  def valid_child_attributes
-    {
-      :name => "Hire Form",
-      :description => "Hire a person for a job",
-      :nkey => "hire_form",
-      :order_num => 1,
-      :parent_fieldset_id => 1
-    }
-      # this should be in there but isnt working right now
-      #:parent_fieldset => DynamicFieldset::Fieldset.new
-  end
 end