granite-form 0.1.0

data/spec/lib/granite/form/model/scopes_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Scopes do
+  let(:model) do
+    stub_model do
+      include Granite::Form::Model::Scopes
+
+      attribute :name, String
+
+      class << self
+        def except_first
+          scope[1..-1]
+        end
+
+        def no_mars
+          scope.delete_if { |i| i.name == 'Mars' }
+        end
+
+      private
+
+        def hidden_method() end
+      end
+    end
+  end
+
+  let(:hash_scoped_model) do
+    stub_model do
+      include Granite::Form::Model::Scopes
+      scopify Hash
+    end
+  end
+
+  describe '.scope_class' do
+    specify { expect(model.scope_class).to be < Array }
+    specify { expect(model.scope_class).to eq(model::ScopeProxy) }
+    specify { expect(model.scope_class._scope_model).to eq(model) }
+    specify { expect(model.scope_class.new).to be_empty }
+
+    specify { expect(hash_scoped_model.scope_class).to be < Hash }
+    specify { expect(hash_scoped_model.scope_class).to eq(hash_scoped_model::ScopeProxy) }
+    specify { expect(hash_scoped_model.scope_class._scope_model).to eq(hash_scoped_model) }
+    specify { expect(hash_scoped_model.scope_class.new).to be_empty }
+
+    context do
+      let(:scope) { model.scope([model.new(name: 'Hello'), model.new(name: 'World'), model.new(name: 'Mars')]) }
+
+      specify { expect(scope).to be_instance_of model.scope_class }
+      specify { expect { model.scope([model.new(name: 'Hello'), {}]) }.to raise_error Granite::Form::AssociationTypeMismatch }
+
+      context 'scopes' do
+        specify { expect(scope.except_first).to be_instance_of model.scope_class }
+        specify { expect(scope.no_mars).to be_instance_of model.scope_class }
+        specify { expect(scope.except_first).to eq(model.scope([model.new(name: 'World'), model.new(name: 'Mars')])) }
+        specify { expect(scope.no_mars).to eq(model.scope([model.new(name: 'Hello'), model.new(name: 'World')])) }
+        specify { expect(scope.except_first.no_mars).to eq(model.scope([model.new(name: 'World')])) }
+        specify { expect(scope.no_mars.except_first).to eq(model.scope([model.new(name: 'World')])) }
+        specify { expect { scope.hidden_method }.to raise_error NoMethodError }
+
+        specify { expect(scope).to respond_to(:no_mars) }
+        specify { expect(scope).to respond_to(:except_first) }
+        specify { expect(scope).not_to respond_to(:hidden_method) }
+      end
+    end
+  end
+
+  context do
+    let!(:ancestor) do
+      stub_model do
+        include Granite::Form::Model::Scopes
+      end
+    end
+
+    let!(:descendant1) do
+      Class.new ancestor
+    end
+
+    let!(:descendant2) do
+      Class.new ancestor
+    end
+
+    specify { expect(descendant1.scope_class).to be < Array }
+    specify { expect(descendant2.scope_class).to be < Array }
+    specify { expect(ancestor.scope_class).not_to eq(descendant1.scope_class) }
+    specify { expect(descendant1.scope_class).not_to eq(descendant2.scope_class) }
+  end
+end

