formbuilder-rb 0.0.4 → 0.2.0

data/spec/lib/formbuilder/views/entry_dl_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Formbuilder::Views::EntryDl do
+
+  TEXT_FIELD_PARAMS = { label: "Text", type: "Formbuilder::ResponseFieldText", sort_order: 0 }
+
+  let(:form) { FactoryGirl.create(:form) }
+  let(:entry) { e = Entry.new(form: form); e.save(validate: false); e }
+
+  it 'should display a label for blind fields' do
+    form.response_fields.create TEXT_FIELD_PARAMS.merge(blind: true)
+    Formbuilder::Views::EntryDl.new(entry: entry, form: form, show_blind: true).to_html.should match('Blind')
+  end
+
+  it 'should only display blind fields when instructed to' do
+    form.response_fields.create TEXT_FIELD_PARAMS.merge(blind: true)
+    Formbuilder::Views::EntryDl.new(entry: entry, form: form).to_html.should_not match('Blind')
+  end
+
+  it 'should optionally display a label for admin only fields' do
+    form.response_fields.create TEXT_FIELD_PARAMS.merge(admin_only: true)
+    Formbuilder::Views::EntryDl.new(entry: entry, form: form).to_html.should_not match('Admin only')
+    Formbuilder::Views::EntryDl.new(entry: entry, form: form, show_admin_only: true).to_html.should match('Admin only')
+  end
+
+  it 'should display placeholder text if there is no response' do
+    form.response_fields.create TEXT_FIELD_PARAMS
+    Formbuilder::Views::EntryDl.new(entry: entry, form: form).to_html.should match('No response')
+  end
+
+  it 'should display the response' do
+    rf = form.response_fields.create TEXT_FIELD_PARAMS
+    entry.save_response('buzz', rf)
+    entry.save(validate: false)
+    Formbuilder::Views::EntryDl.new(entry: entry, form: form).to_html.should match('buzz')
+  end
+
+end

data/spec/models/formbuilder/entry_attachment_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Formbuilder::EntryAttachment do
+
+  let!(:model) { Formbuilder::EntryAttachment.new }
+
+  it 'saves the content type and file size' do
+    model.upload = File.open(File.join(Formbuilder.root, 'spec/fixtures/test_files/text.txt'))
+    model.save
+    model.upload.should be_present
+    model.file_size.should == 8
+    model.content_type.should == 'text/plain'
+    model.update_attributes(remove_upload: true)
+    model.upload.should_not be_present
+  end
+
+end

data/spec/models/formbuilder/form_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Formbuilder::Form do
+
+  let(:form) { Formbuilder::Form.new }
+  subject { form }
+
+  it { should be_valid }
+  it { should respond_to(:formable) }
+  it { should respond_to(:response_fields) }
+
+  describe '#copy_response_fields!' do
+    let!(:other_form) do
+      f = Formbuilder::Form.create
+      f.response_fields.create(type: 'Formbuilder::ResponseFieldText', label: 'foo')
+      f
+    end
+
+    it 'copies properly' do
+      form.save
+      form.response_fields.count.should == 0
+      form.copy_response_fields!(other_form)
+      form.response_fields.count.should == 1
+    end
+  end
+
+  describe '#num_pages' do
+    before { form.save }
+
+    context 'no response fields' do
+      its(:num_pages) { should eq 1 }
+    end
+
+    context 'multiple response fields' do
+      before do
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldText', label: 'foo')
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldParagraph', label: 'foo2')
+      end
+
+      its(:num_pages) { should eq 1 }
+    end
+
+    context '2 pages' do
+      before do
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldText', label: 'foo')
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldPageBreak')
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldParagraph', label: 'foo2')
+      end
+
+      its(:num_pages) { should eq 2 }
+    end
+
+    context 'with 3 pages' do
+      before do
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldText', label: 'foo')
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldPageBreak')
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldParagraph', label: 'foo2')
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldPageBreak')
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldText', label: 'foo3')
+      end
+
+      its(:num_pages) { should eq 3 }
+    end
+
+    context 'with admin only fields' do
+      before do
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldText', label: 'foo')
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldPageBreak')
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldParagraph', label: 'foo2', admin_only: true)
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldPageBreak')
+        form.response_fields.create(type: 'Formbuilder::ResponseFieldText', label: 'foo3')
+      end
+
+      context 'showing admin only' do
+        before { form.show_admin_only = true }
+        its(:num_pages) { should eq 3 }
+      end
+
+      context 'not showing admin only' do
+        its(:num_pages) { should eq 2 }
+      end
+    end
+  end
+
+  describe '#response_fields_for_page' do
+    before { form.save }
+
+    context 'with 2 pages' do
+      let!(:rf1) { form.response_fields.create(type: 'Formbuilder::ResponseFieldText', label: 'foo') }
+      let!(:rf2) { form.response_fields.create(type: 'Formbuilder::ResponseFieldPageBreak') }
+      let!(:rf3) { form.response_fields.create(type: 'Formbuilder::ResponseFieldParagraph', label: 'foo2') }
+
+      it 'calculates properly' do
+        expect(form.response_fields_for_page(1)).to eq [rf1]
+        expect(form.response_fields_for_page(2)).to eq [rf3]
+      end
+    end
+  end
+
+end

