activeadmin 1.3.1 → 1.4.0

data/spec/unit/view_helpers/display_helper_spec.rb

@@ -1,203 +0,0 @@
-require 'rails_helper'
-require 'active_admin/view_helpers/active_admin_application_helper'
-require 'active_admin/view_helpers/auto_link_helper'
-require 'active_admin/view_helpers/display_helper'
-require 'active_admin/view_helpers/method_or_proc_helper'
-
-RSpec.describe ActiveAdmin::ViewHelpers::DisplayHelper do
-  include ActiveAdmin::ViewHelpers::ActiveAdminApplicationHelper
-  include ActiveAdmin::ViewHelpers::AutoLinkHelper
-  include ActiveAdmin::ViewHelpers::DisplayHelper
-  include MethodOrProcHelper
-  include ActionView::Helpers::UrlHelper
-  include ActionView::Helpers::TranslationHelper
-  include ActionView::Helpers::SanitizeHelper
-
-  def active_admin_namespace
-    active_admin_application.namespaces[:admin]
-  end
-
-  def authorized?(*)
-    true
-  end
-
-  def url_options
-    { locale: nil }
-  end
-
-  before do
-    load_resources do
-      ActiveAdmin.register(User)
-      ActiveAdmin.register(Post){ belongs_to :user, optional: true }
-    end
-  end
-
-  describe '#display_name' do
-    ActiveAdmin::Application.new.display_name_methods.map(&:to_s).each do |m|
-      it "should return #{m} when defined" do
-        klass = Class.new do
-          define_method(m) { m }
-        end
-        expect(display_name klass.new).to eq m
-      end
-
-      it "should sanitize the result of #{m} when defined" do
-        klass = Class.new do
-          define_method(m) { '<script>alert(1)</script>' }
-        end
-        expect(display_name klass.new).to eq 'alert(1)'
-      end
-    end
-
-    it "should memoize the result for the class" do
-      subject = Class.new.new
-      expect(subject).to receive(:name).twice.and_return "My Name"
-
-      expect(display_name subject).to eq "My Name"
-
-      expect(ActiveAdmin.application).to_not receive(:display_name_methods)
-      expect(display_name subject).to eq "My Name"
-    end
-
-    it "should not call a method if it's an association" do
-      klass = Class.new
-      subject = klass.new
-      allow(klass).to receive(:reflect_on_all_associations).and_return [ double(name: :login) ]
-      allow(subject).to receive :login
-      expect(subject).to_not receive :login
-      allow(subject).to receive(:email).and_return 'foo@bar.baz'
-
-      expect(display_name subject).to eq 'foo@bar.baz'
-    end
-
-    it "should return `nil` when the passed object is `nil`" do
-      expect(display_name nil).to eq nil
-    end
-
-    it "should return 'false' when the passed object is `false`" do
-      expect(display_name false).to eq "false"
-    end
-
-    it "should default to `to_s`" do
-      subject = Class.new.new
-      expect(display_name subject).to eq sanitize(subject.to_s)
-    end
-
-    context "when no display name method is defined" do
-      context "on a Rails model" do
-        it "should show the model name" do
-          class ThisModel
-            extend ActiveModel::Naming
-          end
-          subject = ThisModel.new
-          expect(display_name subject).to eq "This model"
-        end
-
-        it "should show the model name, plus the ID if in use" do
-          subject = Tagging.create!
-          expect(display_name subject).to eq "Tagging #1"
-        end
-
-        it "should translate the model name" do
-          with_translation activerecord: {models: {tagging: {one: "Different"}}} do
-            subject = Tagging.create!
-            expect(display_name subject).to eq "Different #1"
-          end
-        end
-      end
-    end
-  end
-
-  describe '#format_attribute' do
-    it 'calls the provided block to format the value' do
-      value = format_attribute double(foo: 2), ->r { r.foo + 1 }
-
-      expect(value).to eq '3'
-    end
-
-    it 'finds values as methods' do
-      value = format_attribute double(name: 'Joe'), :name
-
-      expect(value).to eq 'Joe'
-    end
-
-    it 'finds values from hashes' do
-      value = format_attribute({id: 100}, :id)
-
-      expect(value).to eq '100'
-    end
-
-    [1, 1.2, :a_symbol].each do |val|
-      it "calls to_s to format the value of type #{val.class}" do
-        value = format_attribute double(foo: val), :foo
-
-        expect(value).to eq val.to_s
-      end
-    end
-
-    it 'localizes dates' do
-      date = Date.parse '2016/02/28'
-
-      value = format_attribute double(date: date), :date
-
-      expect(value).to eq 'February 28, 2016'
-    end
-
-    it 'localizes times' do
-      time = Time.parse '2016/02/28 9:34 PM'
-
-      value = format_attribute double(time: time), :time
-
-      expect(value).to eq 'February 28, 2016 21:34'
-    end
-
-    it 'uses a display_name method for arbitrary objects' do
-      object = double to_s: :wrong, display_name: :right
-
-      value = format_attribute double(object: object), :object
-
-      expect(value).to eq 'right'
-    end
-
-    it 'auto-links ActiveRecord records by association' do
-      post = Post.create! author: User.new
-
-      value = format_attribute post, :author
-
-      expect(value).to match /<a href="\/admin\/users\/\d+"> <\/a>/
-    end
-
-    it 'auto-links ActiveRecord records & uses a display_name method' do
-      post = Post.create! author: User.new(first_name: 'A', last_name: 'B')
-
-      value = format_attribute post, :author
-
-      expect(value).to match /<a href="\/admin\/users\/\d+">A B<\/a>/
-    end
-
-    pending 'auto-links Mongoid records'
-
-    it 'calls status_tag for boolean values' do
-      post = Post.new starred: true
-
-      value = format_attribute post, :starred
-
-      expect(value.to_s).to eq "<span class=\"status_tag yes\">Yes</span>\n"
-    end
-
-    it 'calls status_tag for boolean non-database values' do
-      post = Post.new
-      post.define_singleton_method(:true_method) do
-        true
-      end
-      post.define_singleton_method(:false_method) do
-        false
-      end
-      true_value = format_attribute post, :true_method
-      expect(true_value.to_s).to eq "<span class=\"status_tag yes\">Yes</span>\n"
-      false_value = format_attribute post, :false_method
-      expect(false_value.to_s).to eq "<span class=\"status_tag no\">No</span>\n"
-    end
-
-  end
-end

