releaf-core 0.2.1

data/spec/lib/releaf/core/resource_table_fields_spec.rb

@@ -0,0 +1,18 @@
+require "rails_helper"
+
+describe Releaf::Core::ResourceTableFields do
+  subject{ described_class.new(Book) }
+
+  describe "#excluded_attributes" do
+    it "returns attributes to exclude from table alongside parent method list" do
+      allow(subject).to receive(:table_excluded_attributes).and_return(%w(xxx yyy))
+      expect(subject.excluded_attributes).to include("id", "created_at", "xxx", "yyy")
+    end
+  end
+
+  describe "#table_excluded_attributes" do
+    it "returns array with attributes matching *_html pattern" do
+      expect(subject.table_excluded_attributes).to eq(%w(summary_html))
+    end
+  end
+end

data/spec/lib/releaf/core/resource_utilities_spec.rb

@@ -0,0 +1,87 @@
+require "rails_helper"
+
+describe Releaf::Core::ResourceUtilities do
+  let(:resource){ Releaf::Permissions::Role.new }
+  let(:users_association){ resource.class.reflect_on_association(:users) }
+  let(:permissions_association){ resource.class.reflect_on_association(:permissions) }
+
+  describe ".restricted_associations" do
+    it "returns hash with restricted association objects and controller" do
+      allow(described_class).to receive(:restricted_associations).with(resource).and_return([permissions_association, users_association])
+      allow(described_class).to receive(:association_controller).with(users_association).and_return("aa")
+      allow(described_class).to receive(:association_controller).with(permissions_association).and_return("bb")
+      resource.users.build
+      resource.permissions.build
+
+      expect(described_class.restricted_relations(resource)).to eq(
+        users: {objects: resource.users, controller: "aa"},
+        permissions: {objects: resource.permissions, controller: "bb"},
+      )
+    end
+  end
+
+  describe ".association_controller" do
+    it "returns guessed controller from given association name" do
+      expect(described_class.association_controller(users_association)).to eq("users")
+    end
+
+    context "when no controller guessed" do
+      it "returns nil" do
+        expect(described_class.association_controller(permissions_association)).to be nil
+      end
+    end
+  end
+
+  describe ".restricted_associations" do
+    it "returns array with restricted associations" do
+      allow(described_class).to receive(:restricted_association?).with(resource, users_association).and_return(false)
+      allow(described_class).to receive(:restricted_association?).with(resource, permissions_association).and_return(true)
+      expect(described_class.restricted_associations(resource)).to eq([permissions_association])
+    end
+  end
+
+  describe ".restricted_association?" do
+    context "when associations with dependent option `restrict_with_exception` given" do
+      let(:association){ resource.class.reflect_on_association(:users) }
+
+      context "when association object(-s) exists" do
+        it "returns true" do
+          resource.users.build
+          users = resource.users
+          allow(resource).to receive(:users).and_return(users)
+          allow(users).to receive(:exists?).and_return(true)
+          expect(described_class.restricted_association?(resource, association)).to be true
+        end
+      end
+
+      context "when association object(-s) does not exist" do
+        it "returns false" do
+          expect(described_class.restricted_association?(resource, association)).to be false
+        end
+      end
+    end
+
+    context "when associations with dependent option other than `restrict_with_exception` given" do
+      it "returns false" do
+        association = resource.class.reflect_on_association(:permissions)
+        expect(described_class.restricted_association?(resource, association)).to be false
+      end
+    end
+  end
+
+  describe ".destroyable?" do
+    context "when no restricted association" do
+      it "returns true" do
+        allow(described_class).to receive(:restricted_associations).with(resource).and_return([])
+        expect(described_class.destroyable?(resource)).to be true
+      end
+    end
+
+    context "when restricted association exist" do
+      it "returns false" do
+        allow(described_class).to receive(:restricted_associations).with(resource).and_return([:a])
+        expect(described_class.destroyable?(resource)).to be false
+      end
+    end
+  end
+end

data/spec/lib/releaf/core/responders/access_denied_responder_spec.rb