data/spec/models/formbuilder/response_field_address_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Formbuilder::ResponseFieldAddress do
+
+  let(:response_field) { Formbuilder::ResponseFieldAddress.new }
+  subject { response_field }
+  subject(:rf) { response_field }
+
+  describe '#audit_response' do
+    it 'geocodes properly' do
+      Geocoder.should_receive(:coordinates).and_return([1, 1])
+      all_responses = {}
+      response_field.audit_response({ 'street' => 'New York, NY, US' }, all_responses)
+      expect(all_responses["#{response_field.id}_x"]).to eq 1
+    end
+  end
+
+  describe '#sortable_value' do
+    it 'functions properly' do
+      expect(rf.sortable_value({'city' => 'zzzz', 'street' => 'adams town'})).to be < rf.sortable_value({'street' => 'cffff'})
+      expect(rf.sortable_value({'city' => 'aaaa', 'street' => 'zzzz'})).to be > rf.sortable_value({'street' => 'cffff'})
+    end
+  end
+
+end

data/spec/models/formbuilder/response_field_checkboxes_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Formbuilder::ResponseFieldCheckboxes do
+
+  let(:response_field) do
+    Formbuilder::ResponseFieldCheckboxes.new(
+      field_options: { 'options' => [{'label' => 'foo', 'checked' => false}]}
+    )
+  end
+  subject { response_field }
+  subject(:rf) { response_field }
+
+  describe '#normalize_response' do
+    it 'calculates the individual sortable values' do
+      all_responses = {}
+      rf.normalize_response({'foo' => true}, all_responses)
+      all_responses["#{rf.id}_sortable_values_foo"].should eq true
+    end
+  end
+
+  describe '#transform_raw_value' do
+    let(:entry) { Entry.new }
+
+    it 'transforms the options properly' do
+      transformed = rf.transform_raw_value({ '0' => 'on' }, entry)
+      transformed['foo'].should == true
+    end
+
+    it 'transforms the other option' do
+      transformed = rf.transform_raw_value({ 'other_checkbox' => 'on', 'other' => 'bar' }, entry)
+      transformed['Other'].should == 'bar'
+    end
+
+    it 'does not save the other option unless the checkbox is checked' do
+      transformed = rf.transform_raw_value({ 'other_checkbox' => nil, 'other' => 'bar' }, entry)
+      transformed['Other'].should == nil
+    end
+
+    it 'sets the _present attribute' do
+      rf.transform_raw_value({ '0' => 'on' }, entry)
+      entry.responses["#{rf.id}_present"].should == true
+      rf.transform_raw_value({ '0' => nil }, entry)
+      entry.responses["#{rf.id}_present"].should == nil
+      rf.transform_raw_value({ 'other_checkbox' => 'on', 'other' => 'z' }, entry)
+      entry.responses["#{rf.id}_present"].should == true
+    end
+  end
+
+  describe '#render_entry_text' do
+    it 'functions properly' do
+      expect(rf.render_entry_text({'foo' => true})).to eq 'foo: y'
+      expect(rf.render_entry_text({'foo' => true, 'bar' => false})).to eq "foo: y\nbar: n"
+      expect(rf.render_entry_text({'foo' => true, 'Other' => 'yee'})).to eq "foo: y\nOther: yee"
+    end
+  end
+
+end

