dynamic_fieldsets 0.0.16 → 0.1.0

data/spec/models/fieldset_associator_spec.rb

@@ -1,20 +1,19 @@
 require 'spec_helper'
-include DynamicFieldsets
 
-describe FieldsetAssociator do
+describe DynamicFieldsets::FieldsetAssociator do
   include FieldsetAssociatorHelper
   
   it "should respond to fieldset" do
-    FieldsetAssociator.new.should respond_to :fieldset
+    DynamicFieldsets::FieldsetAssociator.new.should respond_to :fieldset
   end
 
   it "should respond to field_records" do
-    FieldsetAssociator.new.should respond_to :field_records
+    DynamicFieldsets::FieldsetAssociator.new.should respond_to :field_records
   end
 
   describe "validations" do
     before(:each) do
-      @fsa = FieldsetAssociator.new
+      @fsa = DynamicFieldsets::FieldsetAssociator.new
     end
 
     it "should be valid" do
@@ -41,46 +40,47 @@ describe FieldsetAssociator do
     it "should error require a unique field model, field model name pair" do
       @fsa.attributes = valid_attributes
       @fsa.save
-      fsa2 = FieldsetAssociator.new
+      fsa2 = DynamicFieldsets::FieldsetAssociator.new
       fsa2.should have(1).error_on(:fieldset_model_name)
     end
   end
 
   describe "find_by_fieldset_model_parameters" do
     before(:each) do
-      @fieldset = mock_model(Fieldset)
+      @fieldset = mock_model(DynamicFieldsets::Fieldset)
       @fieldset.stub!(:nkey).and_return(":hire_form")
       @fieldset.stub!(:id).and_return(1)
-      @fsa = FieldsetAssociator.create(valid_attributes)
+      @fsa = DynamicFieldsets::FieldsetAssociator.create(valid_attributes)
 
       @fieldset_model_attributes = valid_attributes
       @fieldset_model_attributes[:fieldset] = :hire_form
     end
   
     it "should respond to find_by_fieldset_model_parameters" do
-      FieldsetAssociator.should respond_to :find_by_fieldset_model_parameters
+      DynamicFieldsets::FieldsetAssociator.should respond_to :find_by_fieldset_model_parameters
     end
 
-    it "should call Fieldset find_by_nkey" do
-      Fieldset.should_receive(:find_by_nkey).and_return(@fieldset)
-      FieldsetAssociator.find_by_fieldset_model_parameters(@fieldset_model_attributes)
+    it "should call DynamicFieldsets::Fieldset find_by_nkey" do
+      DynamicFieldsets::Fieldset.should_receive(:find_by_nkey).and_return(@fieldset)
+      DynamicFieldsets::FieldsetAssociator.find_by_fieldset_model_parameters(@fieldset_model_attributes)
     end
 
     it "should throw an error if the fieldset does not exist" do
-      Fieldset.stub!(:find_by_nkey).and_return(nil)
-      lambda { FieldsetAssociator.find_by_fieldset_model_parameters(@fieldset_model_attributes) }.should raise_error
+      DynamicFieldsets::Fieldset.stub!(:find_by_nkey).and_return(nil)
+      lambda { DynamicFieldsets::FieldsetAssociator.find_by_fieldset_model_parameters(@fieldset_model_attributes) }.should raise_error
     end
 
     it "should return the correct fieldset associator" do
-      Fieldset.stub!(:find_by_nkey).and_return(@fieldset)
+      DynamicFieldsets::Fieldset.stub!(:find_by_nkey).and_return(@fieldset)
       # this is a fun hack because of all the fsas being made during tests
-      FieldsetAssociator.find_by_fieldset_model_parameters(@fieldset_model_attributes).should include @fsa
+      DynamicFieldsets::FieldsetAssociator.find_by_fieldset_model_parameters(@fieldset_model_attributes).should include @fsa
     end
   end
 
   describe "field_values method" do
     before(:each) do