data/spec/lib/granite/form/model/typecasting_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes do
+  subject { model.new }
+
+  context 'object' do
+    before { stub_class(:descendant) }
+    let(:model) { stub_model { attribute :column, Object } }
+
+    specify { expect(model.new(column: 'hello').column).to eq('hello') }
+    specify { expect(model.new(column: []).column).to eq([]) }
+    specify { expect(model.new(column: Descendant.new).column).to be_a(Descendant) }
+    specify { expect(model.new(column: Object.new).column).to be_a(Object) }
+    specify { expect(model.new(column: nil).column).to be_nil }
+
+    context do
+      before { stub_class(:descendant2, Descendant) }
+      let(:model) { stub_model { attribute :column, Descendant } }
+
+      specify { expect(model.new(column: 'hello').column).to be_nil }
+      specify { expect(model.new(column: []).column).to be_nil }
+      specify { expect(model.new(column: Descendant.new).column).to be_a(Descendant) }
+      specify { expect(model.new(column: Descendant2.new).column).to be_a(Descendant2) }
+      specify { expect(model.new(column: Object.new).column).to be_nil }
+      specify { expect(model.new(column: nil).column).to be_nil }
+    end
+  end
+
+  context 'string' do
+    let(:model) { stub_model { attribute :column, String } }
+
+    specify { expect(model.new(column: 'hello').column).to eq('hello') }
+    specify { expect(model.new(column: 123).column).to eq('123') }
+    specify { expect(model.new(column: nil).column).to be_nil }
+  end
+
+  context 'integer' do
+    let(:model) { stub_model { attribute :column, Integer } }
+
+    specify { expect(model.new(column: 'hello').column).to be_nil }
+    specify { expect(model.new(column: '123hello').column).to be_nil }
+    specify { expect(model.new(column: '123').column).to eq(123) }
+    specify { expect(model.new(column: '123.5').column).to eq(123) }
+    specify { expect(model.new(column: 123).column).to eq(123) }
+    specify { expect(model.new(column: 123.5).column).to eq(123) }
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: [123]).column).to be_nil }
+  end
+
+  context 'float' do
+    let(:model) { stub_model { attribute :column, Float } }
+
+    specify { expect(model.new(column: 'hello').column).to be_nil }
+    specify { expect(model.new(column: '123hello').column).to be_nil }
+    specify { expect(model.new(column: '123').column).to eq(123.0) }
+    specify { expect(model.new(column: '123.').column).to be_nil }
+    specify { expect(model.new(column: '123.5').column).to eq(123.5) }
+    specify { expect(model.new(column: 123).column).to eq(123.0) }
+    specify { expect(model.new(column: 123.5).column).to eq(123.5) }
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: [123.5]).column).to be_nil }
+  end
+
+  context 'big_decimal' do
+    let(:model) { stub_model { attribute :column, BigDecimal } }
+
+    specify { expect(model.new(column: 'hello').column).to be_nil }
+    specify { expect(model.new(column: '123hello').column).to be_nil }
+    specify { expect(model.new(column: '123').column).to eq(BigDecimal('123.0')) }
+    specify { expect(model.new(column: '123.').column).to be_nil }
+    specify { expect(model.new(column: '123.5').column).to eq(BigDecimal('123.5')) }
+    specify { expect(model.new(column: 123).column).to eq(BigDecimal('123.0')) }
+    specify { expect(model.new(column: 123.5).column).to eq(BigDecimal('123.5')) }
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: [123.5]).column).to be_nil }
+  end
+
+  context 'boolean' do
+    let(:model) { stub_model { attribute :column, Boolean } }
+
+    specify { expect(model.new(column: 'hello').column).to be_nil }
+    specify { expect(model.new(column: 'true').column).to eq(true) }
+    specify { expect(model.new(column: 'false').column).to eq(false) }
+    specify { expect(model.new(column: '1').column).to eq(true) }
+    specify { expect(model.new(column: '0').column).to eq(false) }
+    specify { expect(model.new(column: true).column).to eq(true) }
+    specify { expect(model.new(column: false).column).to eq(false) }
+    specify { expect(model.new(column: 1).column).to eq(true) }
+    specify { expect(model.new(column: 0).column).to eq(false) }
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: [123]).column).to be_nil }
+  end
+
+  context 'array' do
+    let(:model) { stub_model { attribute :column, Array } }
+
+    specify { expect(model.new(column: [1, 2, 3]).column).to eq([1, 2, 3]) }
+    specify { expect(model.new(column: 'hello, world').column).to eq(%w[hello world]) }
+    specify { expect(model.new(column: 10).column).to be_nil }
+  end
+
+  # rubocop:disable Style/DateTime
+  context 'date' do
+    let(:model) { stub_model { attribute :column, Date } }
+    let(:date) { Date.new(2013, 6, 13) }
+
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: '2013-06-13').column).to eq(date) }
+    specify { expect(model.new(column: '2013-55-55').column).to be_nil }
+    specify { expect(model.new(column: 'blablabla').column).to be_nil }
+    specify { expect(model.new(column: DateTime.new(2013, 6, 13, 23, 13)).column).to eq(date) }
+    specify { expect(model.new(column: Time.new(2013, 6, 13, 23, 13)).column).to eq(date) }
+    specify { expect(model.new(column: Date.new(2013, 6, 13)).column).to eq(date) }
+  end
+
+  context 'datetime' do
+    let(:model) { stub_model { attribute :column, DateTime } }
+    let(:datetime) { DateTime.new(2013, 6, 13, 23, 13) }
+
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: '2013-06-13 23:13').column).to eq(datetime) }
+    specify { expect(model.new(column: '2013-55-55 55:55').column).to be_nil }
+    specify { expect(model.new(column: 'blablabla').column).to be_nil }
+    specify { expect(model.new(column: Date.new(2013, 6, 13)).column).to eq(DateTime.new(2013, 6, 13, 0, 0)) }
+    specify { expect(model.new(column: Time.utc(2013, 6, 13, 23, 13).utc).column).to eq(DateTime.new(2013, 6, 13, 23, 13)) }
+    specify { expect(model.new(column: DateTime.new(2013, 6, 13, 23, 13)).column).to eq(DateTime.new(2013, 6, 13, 23, 13)) }
+  end
+
+  context 'time' do
+    let(:model) { stub_model { attribute :column, Time } }
+
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: '2013-06-13 23:13').column).to eq('2013-06-13 23:13'.to_time) }
+    specify { expect(model.new(column: '2013-55-55 55:55').column).to be_nil }
+    specify { expect(model.new(column: 'blablabla').column).to be_nil }
+    specify { expect(model.new(column: Date.new(2013, 6, 13)).column).to eq(Time.new(2013, 6, 13, 0, 0)) }
+    specify { expect(model.new(column: DateTime.new(2013, 6, 13, 19, 13)).column).to eq(DateTime.new(2013, 6, 13, 19, 13).to_time) }
+    specify { expect(model.new(column: Time.new(2013, 6, 13, 23, 13)).column).to eq(Time.new(2013, 6, 13, 23, 13)) }
+
+    context 'Time.zone set' do
+      around { |example| Time.use_zone('Bangkok', &example) }
+
+      specify { expect(model.new(column: nil).column).to be_nil }
+      specify { expect(model.new(column: '2013-06-13 23:13').column).to eq(Time.zone.parse('2013-06-13 23:13')) }
+      specify { expect(model.new(column: '2013-55-55 55:55').column).to be_nil }
+      specify { expect(model.new(column: 'blablabla').column).to be_nil }
+      specify { expect(model.new(column: Date.new(2013, 6, 13)).column).to eq(Time.new(2013, 6, 13, 0, 0)) }
+      specify { expect(model.new(column: DateTime.new(2013, 6, 13, 19, 13)).column).to eq(DateTime.new(2013, 6, 13, 19, 13).to_time) }
+      specify { expect(model.new(column: Time.new(2013, 6, 13, 23, 13)).column).to eq(Time.new(2013, 6, 13, 23, 13)) }
+    end
+  end
+  # rubocop:enable Style/DateTime
+
+  context 'time_zone' do
+    let(:model) { stub_model { attribute :column, ActiveSupport::TimeZone } }
+
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: Object.new).column).to be_nil }
+    specify { expect(model.new(column: Time.now).column).to be_nil }
+    specify { expect(model.new(column: 'blablabla').column).to be_nil }
+    specify { expect(model.new(column: TZInfo::Timezone.all.first).column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: 'Moscow').column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: '+4').column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: '-3').column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: '3600').column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: '-7200').column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: 4).column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: -3).column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: 3600).column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: -7200).column).to be_a ActiveSupport::TimeZone }
+  end
+
+  context 'uuid' do
+    let(:model) { stub_model { attribute :column, Granite::Form::UUID } }
+    let(:uuid) { Granite::Form::UUID.random_create }
+    let(:uuid_tools) { UUIDTools::UUID.random_create }
+
+    specify { expect(uuid.as_json).to eq(uuid.to_s) }
+    specify { expect(uuid.to_json).to eq("\"#{uuid}\"") }
+    specify { expect(uuid.to_param).to eq(uuid.to_s) }
+    specify { expect(uuid.to_query(:key)).to eq("key=#{uuid}") }
+
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: Object.new).column).to be_nil }
+    specify { expect(model.new(column: uuid_tools).column).to be_a Granite::Form::UUID }
+    specify { expect(model.new(column: uuid_tools).column).to eq(uuid_tools) }
+    specify { expect(model.new(column: uuid).column).to eq(uuid) }
+    specify { expect(model.new(column: uuid.to_s).column).to eq(uuid) }
+    specify { expect(model.new(column: uuid.to_i).column).to eq(uuid) }
+    specify { expect(model.new(column: uuid.hexdigest).column).to eq(uuid) }
+    specify { expect(model.new(column: uuid.raw).column).to eq(uuid) }
+  end
+end

