formbuilder-rb 0.0.4 → 0.2.0

data/spec/fixtures/test_files/text.txt

@@ -0,0 +1 @@
+BALEETED

data/spec/fixtures/test_files/text2.txt

@@ -0,0 +1 @@
+lkasdjlkd

data/spec/lib/formbuilder/entry_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+def create_entry(value)
+  e = Entry.new(form: form, skip_validation: true)
+  e.save_response(value, first_field)
+  e.save
+  e
+end
+
+def ensure_sort_order(*args)
+  (args.length - 1).times do |i|
+    ( (args[i].responses["#{first_field.id}_sortable_value"] || 0) <
+      (args[i+1].responses["#{first_field.id}_sortable_value"] || 0) ).should == true
+  end
+end
+
+def change_field_type(new_field_type, additional_params = {})
+  first_field.update_attributes({ type: new_field_type }.merge(additional_params))
+  first_field.becomes!(new_field_type.constantize)
+end
+
+describe Formbuilder::Entry do
+
+  let!(:form) { FactoryGirl.create(:form_with_one_field) }
+  let!(:entry) { e = Entry.new(form: form, skip_validation: true); e.save; e }
+  let(:first_field) { form.response_fields.first }
+  let(:file_value) { File.open(File.expand_path('../../fixtures/test_files/text2.txt', File.dirname(__FILE__))) }
+
+  subject { entry }
+
+  describe 'callbacks' do
+    describe 'normalize responses' do
+      it 'gets called before validation' do
+        entry.should_receive(:normalize_responses)
+        entry.valid?
+      end
+    end
+
+    describe 'calculate_responses_text' do
+      it 'gets called when responses change and entry is saved' do
+        entry.should_receive(:calculate_responses_text).exactly(:once)
+        entry.save_responses({ "#{first_field.id}" => 'boo' }, form.response_fields)
+        entry.save
+      end
+    end
+  end
+
+  describe '#value_present?' do
+    it 'should be true if there is a value' do
+      entry.value_present?(first_field).should == false
+      entry.responses[first_field.id.to_s] = 'foo'
+      entry.value_present?(first_field).should == true
+    end
+
+    context 'Formbuilder::ResponseFieldCheckboxes' do
+      let(:first_field_checkboxes) { first_field.becomes!(Formbuilder::ResponseFieldCheckboxes) }
+
+      it 'should be true when there are no options' do
+        entry.value_present?(first_field_checkboxes).should == true
+      end
+
+      context 'when there are options' do
+        before { first_field_checkboxes.field_options['options'] = [{ 'label' => 'foo', 'checked' => 'false' }] }
+
+        it 'should be false' do
+          entry.value_present?(first_field_checkboxes).should == false
+        end
+      end
+    end
+
+    context 'when the field is serialized' do
+      let(:first_field_time) { first_field.becomes!(Formbuilder::ResponseFieldTime) }
+
+      it 'should be true if it has at least one response' do
+        entry.value_present?(first_field_time).should == false
+        entry.responses[first_field_time.id.to_s] = { 'am_pm' => 'am' }.to_yaml
+        entry.value_present?(first_field_time).should == false
+        entry.responses[first_field_time.id.to_s] = { 'minutes' => '06' }.to_yaml
+        entry.value_present?(first_field_time).should == true
+      end
+    end
+  end
+
+  describe '#response_value' do
+    context 'when value is serialized' do
+      let(:first_field_serialized) { first_field.becomes!(Formbuilder::ResponseFieldCheckboxes) }
+
+      it 'should unserialize a value if necessary' do
+        entry.responses[first_field_serialized.id.to_s] = { a: 'b' }.to_yaml
+        entry.response_value(first_field_serialized).should == { a: 'b' }
+      end
+    end
+  end
+
+  describe '#save_responses' do
+    # let's not go overboard here. most of this functionality is covered by feature specs.
+    it 'should behave properly' do
+      entry.save_responses({ "#{first_field.id}" => 'boo' }, form.response_fields)
+      entry.response_value(first_field).should == 'boo'
+    end
+  end
+
+  describe '#destroy_response' do
+    it 'should remove the response and its sortable value' do
+      # Setup
+      entry.save_responses({ "#{first_field.id}" => 'boo' }, form.response_fields)
+      entry.response_value(first_field).should == 'boo'
+      entry.responses["#{first_field.id}_sortable_value"].should be_present
+
+      # Destroy
+      entry.destroy_response(first_field)
+      entry.response_value(first_field).should be_nil
+      entry.responses["#{first_field.id}_sortable_value"].should be_nil
+    end
+
+    context 'Formbuilder::ResponseFieldFile' do
+      let(:first_field_file) { first_field.becomes!(Formbuilder::ResponseFieldFile); }
+      let(:attachment_id) { entry.response_value(first_field_file) }
+
+      before do
+        first_field.update_attributes(type: 'Formbuilder::ResponseFieldFile')
+        entry.save_responses({ "#{first_field_file.id}" => file_value }, form.reload.response_fields)
+      end
+
+      it 'uploads properly' do
+        Formbuilder::EntryAttachment.find(attachment_id).should be_present
+      end
+
+      it 'destroys explicitly' do
+        entry.destroy_response(first_field_file)
+        entry.response_value(first_field_file).should be_nil
+        entry.responses["#{first_field_file.id}_sortable_value"].should be_nil
+        Formbuilder::EntryAttachment.where(id: attachment_id).first.should_not be_present
+      end
+
+      it 'destroys when changing value' do
+        prev_attachment_id = attachment_id
+        entry.save_responses({ "#{first_field_file.id}" => file_value }, form.reload.response_fields)
+        Formbuilder::EntryAttachment.where(id: prev_attachment_id).first.should_not be_present
+      end
+
+      # Because <input type='file'> can't have an existing file, we preserve the current
+      # value if the input is blank.
+      it 'preserves when value is blank' do
+        prev_attachment_id = attachment_id
+        entry.save_responses({ "#{first_field_file.id}" => '' }, form.reload.response_fields)
+        Formbuilder::EntryAttachment.where(id: prev_attachment_id).first.should be_present
+      end
+    end
+  end
+
+  describe '#calculate_responses_text' do
+    let(:first_field_number) { first_field.becomes!(Formbuilder::ResponseFieldNumber) }
+
+    it 'should calculate the text-only values of the responses' do
+      entry.save_responses({ "#{first_field_number.id}" => '123' }, form.response_fields)
+      entry.responses["#{first_field_number.id}"].should == '123'
+      entry.responses["#{first_field_number.id}_sortable_value"].should == '123'
+      entry.save
+      entry.responses_text.should == '123'
+    end
+  end
+
+  describe 'normalize responses' do
+    before do
+      first_field.update_attributes(type: 'Formbuilder::ResponseFieldWebsite')
+      entry.reload
+    end
+
+    it 'functions properly' do
+      # does not need normalization
+      entry.responses[first_field.id.to_s] = 'http://www.google.com'
+      entry.normalize_responses
+      entry.responses[first_field.id.to_s].should == 'http://www.google.com'
+
+      # needs normalization
+      entry.responses[first_field.id.to_s] = 'www.google.com'
+      entry.normalize_responses
+      entry.responses[first_field.id.to_s].should == 'http://www.google.com'
+    end
+  end
+
+  describe 'auditing responses' do
+    before do
+      first_field.update_attributes(type: 'Formbuilder::ResponseFieldAddress')
+      entry.reload
+    end
+
+    it 'should run all audits when called explicitly' do
+      entry.responses[first_field.id.to_s] = { 'street' => 'hi' }.to_yaml
+      entry.skip_validation = true
+      entry.save
+      entry.responses["#{first_field.id}_x"].should be_nil
+      entry.audit_responses
+      entry.responses["#{first_field.id}_x"].should == Geocoder::Lookup::Test.read_stub(nil)[0]['latitude']
+    end
+  end
+
+end