-      @fsa = FieldsetAssociator.new
+      pending "this method was completely rewritten.  Most of the functionality was moved to other models."
+      @fsa = DynamicFieldsets::FieldsetAssociator.new
 
       @field = mock_model DynamicFieldsets::Field
       @fieldset_child = mock_model DynamicFieldsets::FieldsetChild
@@ -95,7 +95,7 @@ describe FieldsetAssociator do
     end
 
     it "returns a hash" do
-      @fieldset_child.child.stub!(:field_type).and_return ''
+      @fieldset_child.child.stub!(:type).and_return ''
       @fsa.field_values.should be_a_kind_of Hash
     end
 
@@ -107,27 +107,27 @@ describe FieldsetAssociator do
     # 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 "returns multiple select values as an array of ids" do
-      @fieldset_child.child.stub!(:field_type).and_return 'multiple_select'
+      @fieldset_child.child.stub!(:type).and_return 'multiple_select'
       @fsa.field_values.should == { 37 => [42, 42] }
     end
 
     it "returns checkboxes values as an array of ids" do
-      @field.stub!(:field_type).and_return 'checkbox'
+      @field.stub!(:type).and_return 'checkbox'
       @fsa.field_values.should == { 37 => [42, 42] }
     end
 
     it "returns select values as an id" do
-      @field.stub!(:field_type).and_return 'select'
+      @field.stub!(:type).and_return 'select'
       @fsa.field_values.should == { 37 => 42 }
     end
 
     it "returns radio values as an id" do
-      @field.stub!(:field_type).and_return 'radio'
+      @field.stub!(:type).and_return 'radio'
       @fsa.field_values.should == { 37 => 42 }
     end
 
     it "returns all other field types as strings" do
-      @field.stub!(:field_type).and_return 'textfield'
+      @field.stub!(:type).and_return 'textfield'
       @field_record.stub!(:value).and_return 'forty two'
       @fsa.field_values.should == { 37 => "forty two" }
     end
@@ -136,12 +136,12 @@ describe FieldsetAssociator do
   # these tests seem silly when they don't hit the database
   describe "field_records_by_field_name method" do
     before(:each) do
-      @fieldset = Fieldset.new
-      @field = Field.new(:name => "test_field")
-      @child = FieldsetChild.new(:fieldset => @fieldset, :child => @field)
+      @fieldset = DynamicFieldsets::Fieldset.new
+      @field = DynamicFieldsets::Field.new(:name => "test_field")
+      @child = DynamicFieldsets::FieldsetChild.new(:fieldset => @fieldset, :child => @field)
 
-      @fsa = FieldsetAssociator.new(:fieldset => @fieldset)
-      @record = FieldRecord.new(:fieldset_child => @child)
+      @fsa = DynamicFieldsets::FieldsetAssociator.new(:fieldset => @fieldset)
+      @record = DynamicFieldsets::FieldRecord.new(:fieldset_child => @child)
 
       @fsa.stub!(:field_records).and_return([@record])
     end
@@ -157,22 +157,22 @@ describe FieldsetAssociator do
 
   describe "dependency_child_hash and look_for_dependents" do
     before(:each) do
-      @fsa = FieldsetAssociator.new
+      @fsa = DynamicFieldsets::FieldsetAssociator.new
 
-      @fieldset1 = Fieldset.new
+      @fieldset1 = DynamicFieldsets::Fieldset.new
       @fieldset1.stub!(:id).and_return(100)
-      @fieldset2 = Fieldset.new
+      @fieldset2 = DynamicFieldsets::Fieldset.new
       @fieldset2.stub!(:id).and_return(200)
 
-      @field1 = Field.new
+      @field1 = DynamicFieldsets::Field.new
       @field1.stub!(:id).and_return(100)
-      @field2 = Field.new
+      @field2 = DynamicFieldsets::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 = DynamicFieldsets::FieldsetChild.new
       @fsc1.stub!(:id).and_return(100)
       @fsc1.stub!(:fieldset_id).and_return(@fieldset1.id)
       @fsc1.stub!(:child_id).and_return(@fieldset2.id)