data/spec/lib/granite/form/model/validations/associated_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Validations::AssociatedValidator do
+  before do
+    stub_model(:validated_assoc) do
+      include Granite::Form::Model
+      include Granite::Form::Model::Lifecycle
+
+      attribute :name, String
+
+      validates_presence_of :name
+    end
+
+    stub_model(:unvalidated_assoc) do
+      include Granite::Form::Model
+      include Granite::Form::Model::Lifecycle
+
+      attribute :name, String
+    end
+
+    stub_model(:main) do
+      include Granite::Form::Model::Persistence
+      include Granite::Form::Model::Associations
+
+      attribute :name, String
+
+      validates_presence_of :name
+      validates_associated :validated_one, :unvalidated_one, :validated_many, :unvalidated_many
+
+      embeds_one :validated_one, validate: false, class_name: 'ValidatedAssoc'
+      embeds_one :unvalidated_one, class_name: 'UnvalidatedAssoc'
+      embeds_many :validated_many, class_name: 'ValidatedAssoc'
+      embeds_many :unvalidated_many, class_name: 'UnvalidatedAssoc'
+    end
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: {name: 'name'} }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: {} }
+    it { is_expected.not_to be_valid }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to(validated_one: ['is invalid'])
+    end
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: {name: 'name'} }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: {} }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{name: 'name'}] }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{}] }
+    it { is_expected.not_to be_valid }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to('validated_many.0.name': ["can't be blank"], validated_many: ['is invalid'])
+    end
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{name: 'name'}] }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{}] }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{name: 'name'}], validated_one: {} }
+    it { is_expected.not_to be_valid }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to(validated_one: ['is invalid'])
+    end
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{}], validated_one: {name: 'name'} }
+    it { is_expected.not_to be_valid }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to('validated_many.0.name': ["can't be blank"], validated_many: ['is invalid'])
+    end
+  end
+end