data/spec/unit/view_helpers/download_format_links_helper_spec.rb

@@ -1,39 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper do
-  describe "class methods" do
-    before :all do
-      begin
-        # The mime type to be used in respond_to |format| style web-services in rails
-        Mime::Type.register "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", :xlsx
-      rescue NameError
-        puts "Mime module not defined. Skipping registration of xlsx"
-      end
-    end
-
-    subject do
-      Class.new do
-        include ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper
-      end
-    end
-
-    it "extends the class to add a formats class method that returns the default formats." do
-      expect(subject.formats).to eq [:csv, :xml, :json]
-    end
-
-    it "does not let you alter the formats array directly" do
-      subject.formats << :xlsx
-      expect(subject.formats).to eq [:csv, :xml, :json]
-    end
-
-    it "allows us to add new formats" do
-      subject.add_format :xlsx
-      expect(subject.formats).to eq [:csv, :xml, :json, :xlsx]
-    end
-
-    it "raises an exception if you provide an unregisterd mime type extension" do
-      expect{ subject.add_format :hoge }.to raise_error 'Please register the hoge mime type with `Mime::Type.register`'
-    end
-
-  end
-end

data/spec/unit/view_helpers/fields_for_spec.rb

@@ -1,50 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::ViewHelpers::FormHelper, ".fields_for" do
-  include ActiveAdmin::ViewHelpers::FormHelper
-
-  it "should skip :action, :controller and :commit" do
-    expect(fields_for_params(
-      scope: "All", action: "index", controller: "PostController", commit: "Filter", utf8: "Yes!")).
-      to eq [ { scope: "All" } ]
-  end
-
-  it "should skip the except" do
-    expect(fields_for_params({scope: "All", name: "Greg"}, except: :name)).
-      to eq [ { scope: "All" } ]
-  end
-
-  it "should allow an array for the except" do
-    expect(fields_for_params({scope: "All", name: "Greg", age: "12"}, except: [:name, :age])).
-      to eq [ { scope: "All" } ]
-  end
-
-  it "should work with hashes" do
-    params = fields_for_params(filters: { name: "John", age: "12" })
-
-    expect(params.size).to eq 2
-    expect(params).to include({"filters[name]" => "John" })
-    expect(params).to include({ "filters[age]" => "12" })
-  end
-
-  it "should work with nested hashes" do
-    expect(fields_for_params(filters: { user: { name: "John" }})).
-      to eq [ { "filters[user][name]" => "John" } ]
-  end
-
-  it "should work with arrays" do
-    expect(fields_for_params(people: ["greg", "emily", "philippe"])).
-      to eq [ { "people[]" => "greg" },
-                  { "people[]" => "emily" },
-                  { "people[]" => "philippe" } ]
-  end
-
-  it "should work with symbols" do
-    expect(fields_for_params(filter: :id)).
-      to eq [ { filter: "id" } ]
-  end
-
-  it "should work with booleans" do
-    expect(fields_for_params(booleantest: false)).to eq [ { booleantest: false } ]
-  end
-end