@@ -180,14 +180,14 @@ describe FieldsetAssociator do
       @fsc1.stub!(:child).and_return(@fieldset2)
       @fieldset1.stub!(:fieldset_children).and_return([@fsc1])
 
-      @fsc2 = FieldsetChild.new
+      @fsc2 = DynamicFieldsets::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 = DynamicFieldsets::FieldsetChild.new
       @fsc3.stub!(:id).and_return(300)
       @fsc3.stub!(:fieldset_id).and_return(@fieldset2.id)
       @fsc3.stub!(:child_id).and_return(@field2.id)
@@ -196,19 +196,19 @@ describe FieldsetAssociator do
 
       @fieldset2.stub!(:fieldset_children).and_return([@fsc2, @fsc3])
 
-      @group = DependencyGroup.new
+      @group = DynamicFieldsets::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 = DynamicFieldsets::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 = DynamicFieldsets::Dependency.new
       @dependency.stub!(:id).and_return(100)
       @dependency.stub!(:value).and_return(5)
       @dependency.stub!(:relationship).and_return("equals")
@@ -266,7 +266,5 @@ describe FieldsetAssociator do
       }
       @fsa.dependency_child_hash.should == expected_results
     end
-
   end
-
 end

data/spec/models/fieldset_child_spec.rb

@@ -1,32 +1,35 @@
 require 'spec_helper'
-include DynamicFieldsets
 
-describe FieldsetChild do
+describe DynamicFieldsets::FieldsetChild do
   include FieldsetChildHelper
 
-  it "should respond to fieldset" do
-    FieldsetChild.new.should respond_to :fieldset
+  before do
+    @child = DynamicFieldsets::FieldsetChild.new
   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
+  subject { @child }
 
-  it "should respond to field_records" do
-    FieldsetChild.new.should respond_to :field_records
+  describe "fields" do
+    it { should respond_to :fieldset_id }
+    it { should respond_to :child_id }
+    it { should respond_to :child_type }
+    it { should respond_to :order_num }
   end
 
-  it "should respond to order_num" do
-    FieldsetChild.new.should respond_to :order_num
+  describe "associations" do
+    before do
+      pending "can't get shoulda working"
+    end
+    it { should belong_to :child }
+    it { should belong_to :fieldset }
+    it { should have_many :field_records }
+    it { should have_one :dependency_group }
+    it { should have_many :dependencies } 
   end
 
   describe "validations" do
     before(:each) do
-      @fieldset_child = FieldsetChild.new
+      @fieldset_child = DynamicFieldsets::FieldsetChild.new
     end
     it "are valid" do
       @fieldset_child.attributes = valid_attributes
@@ -47,56 +50,94 @@ describe FieldsetChild do
       @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)
+    describe "validates includsion of child type" do
+      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
     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)
+    it "should call these additional validators" do
+      @fieldset_child.should_receive(:no_duplicate_fields_in_fieldset_children)
+      @fieldset_child.should_receive(:cannot_be_own_parent)
+      @fieldset_child.should_receive(:no_parental_loop)
+      @fieldset_child.valid?
     end
  
+    # no_duplicate_fields_in_fieldset_children
     it "should not allow duplicate pairings of fieldsets and fields" do
-      fieldset = Fieldset.new
-      field = Field.new
+      fieldset = DynamicFieldsets::Fieldset.new
+      field = DynamicFieldsets::Field.new
       field.stub!(:id).and_return(100)
-      fieldset_child1 = FieldsetChild.new(:fieldset => fieldset, :child => field, :order_num => 1)
+      fieldset_child1 = DynamicFieldsets::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 = DynamicFieldsets::FieldsetChild.new(:fieldset => fieldset, :child => field, :order_num => 2)
+      DynamicFieldsets::FieldsetChild.stub!(:where).and_return([fieldset_child1])
       fieldset_child2.should have(1).error_on(:child_id)
     end
 
+    # cannot_be_own_parent
     # this should have two errors, because it's also a loop
     it "cannot be it's own parent" do
