formulary 0.0.1 → 0.0.2

data/spec/html_form/fields/select_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Formulary::HtmlForm::Fields::Select do
+  describe ".compatible_with?" do
+    subject { Formulary::HtmlForm::Fields::Select.compatible_with?(element) }
+
+    context "with a select" do
+      let(:markup) { %{<select name="name"></select>} }
+      it { should be_true }
+    end
+
+    context "with a textarea" do
+      let(:markup) { %{<textarea name="name"></textarea>} }
+      it { should be_false }
+    end
+
+    context "with an input type" do
+      let(:markup) { %{<input type="text" name="name" />} }
+      it { should be_false }
+    end
+  end
+
+  describe "validations" do
+    subject(:input) { Formulary::HtmlForm::Fields::Select.new(element) }
+    let(:markup) do
+      <<-EOS
+        <select name="name">
+          <option>First Text</option>
+          <option value="second_value">Second Text</option>
+        </select>
+      EOS
+    end
+
+    context "passed the text from a valueless option" do
+      before { input.set_value("First Text") }
+
+      it { should be_valid }
+      its(:error) { should be_blank }
+    end
+
+    context "passed the value from an option with a value" do
+      before { input.set_value("second_value") }
+
+      it { should be_valid }
+      its(:error) { should be_blank }
+    end
+
+    context "passed the text from a value with an option" do
+      before { input.set_value("Second Text") }
+
+      it { should_not be_valid }
+      its(:error) { should include("choose") }
+    end
+
+    context "passed a value that is not in the options" do
+      before { input.set_value("unknown") }
+
+      it { should_not be_valid }
+      its(:error) { should include("choose") }
+    end
+  end
+end

data/spec/html_form/fields/tel_input_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Formulary::HtmlForm::Fields::TelInput do
+  describe ".compatible_with?" do
+    subject { Formulary::HtmlForm::Fields::TelInput.compatible_with?(element) }
+    let(:markup) { %{<input type="#{type}" name="name" />} }
+
+    context "text type" do
+      let(:type) { "text" }
+      it { should be_false }
+    end
+
+    context "tel type" do
+      let(:type) { "tel" }
+      it { should be_true }
+    end
+  end
+
+  it_should_behave_like "a field that allows the required attribute" do
+    let(:markup_with_required) { %{<input type="tel" name="field" required />} }
+    let(:markup_without_required) { %{<input type="tel" name="field" />} }
+    let(:valid_value) { "123-123-1234" }
+  end
+
+  it_should_behave_like "a field that allows the pattern attribute" do
+    let(:markup) { '<input type="tel" name="field" pattern="\d{3}-\d{3}-\d{4}" />' }
+    let(:valid_value) { "123-123-1234" }
+  end
+end

data/spec/html_form/fields/text_input_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Formulary::HtmlForm::Fields::TextInput do
+  describe ".compatible_with?" do
+    subject { Formulary::HtmlForm::Fields::TextInput.compatible_with?(element) }
+    let(:markup) { %{<input type="#{type}" name="name" />} }
+
+    context "text type" do
+      let(:type) { "text" }
+      it { should be_true }
+    end
+
+    context "email type" do
+      let(:type) { "email" }
+      it { should be_false }
+    end
+  end
+
+  it_should_behave_like "a field that allows the required attribute" do
+    let(:markup_with_required) { %{<input type="text" name="field" required />} }
+    let(:markup_without_required) { %{<input type="text" name="field" />} }
+    let(:valid_value) { "test" }
+  end
+
+  it_should_behave_like "a field that allows the pattern attribute" do
+    let(:markup) { %{<input type="text" name="field" pattern="^test$" />} }
+    let(:valid_value) { "test" }
+  end
+end

data/spec/html_form/fields/textarea_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Formulary::HtmlForm::Fields::Textarea do
+  describe ".compatible_with?" do
+    subject { Formulary::HtmlForm::Fields::Textarea.compatible_with?(element) }
+
+    context "with a textarea" do
+      let(:markup) { %{<textarea name="name"></textarea>} }
+      it { should be_true }
+    end
+
+    context "with a select" do
+      let(:markup) { %{<select name="name"></select>} }
+      it { should be_false }
+    end
+
+    context "with an input type" do
+      let(:markup) { %{<input type="text" name="name" />} }
+      it { should be_false }
+    end
+  end
+
+  it_should_behave_like "a field that allows the required attribute" do
+    let(:markup_with_required) { %{<textarea name="field" required></textarea>} }
+    let(:markup_without_required) { %{<textarea name="field"></textarea>} }
+    let(:valid_value) { "test" }
+  end
+end