data/spec/unit/view_helpers/flash_helper_spec.rb

@@ -1,24 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::ViewHelpers::FlashHelper do
-
-  describe '.flash_messages' do
-    let(:view) { action_view }
-
-    it "should not include 'timedout' flash messages by default" do
-      view.request.flash[:alert] = "Alert"
-      view.request.flash[:timedout] = true
-      expect(view.flash_messages).to include 'alert'
-      expect(view.flash_messages).to_not include 'timedout'
-    end
-
-    it "should not return flash messages included in flash_keys_to_except" do
-      expect(view.active_admin_application).to receive(:flash_keys_to_except).and_return ["hideme"]
-      view.request.flash[:alert] = "Alert"
-      view.request.flash[:hideme] = "Do not show"
-      expect(view.flash_messages).to include 'alert'
-      expect(view.flash_messages).to_not include 'hideme'
-    end
-
-  end
-end

data/spec/unit/view_helpers/form_helper_spec.rb

@@ -1,42 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::ViewHelpers::FormHelper do
-
-  describe '.active_admin_form_for' do
-    let(:view) { action_view }
-    let(:resource) { double 'resource' }
-    let(:default_options) { { builder: ActiveAdmin::FormBuilder } }
-
-    it 'calls semantic_form_for with the ActiveAdmin form builder' do
-      expect(view).to receive(:semantic_form_for).with(resource, builder: ActiveAdmin::FormBuilder)
-      view.active_admin_form_for(resource)
-    end
-
-    it 'allows the form builder to be customized' do
-      # We can't use a stub here because options gets marshalled, and a new
-      # instance built. Any constant will work.
-      custom_builder = Object
-      expect(view).to receive(:semantic_form_for).with(resource, builder: custom_builder)
-      view.active_admin_form_for(resource, builder: custom_builder)
-    end
-  end
-
-  describe ".hidden_field_tags_for" do
-    let(:view) { action_view }
-
-    it "should render hidden field tags for params" do
-      html = Capybara.string view.hidden_field_tags_for(ActionController::Parameters.new(scope: "All", filter: "None"))
-      expect(html).to have_selector("input#hidden_active_admin_scope[name=scope][type=hidden][value=All]", visible: false)
-      expect(html).to have_selector("input#hidden_active_admin_filter[name=filter][type=hidden][value=None]", visible: false)
-    end
-
-    it "should generate not default id for hidden input" do
-      expect(view.hidden_field_tags_for(ActionController::Parameters.new(scope: "All"))[/id="([^"]+)"/, 1]).to_not eq "scope"
-    end
-
-    it "should filter out the field passed via the option :except" do
-      html = Capybara.string view.hidden_field_tags_for(ActionController::Parameters.new(scope: "All", filter: "None"), except: :filter)
-      expect(html).to have_selector("input#hidden_active_admin_scope[name=scope][type=hidden][value=All]", visible: false)
-    end
-  end
-end