-      fieldset = Fieldset.new
+      fieldset = DynamicFieldsets::Fieldset.new
       fieldset.stub!(:id).and_return(100)
-      fieldset_child = FieldsetChild.new(:fieldset_id => fieldset.id, :child => fieldset, :order_num => 1)
+      fieldset_child = DynamicFieldsets::FieldsetChild.new(:fieldset_id => fieldset.id, :child => fieldset, :order_num => 1)
       fieldset_child.should have(2).error_on(:child_id)
     end
   
+    # no_parental_loop
     it "should not allow a parent fieldset when it would create a cycle" do
-      fieldset1 = Fieldset.new
+      fieldset1 = DynamicFieldsets::Fieldset.new
       fieldset1.stub!(:id).and_return(100)
-      fieldset2 = Fieldset.new
+      fieldset2 = DynamicFieldsets::Fieldset.new
       fieldset2.stub!(:id).and_return(200)
-      fieldset3 = Fieldset.new
+      fieldset3 = DynamicFieldsets::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_child1 = DynamicFieldsets::FieldsetChild.create(:fieldset_id => fieldset1.id, :child => fieldset2, :order_num => 1)
+      fieldset_child2 = DynamicFieldsets::FieldsetChild.create(:fieldset_id => fieldset2.id, :child => fieldset3, :order_num => 1)
+      fieldset_child3 = DynamicFieldsets::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"
+  # Scopes and static methods
+  it { DynamicFieldsets::FieldsetChild.should respond_to(:ordered) }
+  describe ".ordered scope" do
+    it "needs tests"
+  end
+
+  # Methods
+
+  it { should respond_to :children }
+  describe ".children" do
+    it "needs tests"
+  end
+
+  it { should respond_to :fieldset_child_list }
+  describe ".fieldset_child_list" do
+    it "should match the constant FIELDSET_CHILD_LIST" do
+      @child.fieldset_child_list.should == DynamicFieldsets::FieldsetChild::FIELDSET_CHILD_LIST
+    end
+  end
+
+  it { should respond_to :get_value_using_fsa }
+  describe ".get_value_using_fsa" do
+    it "needs tests"
+  end
+
+  it { should respond_to :last_order_num }
+  describe ".last_order_num" do
+    it "needs tests"
   end
 
   describe "root_fieldset method" do
@@ -104,12 +145,12 @@ describe FieldsetChild 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 = DynamicFieldsets::Field.create({ :name => "Test field name", :label => "Test field label", :type => "textfield", :required => true, :enabled => true, })
+      @fieldset = DynamicFieldsets::Fieldset.create({:name => "Hire Form", :description => "Hire a person for a job", :nkey => "hire_form"})
+      @root_fieldset = DynamicFieldsets::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)
+      @field_child = DynamicFieldsets::FieldsetChild.create(:child => @child, :fieldset => @fieldset, :order_num => 1)
+      @child = DynamicFieldsets::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
@@ -119,4 +160,15 @@ describe FieldsetChild do
       @field_child.root_fieldset.id.should == @root_fieldset.id
     end
   end
+
+  it { should respond_to :siblings }
+  describe ".siblings" do
+    it "needs tests"
+  end
+
+  it { should respond_to :to_hash }
+  describe "to_hash method" do
+    it "needs specs"
+    it "needs comments"
+  end
 end

data/spec/models/fieldset_spec.rb

@@ -1,24 +1,23 @@
 require 'spec_helper'
-include DynamicFieldsets
-  
-describe Fieldset do
+
+describe DynamicFieldsets::Fieldset do
   include FieldsetHelper
 
   it "should respond to parent" do 
-    Fieldset.new.should respond_to :parent
+    DynamicFieldsets::Fieldset.new.should respond_to :parent
   end
 
   it "should respond to child_fields" do
-    Fieldset.new.should respond_to :child_fields
+    DynamicFieldsets::Fieldset.new.should respond_to :child_fields
   end
 
   it "should respond to child_fieldsets" do
