dynamic_fieldsets 0.0.3 → 0.0.4

data/spec/models/dependency_group_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+include DynamicFieldsets
+
+describe DependencyGroup do
+  include DependencyGroupHelper
+
+  it "should respond to fieldset_child" do
+    DependencyGroup.new.should respond_to :fieldset_child
+  end
+
+  it "should respond to dependency_clauses" do
+    DependencyGroup.new.should respond_to :dependency_clauses
+  end
+
+  describe "validations" do
+    before(:each) do
+      @group = DependencyGroup.new
+    end
+
+    it "should be valid" do
+      @group.attributes = valid_attributes
+      @group.should be_valid
+    end
+
+    it "should require a fieldset_child" do
+      @group.should have(1).error_on(:fieldset_child_id)
+    end
+
+    it "should have an action" do
+      @group.should have(2).error_on(:action)
+    end
+
+    it "action should be in Action_list" do
+      @group.action = "invalid action"
+      @group.should have(1).error_on(:action)
+    end
+  end
+
+  describe "action_list method" do
+    it "should return an hash" do
+      DependencyGroup.new.action_list.should be_a_kind_of(Hash)
+    end
+  end
+
+  describe "dependency_group_fieldset_chldren method" do
+    before(:each) do
+      @fieldset_child_1 = FieldsetChild.create(:fieldset_id => 1, :child_id => 1, :child_type => "DynamicFieldsets::Field", :order_num => 1)
+      @fieldset_child_2 = FieldsetChild.create(:fieldset_id => 2, :child_id => 2, :child_type => "DynamicFieldsets::Field", :order_num => 2)
+      @fieldset_child_3 = FieldsetChild.create(:fieldset_id => 3, :child_id => 3, :child_type => "DynamicFieldsets::Field", :order_num => 3)
+      @group = DependencyGroup.create(:fieldset_child => @fieldset_child_3, :action => "show")
+      @clause = DependencyClause.create(:dependency_group => @group)
+      @dependency_1 = Dependency.create(:fieldset_child => @fieldset_child_1, :dependency_clause => @clause, :value => "5", :relationship => "equals")
+      @dependency_2 = Dependency.create(:fieldset_child => @fieldset_child_2, :dependency_clause => @clause, :value => "5", :relationship => "equals")
+      @input_hash = JSON.parse(@group.dependency_group_fieldset_children)
+    end
+
+    it "should return a hash object once parsed from json" do
+      @input_hash.should be_a_kind_of(Hash)
+    end
+    it "should return an array of fieldset children that are tied to a dependency group through the dependency clause for the value" do
+      lambda{@input_hash.has_value?([@fieldset_child_1.id, @fieldset_child_2.id])}.should be_true
+    end
+    it "should return the dependency group's fieldset child for the key" do
+      @input_hash.has_key?(@fieldset_child_3.id.to_s).should be_true
+    end
+  end
+
+  describe "dependent_fieldset_children method" do
+    before(:each) do
+      @group = DependencyGroup.new
+      @group.attributes = valid_attributes
+      @group.save
+      @clause = DependencyClause.create(:dependency_group => @group)
+      @dependency = Dependency.create(:value => 5, :relationship => "equals", :dependency_clause => @clause, :fieldset_child_id => 42)
+    end
+
+    it "should return an array" do
+      @group.dependent_fieldset_children.should be_a_kind_of(Array)
+    end
+      
+    it "should return fieldset children ids included in the group" do
+      #debugger
+      @group.dependent_fieldset_children.should include 42
+    end
+
+    it "should not return fieldset children ids not included in the group" do
+      @group.dependent_fieldset_children.should_not include 41
+    end
+  end
+
+  describe "get_action method" do
+    before(:each) do
+      @group = DependencyGroup.new
+      @group.stub!(:evaluate).and_return(true)
+      @group.action = "show"
+    end
+
+    it "should take a hash as input" do
+      @group.get_action({}).should_not raise_error ArgumentError
+    end
+
+    it "should return the success action if evaluate returns true" do
+      @group.get_action({}).should == "show"
+    end
+
+    it "should return the failure action if evaluate returns false" do
+      @group.stub!(:evaluate).and_return(false)
+      @group.get_action({}).should == "hide"
+    end
+  end
+
+  describe "evaluate method" do
+    before(:each) do
+      @group = DependencyGroup.new
+      @clause1 = DependencyClause.new
+      @clause2 = DependencyClause.new
+      @group.stub!(:dependency_clauses).and_return([@clause1, @clause2])
+      @input_values = {}
+    end
+
+    it "should take a hash as input" do
+      @group.stub!(:dependency_clauses).and_return([])
+      @group.evaluate({}).should_not raise_error ArgumentError
+    end
+
+    it "should return true if all the clauses evaluate to true" do
+      @clause1.stub!(:evaluate).and_return(true)
+      @clause2.stub!(:evaluate).and_return(true)
+      @group.evaluate(@input_values).should be_true
+    end
+
+    it "should return true if one of the clauses evaluates to false" do
+      @clause1.stub!(:evaluate).and_return(false)
+      @clause2.stub!(:evaluate).and_return(true)
+      @group.evaluate(@input_values).should be_false
+    end
+  end
+
+  describe "to_hash" do
+    before(:each) do
+      @field = Field.new
+      @field.stub!(:id).and_return 100
+
+      @fieldset_child1 = FieldsetChild.new
+      @fieldset_child1.stub!(:id).and_return 100
+      @fieldset_child2 = FieldsetChild.new
+      @fieldset_child2.stub!(:id).and_return 200
+
+      @dependency = Dependency.new
+      @dependency.stub!(:id).and_return 100
+      @dependency.stub!(:fieldset_child_id).and_return @fieldset_child1.id
+      @dependency.stub!(:relationship).and_return "equals"
+      @dependency.stub!(:value).and_return 5
+
+      @clause = DependencyClause.new
+      @clause.stub!(:id).and_return 100
+
+      @group = DependencyGroup.new
+      @group.stub!(:id).and_return 100
+      @group.stub!(:fieldset_child_id).and_return @fieldset_child2.id
+      @group.stub!(:action).and_return "show"
+    
+      @fieldset_child1.stub!(:dependencies).and_return [@dependency]
+      @dependency.stub!(:fieldset_child).and_return @fieldset_child1
+      @dependency.stub!(:dependency_clause).and_return @clause
+      @clause.stub!(:dependencies).and_return [@dependency]
+      @clause.stub!(:dependency_group).and_return @group
+      @group.stub!(:fieldset_child).and_return @fieldset_child2
+      @group.stub!(:dependency_clauses).and_return [@clause]
+      @fieldset_child2.stub!(:child).and_return @field
+      @fieldset_child2.stub!(:child_id).and_return @field.id
+    end
+
+    it "should return a hash" do
+      @group.to_hash.should be_a_kind_of Hash
+    end
+
+    it "should have a specific return structure" do
+      expected_result = {
+        "action" => @group.action,
+        "fieldset_child_id" => @fieldset_child2.id,
+        "field_id" => @field.id,
+        "clause" => {
+          @clause.id => {
+            @dependency.id => {
+              "fieldset_child_id" => @dependency.fieldset_child_id,
+              "relationship" => @dependency.relationship,
+              "value" => @dependency.value
+            }
+          }
+        }
+      }
+
+      @group.to_hash.should == expected_result
+    end
+
+    it "should have a specific return structure even with a greater complexity" do
+      fieldset_child3 = FieldsetChild.new
+      fieldset_child3.stub!(:id).and_return 300
+      
+      dependency2 = Dependency.new
+      dependency2.stub!(:id).and_return 200
+      dependency2.stub!(:relationship).and_return "equals"
+      dependency2.stub!(:value).and_return 5
+      dependency2.stub!(:fieldset_child_id).and_return fieldset_child3.id
+
+      fieldset_child3.stub!(:dependencies).and_return [dependency2]
+      dependency2.stub!(:fieldset_child).and_return fieldset_child3
+      dependency2.stub!(:dependency_clause).and_return @clause
+      @clause.stub!(:dependencies).and_return [@dependency, dependency2]
+
+      expected_result = {
+          "action" => @group.action,
+          "fieldset_child_id" => @group.fieldset_child_id,
+          "field_id" => @field.id,
+          "clause" => {
+            @clause.id => {
+              @dependency.id => {
+                "fieldset_child_id" => @dependency.fieldset_child_id,
+                "relationship" => @dependency.relationship,
+                "value" => @dependency.value
+              },
+              dependency2.id => {
+                "fieldset_child_id" => dependency2.fieldset_child_id,
+                "relationship" => dependency2.relationship,
+                "value" => dependency2.value
+              }
+            }
+          }
+      }
+
+      @group.to_hash.should == expected_result
+    end
+
+  end
+
+end