data/spec/html_form_spec.rb

@@ -35,152 +35,96 @@ describe Formulary::HtmlForm do
         </div>
 
         <div class="field">
-          <label for="street_address">Street Address</label>
-          <input type="text" name="street_address" />
+          <label for="message">Message</label>
+          <textarea name="message"></textarea>
         </div>
 
         <div class="field">
-          <label for="city">City</label>
-          <input type="text" name="city" pattern="^[A-Za-z]*$" />
+          <label for="unit">Unit</label>
+          <select name="unit">
+            <option>5x5</option>
+            <option value="5x10">Five By Ten</option>
+          </select>
         </div>
 
-        <div class="field">
-          <label for="state">State</label>
-          <input type="text" name="state" />
-        </div>
+        <input type="radio" name="foods" value="bacon">Bacon<br>
+        <input type="radio" name="foods" value="butter" checked>Butter<br>
 
-        <div class="field">
-          <label for="zip">Zip</label>
-          <input type="text" name="zip" />
-        </div>
+        <input type="radio" name="beverages" value="water">Water<br>
 
-        <div class="field">
-          <label for="message">Message</label>
-          <textarea name="message"></textarea>
-        </div>
+        <input type="hidden" name="syndication_url" value="example.com" />
 
-        <input type="submit" value="Apply" />
+        <input type="checkbox" name="terms">
 
+        <input type="submit" value="Apply" />
       </form>
     </div>
     EOS
   end
 
-  def valid_params(hash = {})
-    {
-      first_name: "First",
-      last_name: "Last",
-      email: "test@test.com",
-      g5_email: "test@getg5.com"
-    }.merge(hash)
-  end
-
   let(:html_form) { Formulary::HtmlForm.new(markup) }
 
-  describe "#fields" do
-    let(:fields) { html_form.fields }
-    subject { fields }
-
-    its(:length) { should eq(10) }
-
-    describe "a required text input" do
-      subject { fields.first }
-
-      its(:name) { should eq("first_name") }
-      its(:type) { should eq("text") }
-      its(:required) { should be_true }
-    end
-
-    describe "a textarea that is not required" do
-      subject { fields[9] }
-
-      its(:name) { should eq("message") }
-      its(:type) { should eq("textarea") }
-      its(:required) { should be_false }
-    end
-
-    describe "an input with a pattern attribute" do
-      subject { fields[6] }
+  context "unsupported field type" do
+    let(:markup) { %{<input type="bacon" name="delicious" />} }
 
-      its(:pattern) { should eq("^[A-Za-z]*$") }
+    it "explodes" do
+      expect { html_form }.to raise_error(Formulary::UnsupportedFieldType, /bacon/)
     end
   end
 
-  describe "#valid?" do
-    subject(:valid) { html_form.valid?(params) }
-    #before { subject }
-
-    context "with valid parameters" do
-      let(:params) { valid_params }
-      it { should be_true }
+  describe "validations" do
+    let(:valid_params) do
+      {
+        first_name: "First",
+        last_name: "Last",
+        email: "test@test.com",
+        g5_email: "test@getg5.com",
+        unit: "5x5"
+      }
     end
 
-    context "with valid parameters" do
-      context "phone number" do
-        let(:params) { valid_params(phone: "+1 456 123987") }
+    describe "#valid?" do
+      subject(:valid) { html_form.valid?(params) }
+
+      context "with a valid submission" do
+        let(:params) { valid_params }
         it { should be_true }
       end
-    end
-
-    context "with invalid parameters" do
-      context "due to missing parameters" do
-        let(:params) { { last_name: "" } }
 
+      context "with an invalid submission" do
+        let(:params) { {} }
         it { should be_false }
-
-        it "has an error for an omitted field" do
-          html_form.errors.keys.should include("first_name")
-          html_form.errors["first_name"].should include("required")
-        end
-
-        it "has an error for a blank field" do
-          html_form.errors.keys.should include("last_name")
-          html_form.errors["last_name"].should include("required")
-        end
       end
 