data/spec/lib/granite/form/model/validations/nested_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Validations::NestedValidator do
+  before do
+    stub_model(:validated_assoc) do
+      include Granite::Form::Model
+      include Granite::Form::Model::Lifecycle
+      include Granite::Form::Model::Primary
+
+      primary :id, Integer
+      attribute :name, String
+
+      validates_presence_of :name
+    end
+
+    stub_model(:unvalidated_assoc) do
+      include Granite::Form::Model
+      include Granite::Form::Model::Lifecycle
+
+      attribute :name, String
+    end
+
+    stub_model(:main) do
+      include Granite::Form::Model::Persistence
+      include Granite::Form::Model::Associations
+
+      attribute :name, String
+
+      validates_presence_of :name
+
+      embeds_one :validated_one, class_name: 'ValidatedAssoc'
+      embeds_one :unvalidated_one, class_name: 'UnvalidatedAssoc'
+      embeds_many :validated_many, class_name: 'ValidatedAssoc'
+      embeds_many :unvalidated_many, class_name: 'UnvalidatedAssoc'
+    end
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: {name: 'name'} }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: {} }
+    it { is_expected.not_to be_valid }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to('validated_one.name': ["can't be blank"])
+    end
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: {name: 'name'} }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: {} }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{name: 'name'}] }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{}] }
+    it { is_expected.not_to be_valid }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to('validated_many.0.name': ["can't be blank"])
+    end
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{name: 'name'}] }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{}] }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{name: 'name'}], validated_one: {} }
+    it { is_expected.not_to be_valid }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to('validated_one.name': ["can't be blank"])
+    end
+  end
+
+  context 'accepts nested attributes for one' do
+    before { Main.accepts_nested_attributes_for :validated_one, allow_destroy: true }
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: {id: 1, name: 'name'} }
+
+    specify do
+      instance.validated_one_attributes = {id: 1, name: '', _destroy: true}
+      is_expected.to be_valid
+    end
+  end
+
+  context 'accepts nested attributes for many' do
+    before { Main.accepts_nested_attributes_for :validated_many, allow_destroy: true }
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{id: 1, name: 'name'}] }
+
+    specify do
+      instance.validated_many_attributes = [{id: 1, name: '', _destroy: true}]
+      is_expected.to be_valid
+    end
+  end
+
+  context 'object field is invalid and referenced object does not include AutosaveAssociation' do
+    before do
+      stub_class(:validated_object) do
+        include Granite::Form::Model::Validations
+        include Granite::Form::Model::Attributes
+        include Granite::Form::Model::Primary
+
+        primary :id
+        attribute :title, String
+        validates_presence_of :title
+      end
+
+      Main.class_eval do
+        include Granite::Form::Model::Associations
+        attribute :object, Object
+        validates :object, nested: true
+      end
+    end
+
+    subject(:instance) { Main.instantiate name: 'hello', object: object, validated_one: {name: 'name'} }
+
+    context do
+      let(:object) { ValidatedObject.new(title: 'Mr.') }
+      it { is_expected.to be_valid }
+    end
+
+    context do
+      let(:object) { ValidatedObject.new }
+      it do
+        expect { subject.valid? }.not_to raise_error
+        expect(subject).not_to be_valid
+      end
+    end
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{}], validated_one: {name: 'name'} }
+    it { is_expected.not_to be_valid }
+    specify do
+      expect { instance.validate }.to change { instance.errors.messages }
+        .to('validated_many.0.name': ["can't be blank"])
+    end
+  end
+
+  describe '.validates_nested?' do
+    specify { expect(Main).to be_validates_nested(:validated_one) }
+    specify { expect(Main).to be_validates_nested(:unvalidated_one) }
+    specify { expect(Main).not_to be_validates_nested(:something_else) }
+  end
+end