data/spec/models/formbuilder/response_field_file_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Formbuilder::ResponseFieldFile do
+
+  let!(:form) { Formbuilder::Form.create }
+  let!(:response_field) { Formbuilder::ResponseFieldFile.create(form: form) }
+  let!(:entry) { Entry.create(form: form) }
+
+  let(:file_value) { File.open(File.expand_path('../../fixtures/test_files/text2.txt', File.dirname(__FILE__))) }
+
+  subject { response_field }
+  subject(:rf) { response_field }
+
+  describe '#audit_response' do
+    it 'adds the filename param' do
+      entry.save_response([file_value], rf)
+      entry.audit_responses
+      entry.responses["#{rf.id}_filename"].should == 'text2.txt'
+    end
+  end
+
+  describe '#sortable_value' do
+    it 'calculates properly' do
+      entry.save_response([file_value], rf)
+      entry.responses["#{rf.id}_sortable_value"].should == 1
+    end
+  end
+
+  describe '#transform_raw_value' do
+    it 'preserves old upload' do
+      entry.save_response([file_value], rf)
+      initial_attachment = rf.get_attachments(entry.responses[rf.id.to_s]).first
+      entry.save_response([], rf)
+      initial_attachment.reload.should be_present
+    end
+
+    it 'removes old upload when setting a new one' do
+      entry.save_response([file_value], rf)
+      initial_attachment = rf.get_attachments(entry.responses[rf.id.to_s]).first
+      entry.save_response([file_value], rf)
+      expect { initial_attachment.reload }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+
+    it 'uploads multiple files' do
+      expect {
+        entry.save_response([file_value, file_value], rf)
+      }.to change { Formbuilder::EntryAttachment.count }.by(2)
+
+      rf.get_attachments(entry.responses[rf.id.to_s]).length.should == 2
+    end
+
+    it 'does not choke on nil values' do
+      expect {
+        entry.save_response([nil], rf)
+      }.to_not change { Formbuilder::EntryAttachment.count }
+    end
+  end
+
+  describe '#render_entry' do
+    before do
+      entry.save_response([file_value], rf)
+    end
+
+    it 'renders properly' do
+      rf.render_entry(entry.responses[rf.id.to_s]).should match 'text2.txt'
+    end
+  end
+
+  describe '#render_entry_text' do
+    before do
+      entry.save_response([file_value], rf)
+    end
+
+    it 'renders properly' do
+      rf.render_entry_text(entry.responses[rf.id.to_s]).should match 'text2.txt'
+      rf.render_entry_text(entry.responses[rf.id.to_s]).should_not match '<'
+    end
+  end
+
+end