-    Fieldset.new.should respond_to :child_fieldsets
+    DynamicFieldsets::Fieldset.new.should respond_to :child_fieldsets
   end
   
   describe "validations" do
     before(:each) do
-      @fieldset = Fieldset.new
+      @fieldset = DynamicFieldsets::Fieldset.new
     end
 
     it "should be valid" do
@@ -39,7 +38,7 @@ describe Fieldset do
     end
 
     it "should require a unique nkey" do
-      Fieldset.create(valid_attributes)
+      DynamicFieldsets::Fieldset.create(valid_attributes)
       @fieldset.attributes = valid_attributes
       @fieldset.should have(1).error_on(:nkey)
     end
@@ -48,37 +47,37 @@ describe Fieldset do
   describe ".roots scope" do
     before(:each) do
       # we could stub this one but I am not convinced the polymorphic relationships actually work
-      @root_fieldset = Fieldset.new( valid_attributes )
+      @root_fieldset = DynamicFieldsets::Fieldset.new( valid_attributes )
       @root_fieldset.save
 
-      @child_fieldset = Fieldset.new( valid_attributes )
+      @child_fieldset = DynamicFieldsets::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 = DynamicFieldsets::FieldsetChild.new(:child => @child_fieldset, :fieldset => @root_fieldset, :order_num => 1)
       @fieldset_children.save
     end
     
-    it ": Fieldset responds to .roots" do
-      Fieldset.should respond_to :roots
+    it ": DynamicFieldsets::Fieldset responds to .roots" do
+      DynamicFieldsets::Fieldset.should respond_to :roots
     end
     
     it "returns fieldsets with no parent" do
-      roots = Fieldset.roots
+      roots = DynamicFieldsets::Fieldset.roots
       roots.each do |root|
         root.parent.should be_nil
       end
     end
     
     it "does not return fieldsets with a parent" do
-      roots = Fieldset.roots
+      roots = DynamicFieldsets::Fieldset.roots
       roots.should_not include @child_fieldset
     end
   end
 
   describe ".root? method" do
     before(:each) do
-      @fieldset = Fieldset.new
+      @fieldset = DynamicFieldsets::Fieldset.new
     end
 
     it "calls parent" do  
@@ -98,7 +97,7 @@ describe Fieldset do
 
   describe "parent_fieldset_list static method" do
     it "should include values for any fieldset" do
-      fieldset = Fieldset.new(:name => "parent_fieldset_list test", :nkey => "parent_fieldset_list_test")
+      fieldset = DynamicFieldsets::Fieldset.new(:name => "parent_fieldset_list test", :nkey => "parent_fieldset_list_test")
       fieldset.save(:validate => false)
       DynamicFieldsets::Fieldset.parent_fieldset_list.should include [fieldset.name, fieldset.id]
     end
@@ -107,31 +106,29 @@ describe Fieldset do
   # 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_attributes )
+      @root_fieldset = DynamicFieldsets::Fieldset.new( valid_attributes )
       @root_fieldset.stub!(:id).and_return(1234)
       
-      @child_fieldset = Fieldset.new( valid_attributes )
+      @child_fieldset = DynamicFieldsets::Fieldset.new( valid_attributes )
       @child_fieldset.nkey = "child_fieldset"
       @child_fieldset.save
-      @cfs = FieldsetChild.new(:child => @child_fieldset, :fieldset => @root_fieldset, :order_num => 1)
+      @cfs = DynamicFieldsets::FieldsetChild.new(:child => @child_fieldset, :fieldset => @root_fieldset, :order_num => 1)
       
-      @field1 = Field.new(
+      @field1 = DynamicFieldsets::TextField.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)
+      @field1.save!
+      @cf1 = DynamicFieldsets::FieldsetChild.new(:child => @field1, :fieldset => @root_fieldset, :order_num => 2)
       
-      @field2 = Field.new(
+      @field2 = DynamicFieldsets::TextField.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)
+      @field2.save!
+      @cf2 = DynamicFieldsets::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)
@@ -163,5 +160,4 @@ describe Fieldset do
       children.last.should == @field1
     end
   end
-  
 end