data/spec/models/dependency_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+include DynamicFieldsets
+
+describe Dependency do
+  include DependencyHelper
+
+  it "should respond to fieldset_child" do
+    Dependency.new.should respond_to :fieldset_child
+  end
+
+  it "should respond to dependency_clause" do
+    Dependency.new.should respond_to :dependency_clause
+  end
+
+  describe "validations" do
+
+    before(:each) do
+      @dependency = Dependency.new
+    end
+
+    it "should be valid" do
+      @dependency.attributes = valid_attributes
+      @dependency.should be_valid
+    end
+
+    it "should have a fieldset_child_id" do
+      @dependency.should have(1).error_on(:fieldset_child_id)
+    end
+
+    it "should not require a dependency_clause_id" do
+      #@dependency.should have(1).error_on(:dependency_clause_id)
+      @dependency.should have(0).error_on(:dependency_clause_id)
+    end
+
+    it "should have a relationship limited to allowable values" do
+      @dependency.relationship = "equals"
+      @dependency.should have(0).error_on(:relationship)
+    end
+
+    it "should error when relationship is not one of the allowable values" do
+      @dependency.relationship = "invalid relationship"
+      @dependency.should have(1).error_on(:relationship)
+    end
+  end
+
+  describe "evaluate" do
+    before(:each) do
+      @fieldset_child = FieldsetChild.new
+      @fieldset_child.stub!(:id).and_return(100)
+      @dependency = Dependency.new
+      @dependency.attributes = valid_attributes
+      @input_hash = {100 => "test value"}
+    end
+
+    it "should take a hash's input" do
+      lambda{@dependency.evaluate(@input_hash)}.should_not raise_error
+    end
+
+    it "should return true when input matches requirements" do
+      @dependency.stub!(:process_relationship).and_return(true)
+      @dependency.evaluate(@input_hash).should be_true
+    end
+
+    it "should return false when input does not match requirements" do
+      @dependency.stub!(:process_relationship).and_return(false)
+      @dependency.evaluate(@input_hash).should be_false
+    end
+
+    it "should return false when key pairing does not exist" do
+      @dependency.stub!(:process_relationship).and_return(false)
+      @dependency.evaluate({1 => "test_value"}).should be_false
+    end
+ 
+  end
+
+  describe "relationship_list" do
+    it "should return an array" do
+      @dependency = Dependency.new
+      @dependency.attributes = valid_attributes
+      @dependency.relationship_list.should be_an_instance_of Array
+    end
+  end
+
+  describe "process_relationship" do
+    before(:each) do
+      @dependency = Dependency.new
+      @dependency.attributes = valid_attributes
+      @dependency.value = "test string"
+    end
+
+    it "should take a string as input" do
+      input_value = "test string"
+      lambda{@dependency.process_relationship(input_value)}.should_not raise_error
+    end
+
+    it "should return true if the value and input_value are equal and relatinship is equal" do
+      @dependency.relationship = "equals"
+      input_value = "test string"
+      @dependency.process_relationship(input_value).should be_true
+    end
+
+    it "should return false if the value and input value are not equal and relationship is equal" do
+      @dependency.relationship = "equals"
+      input_value = "not test string"
+      @dependency.process_relationship(input_value).should be_false
+    end
+
+    it "should return true if the value and input_value are not equal and relationship is not equal" do
+      @dependency.relationship = "not equals"
+      input_value = "not test string"
+      @dependency.process_relationship(input_value).should be_true
+    end
+
+    it "should return false if the value and input_value are equal and relationship is not equal" do
+      @dependency.relationship = "not equals"
+      input_value = "test string"
+      @dependency.process_relationship(input_value).should be_false
+    end
+
+    it "should return true if the value is within the input_value array and relationship is includes" do
+      @dependency.relationship = "includes"
+      input_value = ["test string"]
+      @dependency.process_relationship(input_value).should be_true 
+    end
+
+    it "should return false if the value is not within the input_value array and relationship is includes" do
+      @dependency.relationship = "includes"
+      input_value = ["a"]
+      @dependency.process_relationship(input_value).should be_false
+    end
+
+    it "should return true if the value is not within the input_value array and relationship is not includes" do
+      @dependency.relationship = "not includes"
+      input_value = ["a"]
+      @dependency.process_relationship(input_value).should be_true
+    end
+
+    it "should return false if the value is within the input_value array and relationship is not includes" do
+      @dependency.relationship = "not includes"
+      input_value = ["test string"]
+      @dependency.process_relationship(input_value).should be_false
+    end
+
+    it "should return true if the input_value is an empty string and relationship is blank" do
+      @dependency.relationship = "blank"
+      input_value = ""
+      @dependency.process_relationship(input_value).should be_true
+    end
+
+    it "should return false if the input_value is not an empty string and relationship is blank" do
+      @dependency.relationship = "blank"
+      input_value = "test string"
+      @dependency.process_relationship(input_value).should be_false
+    end
+
+    it "should return true if the input_value is not an empty string and relationship is not blank" do
+      @dependency.relationship = "not blank"
+      input_value = "test string"
+      @dependency.process_relationship(input_value).should be_true
+    end
+
+    it "should return false if the input_value is not an empty string and relationship is not blank" do
+      @dependency.relationship = "not blank"
+      input_value = ""
+      @dependency.process_relationship(input_value).should be_false
+    end
+
+  end
+
+  describe "to_hash method" do
+    it "should have spec tests"
+  end
+end

