activeadmin-rb 1.4.0

data/spec/unit/view_helpers/display_helper_spec.rb

@@ -0,0 +1,203 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,138 @@
+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