@@ -0,0 +1,12 @@
+require "rails_helper"
+
+describe Releaf::Core::Responders::AccessDeniedResponder, type: :controller do
+  controller{}
+  subject{ described_class.new(controller, []) }
+
+  describe "#status_code" do
+    it "returns 404" do
+      expect(subject.status_code).to eq(403)
+    end
+  end
+end

data/spec/lib/releaf/core/responders/after_save_responder_spec.rb

@@ -0,0 +1,102 @@
+require "rails_helper"
+
+describe Releaf::Core::Responders::AfterSaveResponder, type: :controller do
+  let(:controller){ Releaf::BaseController.new }
+  let(:resource){ Book.new}
+  subject{ described_class.new(controller, [resource]) }
+
+  describe "#json_resource_errors" do
+    it "returns resource errors formatted with `Releaf::Releaf::ErrorFormatter`" do
+      allow(Releaf::Core::ErrorFormatter).to receive(:format_errors).with(resource).and_return(a: "b")
+      expect(subject.json_resource_errors).to eq(errors: {a: "b"})
+    end
+  end
+
+  describe "#render_notification?" do
+    before do
+      allow(subject).to receive(:has_errors?).and_return(true)
+      allow(subject).to receive(:format).and_return(:json)
+    end
+
+    context "when request format is other json" do
+      it "returns true" do
+        allow(subject).to receive(:format).and_return(:html)
+        expect(subject.render_notification?).to be true
+      end
+    end
+
+    context "when object has no errors" do
+      it "returns true" do
+        allow(subject).to receive(:has_errors?).and_return(false)
+        expect(subject.render_notification?).to be true
+      end
+    end
+
+    context "when request format is json and object has errors" do
+      it "returns false" do
+        expect(subject.render_notification?).to be false
+      end
+    end
+  end
+
+  describe "#respond" do
+    before do
+      allow(subject).to receive(:to_html)
+    end
+
+    context "when render notifications return `true`" do
+      it "renders notification with success value true/false whether resource has errors" do
+        allow(subject).to receive(:render_notification?).and_return(true)
+        allow(subject).to receive(:has_errors?).and_return(true)
+        expect(subject.controller).to receive(:render_notification).with(false)
+        subject.respond
+
+        allow(subject).to receive(:has_errors?).and_return(false)
+        expect(subject.controller).to receive(:render_notification).with(true)
+        subject.respond
+      end
+    end
+
+    context "when render notifications return `false`" do
+      it "does not render notification" do
+        allow(subject).to receive(:render_notification?).and_return(false)
+        expect(subject.controller).to_not receive(:render_notification)
+        subject.respond
+      end
+    end
+  end
+
+  describe "#to_json" do
+    context "when resource has errors" do
+      it "calls `display_errors`" do
+        allow(subject).to receive(:has_errors?).and_return(true)
+        expect(subject).to receive(:display_errors)
+        subject.to_json
+      end
+    end
+
+    context "when resource has no errors" do
+      before do
+        allow(subject).to receive(:resource_location).and_return("some_url")
+        allow(subject).to receive(:has_errors?).and_return(false)
+      end
+
+      context "when options has :redirect key" do
+        it "calls `display_errors`" do
+          allow(subject).to receive(:options).and_return(redirect: true)
+          expect(subject).to receive(:render).with(json: {url: "some_url"}, status: 303)
+          subject.to_json
+        end
+      end
+
+      context "when options has key :destroyable with `false` value" do
+        it "renders `refused_destroy` template" do
+          allow(subject).to receive(:options).and_return({})
+          expect(subject).to receive(:redirect_to).with("some_url", status: 303)
+          subject.to_json
+        end
+      end
+    end
+  end
+end
+

data/spec/lib/releaf/core/responders/confirm_destroy_responder_spec.rb