data/spec/models/field_default_spec.rb

@@ -23,4 +23,53 @@ describe FieldDefault do
       @field_default.should have(1).error_on(:value)
     end
   end  
+
+  # note that these are saving because I am testing a before save
+  # instead of testing the method directly
+  describe "convert_option_name_to_id method" do
+    before(:each) do
+      @field = Field.new(:field_type => "select")
+      @field.stub!(:id).and_return(1)
+      @field_option = FieldOption.new(:name => "test value")
+      @field_option.stub!(:id).and_return(2)
+      FieldOption.stub!(:find_by_name).and_return(@field_option)
+      @default = FieldDefault.new(:field => @field, :value => "test value")
+    end
+
+    it "should convert the value to a field option id if the field's type is an option type" do
+      @default.save
+      @default.value.should == @field_option.id
+    end
+
+    it "should retain it's value if the field's type is not an option type" do
+      @field.field_type = "textfield"
+      @default.save
+      @default.value.should_not == @field_option.id
+    end
+  end
+
+  describe "pretty_value method" do
+    before(:each) do
+      @field = Field.new(:field_type => "select")
+      @field.stub!(:id).and_return(1)
+      @field_option = FieldOption.new(:name => "test value")
+      @field_option.stub!(:id).and_return(2)
+      FieldOption.stub!(:find_by_name).and_return(@field_option)
+      @default = FieldDefault.new(:field => @field, :value => "test value")
+    end
+
+    it "should return the value if the field is not an option type" do
+      @field.field_type = "textfield"
+      @default.pretty_value.should == @default.value
+    end
+
+    it "should return the field option name if the field is an option type" do
+      @default.pretty_value.should == @field_option.name
+    end
+      
+    it "should return the value if the field is not set" do
+      @default.field = nil
+      @default.pretty_value.should == @default.value
+    end
+  end
 end