-      context "due to failing regex check" do
-        let(:params) { valid_params(city: "New York") }
-
-        it { should be_false }
+      context "due to unexpected parameters" do
+        let(:params) { valid_params.merge(extra: "test") }
 
-        it "has an error for the field that doesn't match the pattern" do
-          valid
-          html_form.errors.keys.should include("city")
-          html_form.errors["city"].should include("format")
+        it "raises a Formulary::UnexpectedParameter exception" do
+          expect { valid }.to raise_error(Formulary::UnexpectedParameter, /extra/)
         end
       end
+    end
 
-      context "due to invalid email address" do
-        let(:params) { valid_params(email: "testing") }
-
-        it { should be_false }
+    describe "#errors" do
+      before { html_form.valid?(params) }
+      subject { html_form.errors }
 
-        it "has an error for the email field" do
-          valid
-          html_form.errors.keys.should include("email")
-          html_form.errors["email"].should include("not a valid email")
-        end
+      context "with a valid submission" do
+        let(:params) { valid_params }
+        it { should be_empty }
       end
 
-      context "due to invalid g5 email address" do
-        let(:params) { valid_params(g5_email: "test@test.com") }
-
-        it { should be_false }
-
-        it "has an error for the g5 email field" do
-          valid
-          html_form.errors.keys.should include("g5_email")
-          html_form.errors["g5_email"].should include("format")
+      context "with an invalid submission" do
+        let(:params) do
+          {
+            email: "invalid", g5_email: "test@example.com", foods: "water"
+          }
         end
-      end
-
-      context "due to unexpected parameters" do
-        let(:params) { valid_params(extra: "test") }
 
-        it "raises a Formulary::UnexpectedParameter exception" do
-          expect { valid }.to raise_error(Formulary::UnexpectedParameter, /extra/)
-        end
+        its(["first_name"]) { should include("required") }
+        its(["email"]) { should include("email") }
+        its(["g5_email"]) { should include("format") }
+        its(["foods"]) { should include("choose") }
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,18 +1,13 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'pry'
+require 'support/shared_examples_for_pattern'
+require 'support/shared_examples_for_required'
+require 'support/element_helper'
+
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
   config.order = 'random'
 end
 

data/spec/support/element_helper.rb

@@ -0,0 +1,15 @@
+module ElementHelper
+  def element
+    @element ||= elements.first
+  end
+
+  def elements
+    @elements ||= \
+      Nokogiri::HTML("<html><body>#{markup}</body></html>").
+        css("body > *")
+  end
+end
+
+RSpec.configure do |config|
+  config.include ElementHelper
+end

data/spec/support/shared_examples_for_pattern.rb

@@ -0,0 +1,15 @@
+shared_examples_for "a field that allows the pattern attribute" do
+  subject(:input) { described_class.new(element) }
+
+  context "with a matching value" do
+    before { input.set_value(valid_value) }
+    it { should be_valid }
+    its(:error) { should be_blank }
+  end
+
+  context "without a matching value" do
+    before { input.set_value("z") }
+    it { should_not be_valid }
+    its(:error) { should include("format") }
+  end
+end

data/spec/support/shared_examples_for_required.rb

@@ -0,0 +1,35 @@
+shared_examples_for "a field that allows the required attribute" do
+  subject(:input) { described_class.new(element) }
+
+  context "required" do
+    let(:markup) { markup_with_required }
+
+    context "with a submitted value" do
+      before { input.set_value(valid_value) }
+      it { should be_valid }
+      its(:error) { should be_blank }
+    end
+
+    context "submitted a blank value" do
+      before { input.set_value("") }
+      it { should_not be_valid }
+      its(:error) { should include("required") }
+    end
+
+    context "submitted a nil value" do
+      before { input.set_value(nil) }
+      it { should_not be_valid }
+      its(:error) { should include("required") }
+    end
+  end
+
+  context "not required" do
+    let(:markup) { markup_without_required }
+
+    context "without a submitted value" do
+      before { input.set_value("") }
+      it { should be_valid }
+      its(:error) { should be_blank }
+    end
+  end
+end