@@ -0,0 +1,26 @@
+require "rails_helper"
+
+describe Releaf::Core::Responders::ConfirmDestroyResponder, type: :controller do
+  let(:controller){ Releaf::BaseController.new }
+  let(:resource){ Book.new}
+  subject{ described_class.new(controller, [resource]) }
+
+  describe "#to_html" do
+    context "when options has key :destroyable with `true` value" do
+      it "renders default view" do
+        allow(subject).to receive(:options).and_return(destroyable: true)
+        expect(subject).to receive(:default_render)
+        subject.to_html
+      end
+    end
+
+    context "when options has key :destroyable with `false` value" do
+      it "renders `refused_destroy` template" do
+        allow(subject).to receive(:options).and_return(destroyable: false)
+        expect(subject).to receive(:render).with("refused_destroy")
+        subject.to_html
+      end
+    end
+  end
+end
+

data/spec/lib/releaf/core/responders/destroy_responder_spec.rb

@@ -0,0 +1,30 @@
+require "rails_helper"
+
+describe Releaf::Core::Responders::DestroyResponder, type: :controller do
+  let(:controller){ Releaf::BaseController.new }
+  let(:resource){ Book.new}
+  subject{ described_class.new(controller, [resource]) }
+
+  describe "#to_html" do
+    before do
+      allow(controller).to receive(:request).and_return(request)
+      allow(controller).to receive(:formats).and_return([:html])
+      allow(subject).to receive(:default_render)
+    end
+
+    context "when resource has been successfully destroyed" do
+      it "renders success notification" do
+        resource.destroy
+        expect(subject.controller).to receive(:render_notification).with(true, failure_message_key: "cant destroy, because relations exists")
+        subject.to_html
+      end
+    end
+
+    context "when resource has not been destroyed" do
+      it "renders failure notification" do
+        expect(subject.controller).to receive(:render_notification).with(false, failure_message_key: "cant destroy, because relations exists")
+        subject.to_html
+      end
+    end
+  end
+end

data/spec/lib/releaf/core/responders/error_responder_spec.rb

@@ -0,0 +1,26 @@
+require "rails_helper"
+
+describe Releaf::Core::Responders::ErrorResponder, type: :controller do
+  class Releaf::Core::Responders::DummyErrorResponder < ActionController::Responder
+    include Releaf::Core::Responders::ErrorResponder
+    def status_code
+      401
+    end
+  end
+
+  controller{}
+  subject{ Releaf::Core::Responders::DummyErrorResponder.new(controller, []) }
+
+  describe "#template" do
+    it "returns template based on class name" do
+      expect(subject.template).to eq("dummy_error")
+    end
+  end
+
+  describe "#to_html" do
+    it "renders error template with class status code" do
+      expect(subject).to receive(:render).with("releaf/error_pages/dummy_error", status: 401)
+      subject.to_html
+    end
+  end
+end

data/spec/lib/releaf/core/responders/feature_disabled_responder_spec.rb

@@ -0,0 +1,12 @@
+require "rails_helper"
+
+describe Releaf::Core::Responders::FeatureDisabledResponder, type: :controller do
+  controller{}
+  subject{ described_class.new(controller, []) }
+
+  describe "#status_code" do
+    it "returns 404" do
+      expect(subject.status_code).to eq(403)
+    end
+  end
+end

data/spec/lib/releaf/core/responders/page_not_found_responder_spec.rb

@@ -0,0 +1,12 @@
+require "rails_helper"
+
+describe Releaf::Core::Responders::PageNotFoundResponder, type: :controller do
+  controller{}
+  subject{ described_class.new(controller, []) }
+
+  describe "#status_code" do
+    it "returns 404" do
+      expect(subject.status_code).to eq(404)
+    end
+  end
+end

data/spec/lib/releaf/core/responders_spec.rb