data/spec/lib/formbuilder/entry_validator_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe Formbuilder::EntryValidator do
+
+  let!(:form) { FactoryGirl.create(:form) }
+  let!(:entry) { e = Entry.new(form: form); e.save(skip_validation: true); e }
+
+  describe '#validate' do
+    before do
+      form.response_fields.create(label: "Text", type: "Formbuilder::ResponseFieldText", sort_order: 0, required: true)
+    end
+
+    it 'should validate properly' do
+      entry.should_not be_valid
+    end
+
+    it 'should not validate if there is no form' do
+      entry.form = nil
+      entry.should be_valid
+    end
+
+    it 'should not validate if the :skip_validation flag is passed' do
+      entry.skip_validation = true
+      entry.should be_valid
+    end
+  end
+
+  describe 'page validation' do
+    let!(:rf1) { form.response_fields.create(label: "Text", type: "Formbuilder::ResponseFieldText", sort_order: 0, required: true) }
+    let!(:rf2) { form.response_fields.create(label: "pb", type: "Formbuilder::ResponseFieldPageBreak", sort_order: 1) }
+    let!(:rf3) { form.response_fields.create(label: "Text2", type: "Formbuilder::ResponseFieldText", sort_order: 2, required: true) }
+
+    before do
+      entry.save_response('Boo', rf1)
+      entry.save
+    end
+
+    subject { entry }
+
+    it 'validates per page' do
+      expect(entry.valid_page?(2)).to be_false
+      expect(entry.valid_page?(1)).to be_true
+    end
+
+    its(:first_page_with_errors) { should eq 2 }
+    its(:pages_with_errors) { should eq [false, true] }
+
+    describe '#errors_on_page?' do
+      before { entry.valid? }
+
+      it 'calculates properly' do
+        expect(entry.errors_on_page?(1)).to be_false
+        expect(entry.errors_on_page?(2)).to be_true
+      end
+    end
+  end
+
+  describe 'ResponseFieldText' do
+    let(:field) { form.response_fields.create(label: "Text", type: "Formbuilder::ResponseFieldText", sort_order: 0) }
+
+    it 'required' do
+      field.update_attributes(required: true)
+      entry.should_not be_valid
+      entry.save_response('Boo', field)
+      entry.should be_valid
+    end
+
+    it 'min/max length characters' do
+      field.update_attributes(field_options: { 'minlength' => '5', 'maxlength' => '10' })
+      entry.should be_valid
+      entry.save_response('Boo', field)
+      entry.should_not be_valid
+      entry.save_response('Boooo', field)
+      entry.should be_valid
+      entry.save_response('Boooooooooooooooooooo', field)
+      entry.should_not be_valid
+      entry.save_response('Boooo', field)
+      entry.should be_valid
+    end
+
+    it 'min/max length words' do
+      field.update_attributes(field_options: { 'minlength' => '2', 'maxlength' => '3', 'min_max_length_units' => 'words' })
+      entry.should be_valid
+      entry.save_response('Boo', field)
+      entry.should_not be_valid
+      entry.save_response('Boo hoo', field)
+      entry.should be_valid
+      entry.save_response('Boo hoo hoo', field)
+      entry.should be_valid
+      entry.save_response('Booo hoo hoo hooo', field)
+      entry.should_not be_valid
+    end
+  end
+
+  describe 'ResponseFieldAddress' do
+    let(:field) { form.response_fields.create(label: "Address", type: "Formbuilder::ResponseFieldAddress", sort_order: 0) }
+
+    it 'required' do
+      field.update_attributes(required: true)
+      entry.should_not be_valid
+      entry.save_response({'street' => '123'}, field)
+      entry.should be_valid
+    end
+  end
+
+  describe 'ResponseFieldDate' do
+    let(:field) { form.response_fields.create(label: "Date", type: "Formbuilder::ResponseFieldDate", sort_order: 0) }
+
+    it 'validates properly' do
+      entry.should be_valid
+      entry.save_response({'month' => '2'}, field)
+      entry.should_not be_valid
+      entry.save_response({'month' => '2', 'day' => '3'}, field)
+      entry.should_not be_valid
+      entry.save_response({'month' => '2', 'day' => '3', 'year' => '2011'}, field)
+      entry.should be_valid
+
+      # @todo  automatically add 20** or 19** to dates
+    end
+  end
+
+  describe 'ResponseFieldEmail' do
+    let(:field) { form.response_fields.create(label: "Email", type: "Formbuilder::ResponseFieldEmail", sort_order: 0) }
+
+    it 'validates properly' do
+      entry.should be_valid
+      entry.save_response('a', field)
+      entry.should_not be_valid
+      entry.save_response('a@a.com', field)
+      entry.should be_valid
+    end
+  end
+
+  describe 'ResponseFieldNumber' do
+    let(:field) { form.response_fields.create(label: "Number", type: "Formbuilder::ResponseFieldNumber", sort_order: 0) }
+
+    it 'min/max' do
+      field.update_attributes(field_options: { 'min' => '5', 'max' => '10' })
+      entry.should be_valid
+      entry.save_response('1', field)
+      entry.should_not be_valid
+      entry.save_response('4.99999', field)
+      entry.should_not be_valid
+      entry.save_response('5.01', field)
+      entry.should be_valid
+      entry.save_response('10.00', field)
+      entry.should be_valid
+      entry.save_response('10.9', field)
+      entry.should_not be_valid
+    end
+
+    it 'integer only' do
+      field.update_attributes(field_options: { 'integer_only' => true })
+      entry.should be_valid
+      entry.save_response('1.2', field)
+      entry.should_not be_valid
+      entry.save_response('1.0', field)
+      entry.should_not be_valid
+      entry.save_response('1', field)
+      entry.should be_valid
+    end
+  end
+
+  describe 'ResponseFieldPrice' do
+    let(:field) { form.response_fields.create(label: "Price", type: "Formbuilder::ResponseFieldPrice", sort_order: 0) }
+
+    it 'validates properly' do
+      entry.should be_valid
+      entry.save_response({ 'dollars' => 'a' }, field)
+      entry.should_not be_valid
+      entry.save_response({ 'dollars' => '0' }, field)
+      entry.should be_valid
+      entry.save_response({ 'dollars' => '1a' }, field)
+      entry.should_not be_valid
+      entry.save_response({ 'dollars' => '1' }, field)
+      entry.should be_valid
+      entry.save_response({ 'cents' => 'a' }, field)
+      entry.should_not be_valid
+      entry.save_response({ 'cents' => '0' }, field)
+      entry.should be_valid
+      entry.save_response({ 'cents' => '1a' }, field)
+      entry.should_not be_valid
+      entry.save_response({ 'cents' => '1' }, field)
+      entry.should be_valid
+      entry.save_response({ 'dollars' => '3a', 'cents' => '1' }, field)
+      entry.should_not be_valid
+      entry.save_response({ 'dollars' => '3', 'cents' => '100z' }, field)
+      entry.should_not be_valid
+    end
+  end
+
+  describe 'ResponseFieldTime' do
+    let(:field) { form.response_fields.create(label: "Time", type: "Formbuilder::ResponseFieldTime", sort_order: 0) }
+
+    it 'validates properly' do
+      entry.should be_valid
+      entry.save_response({'hours' => '0'}, field)
+      entry.should_not be_valid
+      entry.save_response({'hours' => '0', 'minutes' => '1'}, field)
+      entry.should_not be_valid
+      entry.save_response({'hours' => '1', 'minutes' => '3'}, field)
+      entry.should be_valid
+    end
+  end
+
+  describe 'ResponseFieldWebsite' do
+    let(:field) { form.response_fields.create(label: "Website", type: "Formbuilder::ResponseFieldWebsite", sort_order: 0) }
+
+    it 'validates properly' do
+      entry.should be_valid
+      # @todo add real validations for website field?
+    end
+  end
+
+end