data/spec/lib/granite/form/model/validations_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Validations do
+  let(:model) do
+    stub_model(:model) do
+      attribute :name, String
+      validates :name, presence: true
+    end
+  end
+
+  describe '#errors' do
+    specify { expect(model.new.errors).to be_a ActiveModel::Errors }
+    specify { expect(model.new.errors).to be_empty }
+  end
+
+  describe '#valid?' do
+    specify { expect(model.new).not_to be_valid }
+    specify { expect(model.new(name: 'Name')).to be_valid }
+  end
+
+  describe '#invalid?' do
+    specify { expect(model.new).to be_invalid }
+    specify { expect(model.new(name: 'Name')).not_to be_invalid }
+  end
+
+  describe '#validate!' do
+    specify { expect { model.new.validate! }.to raise_error Granite::Form::ValidationError }
+    specify { expect(model.new(name: 'Name').validate!).to eq(true) }
+    specify { expect { model.new(name: 'Name').validate! }.not_to raise_error }
+  end
+end

data/spec/lib/granite/form/model_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Granite::Form::Model do
+  let(:model) { stub_model }
+  specify { expect { model.blablabla }.to raise_error NoMethodError }
+
+  context 'Fault tolerance' do
+    specify { expect { model.new(foo: 'bar') }.not_to raise_error }
+  end
+end

data/spec/lib/granite/form_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Granite::Form do
+  specify { expect(subject).to respond_to :include_root_in_json }
+  specify { expect(subject).to respond_to :include_root_in_json= }
+  specify { expect(subject).to respond_to :i18n_scope }
+  specify { expect(subject).to respond_to :i18n_scope= }
+  specify { expect(subject).to respond_to :primary_attribute }
+  specify { expect(subject).to respond_to :primary_attribute= }
+  specify { expect(subject).to respond_to :normalizer }
+end