data/spec/models/field_record_spec.rb

@@ -18,14 +18,16 @@ describe FieldRecord do
     end
     
     it "should be valid" do
-      @field_record.field = Field.new
+      @field_record.fieldset_child = FieldsetChild.new
       @field_record.fieldset_associator = FieldsetAssociator.new
       @field_record.value = "42"
+      child = mock_model(DynamicFieldsets::Field)
+      @field_record.fieldset_child = FieldsetChild.new(:child => child)
       @field_record.should be_valid
     end
 
     it "should require field" do
-      @field_record.should have(1).error_on(:field)
+      @field_record.should have(1).error_on(:fieldset_child)
     end
 
     it "should require fieldset_associator" do
@@ -40,5 +42,12 @@ describe FieldRecord do
       @field_record.value = ""
       @field_record.should have(0).error_on(:value)
     end
+
+    it "should error if the fieldset_child has the wrong type" do
+      child = mock_model(DynamicFieldsets::Fieldset)
+      @field_record.fieldset_child = FieldsetChild.new(:child => child)
+      @field_record.valid?
+      @field_record.should have(1).error_on(:fieldset_child)
+    end
   end
 end

data/spec/models/field_spec.rb

@@ -4,8 +4,8 @@ include DynamicFieldsets
 describe Field do
   include FieldHelper
 
-  it "should respond to fieldset" do
-    Field.new.should respond_to :fieldset
+  it "should respond to parent_fieldset" do
+    Field.new.should respond_to :parent_fieldsets
   end
 
   it "should respond to field_options" do
@@ -42,10 +42,6 @@ describe Field do
       @field.should have(2).error_on(:field_type)
     end
 
-    it "should require order number" do
-      @field.should have(1).error_on(:order_num)
-    end
-
     it "should require type within the allowable types" do
       @field.field_type = "unsupported_type"
       @field.should have(1).error_on(:field_type)
@@ -166,4 +162,32 @@ describe Field do
       Field.option_field_types.should be_a_kind_of Array
     end
   end
+
+  describe "in_use? method" do
+    before(:each) do
+      @field = Field.new
+      @field.stub!(:id).and_return(1)
+
+    end
+    it "should return true if there is a field record associated with the field" do
+      @fieldset_child = FieldsetChild.new(:child => @field, :fieldset => nil )
+      @fieldset_child.stub!(:field_records).and_return(["random", "array" "of", "stuff"])
+      @field.stub!(:fieldset_children).and_return([@fieldset_child])
+
+      @field.in_use?.should be_true
+    end
+
+    it "should return true if the field is in a fieldset (through a fieldset child)" do
+      @fieldset = Fieldset.new
+      @fieldset.stub!(:id).and_return(2)
+      @fieldset_child = FieldsetChild.new(:child => @field, :fieldset_id => @fieldset.id)
+      @field.stub!(:fieldset_children).and_return([@fieldset_child])
+
+      @field.in_use?.should be_true
+    end
+
+    it "should return false otherwise" do
+      @field.in_use?.should be_false
+    end
+  end
 end