data/spec/unit/view_helpers/method_or_proc_helper_spec.rb

@@ -1,138 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe MethodOrProcHelper do
-  let(:receiver) { double }
-
-  let(:context) do
-    obj = double receiver_in_context: receiver
-    obj.extend MethodOrProcHelper
-    obj
-  end
-
-  describe "#call_method_or_exec_proc" do
-
-    it "should call the method in the context when a symbol" do
-      expect(context.call_method_or_exec_proc(:receiver_in_context)).to eq receiver
-    end
-
-    it "should call the method in the context when a string" do
-      expect(context.call_method_or_exec_proc("receiver_in_context")).to eq receiver
-    end
-
-    it "should exec a proc in the context" do
-      test_proc = Proc.new{ raise "Success" if receiver_in_context }
-
-      expect {
-        context.call_method_or_exec_proc(test_proc)
-      }.to raise_error("Success")
-    end
-
-  end
-
-  describe "#call_method_or_proc_on" do
-
-    [:hello, 'hello'].each do |key|
-      context "when a #{key.class}" do
-        it "should call the method on the receiver" do
-          expect(receiver).to receive(key).and_return 'hello'
-
-          expect(context.call_method_or_proc_on(receiver, key)).to eq 'hello'
-        end
-
-        it "should receive additional arguments" do
-          expect(receiver).to receive(key).with(:world).and_return 'hello world'
-
-          expect(context.call_method_or_proc_on(receiver, key, :world)).to eq 'hello world'
-        end
-      end
-    end
-
-    context "when a proc" do
-
-      it "should exec the block in the context and pass in the receiver" do
-        test_proc = Proc.new do |arg|
-          raise "Success!" if arg == receiver_in_context
-        end
-
-        expect {
-          context.call_method_or_proc_on(receiver, test_proc)
-        }.to raise_error("Success!")
-      end
-
-      it "should receive additional arguments" do
-        test_proc = Proc.new do |arg1, arg2|
-          raise "Success!" if arg1 == receiver_in_context && arg2 == "Hello"
-        end
-
-        expect {
-          context.call_method_or_proc_on(receiver, test_proc, "Hello")
-        }.to raise_error("Success!")
-      end
-
-    end
-
-    context "when a proc and exec: false" do
-
-      it "should call the proc and pass in the receiver" do
-        obj_not_in_context = double
-
-        test_proc = Proc.new do |arg|
-          raise "Success!" if arg == receiver && obj_not_in_context
-        end
-
-        expect {
-          context.call_method_or_proc_on(receiver, test_proc, exec: false)
-        }.to raise_error("Success!")
-      end
-
-    end
-
-  end
-
-  describe "#render_or_call_method_or_proc_on" do
-    [ :symbol, Proc.new{} ].each do |key|
-      context "when a #{key.class}" do
-        it "should call #call_method_or_proc_on" do
-          options = { foo: :bar }
-          expect(context).to receive(:call_method_or_proc_on).with(receiver, key, options).and_return("data")
-          expect(context.render_or_call_method_or_proc_on(receiver, key, options)).to eq "data"
-        end
-      end
-    end
-
-    context "when a string" do
-      it "should return the string" do
-        expect(context.render_or_call_method_or_proc_on(receiver, "string")).to eq "string"
-      end
-    end
-  end
-
-  describe "#render_in_context" do
-    let(:args) { [1, 2, 3] }
-
-    context "when a Proc" do
-      let(:object) { Proc.new { } }
-
-      it "should instance_exec the Proc" do
-        expect(receiver).to receive(:instance_exec).with(args, &object).and_return("data")
-        expect(context.render_in_context(receiver, object, args)).to eq "data"
-      end
-    end
-
-    context "when a Symbol" do
-      it "should send the symbol" do
-        expect(receiver).to receive(:public_send).with(:symbol, args).and_return("data")
-        expect(context.render_in_context(receiver, :symbol, args)).to eq "data"
-      end
-    end
-
-    context "when a Object (not Proc or String)" do
-      let(:object) { Object.new }
-
-      it "should return the Object" do
-        expect(context.render_in_context(receiver, object)).to eq object
-      end
-    end
-  end
-
-end