data/spec/models/formbuilder/response_field_paragraph_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Formbuilder::ResponseFieldParagraph do
+
+  let(:response_field) { Formbuilder::ResponseFieldParagraph.new }
+  subject { response_field }
+
+  describe '#render_entry' do
+    INPUT = "blah blah\n\nhttp://www.google.com asldfkj"
+    EXPECTED_OUTPUT = %Q{<p>blah blah</p>\n\n<p><a href="http://www.google.com">http://www.google.com</a> asldfkj</p>}
+
+    it 'autolinks properly' do
+      expect(response_field.render_entry(INPUT)).to eq EXPECTED_OUTPUT
+    end
+
+    it 'doesnt choke on nil value' do
+      expect(response_field.render_entry(nil)).to eq ''
+      expect(response_field.render_entry('')).to eq ''
+    end
+  end
+
+end

data/spec/models/formbuilder/response_field_radio_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Formbuilder::ResponseFieldRadio do
+
+  let(:response_field) do
+    Formbuilder::ResponseFieldRadio.new(
+      field_options: { 'options' => [{'label' => 'foo', 'checked' => false}]}
+    )
+  end
+  subject { response_field }
+  subject(:rf) { response_field }
+
+  describe '#transform_raw_value' do
+    before { rf.save }
+    let(:entry) { Entry.new }
+
+    it 'does not set the other option if raw_value is not other' do
+      transformed = rf.transform_raw_value('Goats', entry, { response_field_params: { "#{rf.id}_other" => 'foo' } })
+      transformed.should == 'Goats'
+      entry.responses["#{rf.id}_other"].should == nil
+    end
+
+    it 'sets the other option on the entry if raw_value is other' do
+      transformed = rf.transform_raw_value('Other', entry, { response_field_params: { "#{rf.id}_other" => 'foo' } })
+      transformed.should == 'Other'
+      entry.responses["#{rf.id}_other"].should == 'foo'
+    end
+  end
+
+end

data/spec/models/formbuilder/response_field_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Formbuilder::ResponseField do
+
+  let(:response_field) { Formbuilder::ResponseFieldText.new }
+  subject { response_field }
+
+  it { should be_valid }
+
+  describe '#options_array' do
+    its(:options_array) { should be_empty }
+
+    context 'with options' do
+      before { response_field.field_options['options'] = [{'checked' => 'false', 'label' => 'Choice #1'},
+                                                          {'checked' => 'false', 'label' => 'Choice #2'}] }
+
+      its(:options_array) { should == ['Choice #1', 'Choice #2'] }
+    end
+  end
+
+end

data/spec/models/formbuilder/response_field_table_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Formbuilder::ResponseFieldTable do
+
+  let(:response_field) do
+    Formbuilder::ResponseFieldTable.new(
+      field_options: { 'columns' => [{'label' => 'column one'}],
+                       'column_totals' => true }
+    )
+  end
+  subject { response_field }
+  subject(:rf) { response_field }
+
+  describe '#normalize_response' do
+    it 'calculates the individual sortable values' do
+      all_responses = {}
+      rf.normalize_response({'column one' => ['1', '2', '3.5', 'asdf']}, all_responses)
+      all_responses["#{rf.id}_sum_column one"].should eq 6.5
+    end
+
+    it 'calculates the sums' do
+      all_responses = {}
+      rf.normalize_response({'column one' => ['asdfasdf', 'fasdf']}, all_responses)
+      all_responses["#{rf.id}_sum_column one"].should eq 0
+    end
+  end
+
+  describe '#transform_raw_value' do
+    let(:entry) { Entry.new }
+
+    before do
+      response_field.update_attributes(
+        field_options: { 'columns' => [{'label' => 'column one'},
+                                       {'label' => 'column two'}] }
+      )
+    end
+
+    it 'transforms the options properly' do
+      transformed = rf.transform_raw_value({ '0' => ['foo', 'bar'] }, entry)
+      transformed['column one'].should == ['foo', 'bar']
+    end
+
+    it 'preserves rows with one input' do
+      transformed = rf.transform_raw_value({ '0' => ['', 'bar'], '1' => ['baz', ''] }, entry)
+      transformed['column one'].should == ['', 'bar']
+      transformed['column two'].should == ['baz', '']
+
+    end
+
+    it 'removes blank rows' do
+      transformed = rf.transform_raw_value({ '0' => ['', 'bar'], '1' => ['', 'baz'] }, entry)
+      transformed['column one'].should == ['bar']
+      transformed['column two'].should == ['baz']
+    end
+
+    it 'doesnt choke on nils' do
+      transformed = rf.transform_raw_value({ }, entry)
+      transformed['column one'].should == nil
+      transformed['column two'].should == nil
+    end
+  end
+
+  describe '#render_entry_text' do
+    it 'functions properly' do
+      expect(rf.render_entry_text({'column one' => ['bar', 'baz']})).to eq 'column one: bar, baz'
+    end
+  end
+
+  describe '#render_entry' do
+    it 'does not trip on blanks' do
+      rendered = rf.render_entry(
+        {'column one' => ['bar', 'baz']},
+        entry: OpenStruct.new(get_responses: {})
+      )
+      expect(rendered).to match 'bar'
+      expect(rendered).to match 'baz'
+      expect(rendered).to_not match '0'
+    end
+
+    it 'does not render zeroes' do
+      rendered = rf.render_entry(
+        {'column one' => ['bar', 'baz']},
+        entry: OpenStruct.new(get_responses: {"#{rf.id}_sum_column one" => '0.0'})
+      )
+      expect(rendered).to match 'bar'
+      expect(rendered).to match 'baz'
+      expect(rendered).to_not match '0'
+    end
+
+    it 'renders sums greater than zero' do
+      rendered = rf.render_entry(
+        {'column one' => ['bar', '1', '1.5']},
+        entry: OpenStruct.new(get_responses: {"#{rf.id}_sum_column one" => '2.5'})
+      )
+      expect(rendered).to match 'bar'
+      expect(rendered).to match '1'
+      expect(rendered).to match '1.5'
+      expect(rendered).to match '2.5'
+    end
+  end
+
+  describe '#render_input' do
+    it 'renders properly' do
+      rendered = rf.render_input({})
+      expect(rendered).to match("<textarea")
+    end
+
+    context 'with default row values' do
+      before do
+        rf.field_options['preset_values'] = {'column one' => ['p1', 'p2']}
+        rf.field_options['minrows'] = 2
+        rf.save
+      end
+
+      it 'renders properly' do
+        rendered = rf.render_input({})
+        expect(rendered).to match(">p1<")
+        expect(rendered).to match(">p2<")
+        expect(rendered).to match("readonly")
+      end
+    end
+  end
+
+end