@@ -0,0 +1,60 @@
+require "rails_helper"
+
+describe Releaf::Core::Responders, type: :controller do
+  subject{ Releaf::BaseController.new }
+
+  describe "#respond_with" do
+    before do
+      allow(subject).to receive(:active_responder).and_return(Releaf::Core::Responders::AfterSaveResponder)
+      allow(subject).to receive(:request).and_return(request)
+      allow(subject).to receive(:content_type).and_return(:html)
+    end
+
+    context "when no responder defined within options" do
+      it "adds active responder to `responder` options" do
+        expect(Releaf::Core::Responders::AfterSaveResponder).to receive(:call)
+        subject.respond_with(nil)
+      end
+    end
+
+    context "when responder is defined within options" do
+      it "adds active responder to `responder` options" do
+        expect(Releaf::Core::Responders::AfterSaveResponder).to_not receive(:call)
+        expect(Releaf::Core::Responders::PageNotFoundResponder).to receive(:call)
+        subject.respond_with(nil, responder: Releaf::Core::Responders::PageNotFoundResponder)
+      end
+    end
+  end
+
+  describe "#action_responders" do
+    it "returns hash with action to responders matching" do
+      hash = {
+        create: Releaf::Core::Responders::AfterSaveResponder,
+        update: Releaf::Core::Responders::AfterSaveResponder,
+        confirm_destroy: Releaf::Core::Responders::ConfirmDestroyResponder,
+        destroy: Releaf::Core::Responders::DestroyResponder,
+        access_denied: Releaf::Core::Responders::AccessDeniedResponder,
+        feature_disabled: Releaf::Core::Responders::FeatureDisabledResponder,
+        page_not_found: Releaf::Core::Responders::PageNotFoundResponder,
+      }
+      expect(subject.action_responders).to eq(hash)
+    end
+  end
+
+  describe "#action_responder" do
+    it "returns matching responder for given action" do
+      allow(subject).to receive(:action_responders).and_return(a: "x")
+      expect(subject.action_responder(:a)).to eq("x")
+      allow(subject).to receive(:action_responders).and_return(b: "x")
+      expect(subject.action_responder(:a)).to be nil
+    end
+  end
+
+  describe "#active_responder" do
+    it "returns currect action matching responder" do
+      allow(subject).to receive(:action_name).and_return(:save)
+      allow(subject).to receive(:action_responder).with(:save).and_return("x")
+      expect(subject.active_responder).to eq("x")
+    end
+  end
+end

data/spec/lib/releaf/core/template_field_type_mapper_spec.rb