data/spec/lib/formbuilder/entry_with_alternate_column_name_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe EntryWithAlternateColumnName do
+
+  let!(:form) { FactoryGirl.create(:form_with_one_field) }
+  let!(:entry) { e = EntryWithAlternateColumnName.new(form: form, skip_validation: true); e.save; e }
+  let(:first_field) { form.response_fields.first }
+
+  subject { entry }
+
+  describe '#value_present?' do
+    it 'should be true if there is a value' do
+      entry.value_present?(first_field).should == false
+      entry.responses_alt[first_field.id.to_s] = 'foo'
+      entry.value_present?(first_field).should == true
+    end
+  end
+
+  describe '#response_value' do
+    context 'when value is serialized' do
+      let(:first_field_serialized) { first_field.becomes!(Formbuilder::ResponseFieldCheckboxes) }
+
+      it 'should unserialize a value if necessary' do
+        entry.responses_alt[first_field_serialized.id.to_s] = { a: 'b' }.to_yaml
+        entry.response_value(first_field_serialized).should == { a: 'b' }
+      end
+    end
+  end
+
+  describe '#save_responses' do
+    it 'should behave properly' do
+      entry.save_responses({ "#{first_field.id}" => 'boo' }, form.response_fields)
+      entry.response_value(first_field).should == 'boo'
+    end
+  end
+
+end