@@ -0,0 +1,311 @@
+require "rails_helper"
+
+describe Releaf::Core::TemplateFieldTypeMapper do
+  let(:object){ double("generic object") }
+
+  def file_field_error_message field_name, obj
+    "object doesn't respond to `%s` method. Did you forgot to add `file_accessor :%s` to `%s` model?" % [field_name, field_name, obj.class.name]
+  end
+
+  def image_field_error_message field_name, obj
+    "object doesn't respond to `%s` method. Did you forgot to add `image_accessor :%s` to `%s` model?" % [field_name, field_name, obj.class.name]
+  end
+
+  describe ".field_type_name", pending: true do
+    it "needs tests"
+  end
+
+  describe ".use_i18n?" do
+    context "when object translates" do
+      context "when given attribute translatable" do
+        it "returns true" do
+          expect(described_class.use_i18n?(Book.new, :description)).to be true
+        end
+      end
+
+      context "when attribute does not translatable" do
+        it "returns false" do
+          expect(described_class.use_i18n?(Book.new, :title)).to be false
+        end
+      end
+    end
+
+    context "when object does not translates" do
+      it "returns false" do
+        expect(described_class.use_i18n?(Releaf::Permissions::User.new, :password)).to be false
+      end
+    end
+  end
+
+  describe ".image_or_error" do
+    context "given field_name that doesn't end with _uid" do
+      it "raises ArgumentError" do
+        allow(object).to receive(:image)
+        expect { subject.send(:image_or_error, 'image', object) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'given field_name is `image_uid`' do
+      context 'when object responds to `image` method' do
+        it "returns 'image'" do
+          allow(object).to receive(:image)
+          expect( subject.send(:image_or_error, 'image_uid', object) ).to eq 'image'
+        end
+      end
+
+      context 'when object does not respond to `image` method' do
+        it 'raises RuntimeError' do
+          expect { subject.send(:image_or_error, 'image_uid', object) }.to raise_error(RuntimeError, image_field_error_message('image', object))
+        end
+      end
+    end
+  end
+
+  describe ".file_or_error" do
+    context "given field_name that doesn't end with _uid" do
+      it "raises ArgumentError" do
+        allow(object).to receive(:file)
+        expect { subject.send(:file_or_error, 'file', object) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'given field_name is `file_uid`' do
+      context 'when object responds to `file` method' do
+        it "returns 'file'" do
+          allow(object).to receive(:file)
+          expect( subject.send(:file_or_error, 'file_uid', object) ).to eq 'file'
+        end
+      end
+
+      context 'when object does not respond to `file` method' do
+        it 'raises RuntimeError' do
+          expect { subject.send(:file_or_error, 'file_uid', object) }.to raise_error(RuntimeError, file_field_error_message('file', object))
+        end
+      end
+    end
+  end
+
+  describe ".field_type_name_for_string" do
+    %w[thumbnail_uid image_uid photo_uid photography_uid picture_uid avatar_uid logo_uid banner_uid icon_uid].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        context "when object responds to '#{field_name.sub(/_uid$/, '')}'" do
+          it "returns 'image'" do
+            allow(object).to receive(field_name.sub(/_uid$/, '').to_sym)
+            expect( subject.send(:field_type_name_for_string, field_name, object) ).to eq 'image'
+          end
+        end
+
+        context "when object doesn't respond to '#{field_name.sub(/_uid$/, '')}'" do
+          it "raises RuntimeError" do
+            test_field_name = field_name.sub(/_uid$/, '')
+            expect { subject.send(:field_type_name_for_string, field_name, object) }.to raise_error(RuntimeError, image_field_error_message(test_field_name, object))
+          end
+        end
+      end
+    end
+
+    %w[image_uid2 uid].each do |field_name|
+      context "when attribute_name is '#{field_name}'" do
+        it "doesn't return 'image'" do
+          expect( subject.send(:field_type_name_for_string, field_name, nil) ).to_not eq 'image'
+        end
+
+        it "doesn't return 'file'" do
+          expect( subject.send(:field_type_name_for_string, field_name, nil) ).to_not eq 'file'
+        end
+      end
+    end
+
+    %w[some_uid other_uid cook_file_uid file_uid].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        context "when object responds to '#{field_name.sub(/_uid$/, '')}'" do
+          it "returns 'file'" do
+            allow(object).to receive(field_name.sub(/_uid$/, '').to_sym)
+            expect( subject.send(:field_type_name_for_string, field_name, object) ).to eq 'file'
+          end
+        end
+
+        context "when object doesn't respond to '#{field_name.sub(/_uid$/, '')}'" do
+          it "raises RuntimeError" do
+            test_field_name = field_name.sub(/_uid$/, '')
+            expect { subject.send(:field_type_name_for_string, field_name, object) }.to raise_error(RuntimeError, file_field_error_message(test_field_name, object))
+          end
+        end
+      end
+    end
+
+    %w[pin password password_confirmation encrypted_password some_password some_password_for_secretary].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'password'" do
+          expect( subject.send(:field_type_name_for_string, field_name, nil) ).to eq 'password'
+        end
+      end
+    end
+
+    %w[this_pin pin_that some_pin_for_admin].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "doesn't return 'password'" do
+          expect( subject.send(:field_type_name_for_string, field_name, nil) ).to_not eq 'password'
+        end
+      end
+    end
+
+    %w[email admin_email].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'email'" do
+          expect( subject.send(:field_type_name_for_string, field_name, nil) ).to eq 'email'
+        end
+      end
+    end
+
+    context "when attribute name is 'email_for_admin'" do
+      it "doesn't return 'email'" do
+        expect( subject.send(:field_type_name_for_string, 'email_for_admin', nil) ).to_not eq 'email'
+      end
+    end
+
+    %w[link awesome_link].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'link'" do
+          expect( subject.send(:field_type_name_for_string, field_name, nil) ).to eq 'link'
+        end
+      end
+    end
+
+    context "when attribute name is 'link_to_awesome_site'" do
+      it "doesn't return 'link'" do
+        expect( subject.send(:field_type_name_for_string, 'link_to_awesome_site', nil) ).to_not eq 'link'
+      end
+    end
+
+    %w[www homepage admin_homepage www_page homepage_www url homepage_url site_url url_for_this_site].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "doesn't return 'link'" do
+          expect( subject.send(:field_type_name_for_string, field_name, nil) ).to_not eq 'link'
+        end
+      end
+    end
+
+    %w[www homepage url some_pin uid everything_else html].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'text'" do
+          expect( subject.send(:field_type_name_for_string, field_name, nil) ).to eq 'text'
+        end
+      end
+    end
+  end # describe ".field_type_name_for_string"
+
+
+  describe '.field_type_name_for_text' do
+    %w[url homepage random_url random_homepage random_link cool_link].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'link'" do
+          expect( subject.send(:field_type_name_for_text, field_name, nil) ).to eq 'link'
+        end
+      end
+    end
+
+    %w[url_for_site link_to_site link home_page homepage_for_site].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "doesn't return 'link'" do
+          expect( subject.send(:field_type_name_for_text, field_name, nil) ).to_not eq 'link'
+        end
+      end
+    end
+
+    %w[html random_html].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'richtext'" do
+          expect( subject.send(:field_type_name_for_text, field_name, nil) ).to eq 'richtext'
+        end
+      end
+    end
+
+    context "when attribute name is 'html_for_description'" do
+      it "doesn't return 'richtext'" do
+        expect( subject.send(:field_type_name_for_text, 'html_for_description', nil) ).to_not eq 'richtext'
+      end
+    end
+
+    %w[text description random html_text].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'textarea'" do
+          expect( subject.send(:field_type_name_for_text, field_name, nil) ).to eq 'textarea'
+        end
+      end
+    end
+  end # describe '.field_type_name_for_text'
+
+  describe ".field_type_name_for_datetime" do
+    %w[no matter what].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'datetime'" do
+          expect( subject.send(:field_type_name_for_datetime, field_name, nil) ).to eq 'datetime'
+        end
+      end
+    end
+  end # describe ".field_type_name_for_datetime" do
+  describe ".field_type_name_for_date" do
+    %w[no matter what].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'date'" do
+          expect( subject.send(:field_type_name_for_date, field_name, nil) ).to eq 'date'
+        end
+      end
+    end
+  end # describe ".field_type_name_for_date" do
+  describe ".field_type_name_for_time" do
+    %w[no matter what].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'time'" do
+          expect( subject.send(:field_type_name_for_time, field_name, nil) ).to eq 'time'
+        end
+      end
+    end
+  end # describe ".field_type_name_for_time" do
+  describe ".field_type_name_for_boolean" do
+    %w[no matter what].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'boolean'" do
+          expect( subject.send(:field_type_name_for_boolean, field_name, nil) ).to eq 'boolean'
+        end
+      end
+    end
+  end # describe ".field_type_name_for_boolean" do
+  describe ".field_type_name_for_float" do
+    %w[no matter what].each do |field_name|
+      context "when attribute name is '#{field_name}'" do
+        it "returns 'float'" do
+          expect( subject.send(:field_type_name_for_float, field_name, nil) ).to eq 'float'
+        end
+      end
+    end
+  end # describe ".field_type_name_for_float" do
+
+  describe ".field_type_name_for_integer" do
+    before do
+      author = FactoryGirl.create(:author)
+      @book = FactoryGirl.create(:book, :author => author)
+    end
+
+    context "when attributes ends with '_id'" do
+      context "when there's an ActiveRecord association" do
+        it "returns 'item'" do
+          expect( subject.send(:field_type_name_for_integer, 'author_id', @book) ).to eq 'item'
+        end
+      end
+
+      context "when there's no ActiveRecord association" do
+        it "returns 'text'" do
+          expect( subject.send(:field_type_name_for_integer, 'random_field_id', @book) ).to eq 'integer'
+        end
+      end
+    end
+
+    context "when attribute doesn't end with '_id'" do
+      it "returns 'text'" do
+        expect( subject.send(:field_type_name_for_integer, 'random_field', nil) ).to eq 'integer'
+      end
+    end
+  end # describe ".field_type_name_for_integer"
+end