activeadmin 1.0.0.pre4 → 2.4.0

data/spec/unit/settings_spec.rb

@@ -1,118 +0,0 @@
-require 'rails_helper'
-
-describe ActiveAdmin::Settings do
-
-  subject{ Class.new{ include ActiveAdmin::Settings } }
-
-  it{ is_expected.to respond_to :setting }
-  it{ is_expected.to respond_to :deprecated_setting }
-  it{ is_expected.to respond_to :default_settings }
-
-  describe "class API" do
-    it "should create settings" do
-      subject.setting :foo, 'bar'
-      expect(subject.default_settings[:foo]).to eq 'bar'
-    end
-
-    it "should create deprecated settings" do
-      expect(ActiveAdmin::Deprecation).to receive(:deprecate).twice
-      subject.deprecated_setting :baz, 32
-      expect(subject.default_settings[:baz]).to eq 32
-    end
-  end
-
-  describe "instance API" do
-
-    before do
-      subject.setting :foo, 'bar'
-      subject.deprecated_setting :baz, 32
-    end
-    let(:instance) { subject.new }
-
-    it "should have access to a default value" do
-      expect(instance.foo).to eq 'bar'
-      instance.foo = 'qqq'
-      expect(instance.foo).to eq 'qqq'
-    end
-
-    it "should have access to a deprecated value" do
-      expect(ActiveAdmin::Deprecation).to receive(:warn).exactly(3).times
-      expect(instance.baz).to eq 32
-      instance.baz = [45]
-      expect(instance.baz).to eq [45]
-    end
-  end
-
-end
-
-
-describe ActiveAdmin::Settings::Inheritance do
-
-  subject do
-    Class.new do
-      include ActiveAdmin::Settings
-      include ActiveAdmin::Settings::Inheritance
-    end
-  end
-
-  it{ is_expected.to respond_to :settings_inherited_by }
-  it{ is_expected.to respond_to :inheritable_setting }
-  it{ is_expected.to respond_to :deprecated_inheritable_setting }
-
-  let(:heir) { Class.new }
-
-  before do
-    subject.settings_inherited_by heir
-  end
-
-  describe "class API" do
-    it "should add setting to an heir" do
-      subject.inheritable_setting :one, 2
-      expect(heir.default_settings[:one]).to eq 2
-    end
-
-    it "should add deprecated setting to an heir" do
-      expect(ActiveAdmin::Deprecation).to receive(:deprecate).exactly(4).times
-      subject.deprecated_inheritable_setting :three, 4
-      expect(heir.default_settings[:three]).to eq 4
-    end
-  end
-
-  describe "instance API" do
-    describe "the setter `config.left =`" do
-      before{ subject.inheritable_setting :left, :right }
-      it "should work" do
-        config = heir.new
-        config.left = :none
-        expect(config.left).to eq :none
-      end
-    end
-
-    describe "the getter `config.left`" do
-      before{ subject.inheritable_setting :left, :right }
-      it "should work" do
-        expect(heir.new.left).to eq :right
-      end
-    end
-
-    describe "the getter with question-mark `config.left?`" do
-      {
-        "nil" => [nil, false],
-        "false" => [false, false],
-        "true" => [true, true],
-        "string" => ["string", true],
-        "empty string" => ["", false],
-        "array" => [[1, 2], true],
-        "empty array" => [[], false]
-      }.each do |context, (value, result)|
-        context "with a #{context} value" do
-          before{ subject.inheritable_setting :left, value }
-          it "should be #{result}" do
-            expect(heir.new.left?).to eq result
-          end
-        end
-      end
-    end
-  end
-
-end

data/spec/unit/view_factory_spec.rb

@@ -1,19 +0,0 @@
-require 'rails_helper'
-
-def it_should_have_view(key, value)
-  it "should have #{value} for view key '#{key}'" do
-    expect(subject.send(key)).to  eq value
-  end
-end
-
-describe ActiveAdmin::ViewFactory do
-
-  it_should_have_view :global_navigation,    ActiveAdmin::Views::TabbedNavigation
-  it_should_have_view :utility_navigation,   ActiveAdmin::Views::TabbedNavigation
-  it_should_have_view :site_title,           ActiveAdmin::Views::SiteTitle
-  it_should_have_view :action_items,         ActiveAdmin::Views::ActionItems
-  it_should_have_view :header,               ActiveAdmin::Views::Header
-  it_should_have_view :blank_slate,          ActiveAdmin::Views::BlankSlate
-  it_should_have_view :layout,               ActiveAdmin::Views::Pages::Layout
-
-end

data/spec/unit/view_helpers/breadcrumbs_spec.rb

@@ -1,217 +0,0 @@
-require 'rails_helper'
-
-describe "Breadcrumbs" do
-
-  include ActiveAdmin::ViewHelpers
-
-  describe "generating a trail from paths" do
-
-    def params; {}; end
-    def link_to(name, url); {name: name, path: url}; end
-
-    actions = ActiveAdmin::BaseController::ACTIVE_ADMIN_ACTIONS
-
-    let(:user)        { double display_name: 'Jane Doe' }
-    let(:user_config) { double find_resource: user, resource_name: double(route_key: 'users'),
-                               defined_actions: actions }
-    let(:post)        { double display_name: 'Hello World' }
-    let(:post_config) { double find_resource: post, resource_name: double(route_key: 'posts'),
-                               defined_actions: actions, belongs_to_config: double(target: user_config) }
-
-    let :active_admin_config do
-      post_config
-    end
-
-    let(:trail) { breadcrumb_links(path) }
-
-    context "when request '/admin'" do
-      let(:path) { "/admin" }
-
-      it "should not have any items" do
-        expect(trail.size).to eq 0
-      end
-    end
-
-    context "when path 'admin/users'" do
-      let(:path) { 'admin/users' }
-
-      it 'should have one item' do
-        expect(trail.size).to eq 1
-      end
-      it 'should have a link to /admin' do
-        expect(trail[0][:name]).to eq 'Admin'
-        expect(trail[0][:path]).to eq '/admin'
-      end
-    end
-
-    context "when path '/admin/users'" do
-      let(:path) { "/admin/users" }
-
-      it "should have one item" do
-        expect(trail.size).to eq 1
-      end
-      it "should have a link to /admin" do
-        expect(trail[0][:name]).to eq "Admin"
-        expect(trail[0][:path]).to eq "/admin"
-      end
-    end
-
-    context "when path '/admin/users/1'" do
-      let(:path) { "/admin/users/1" }
-
-      it "should have 2 items" do
-        expect(trail.size).to eq 2
-      end
-      it "should have a link to /admin" do
-        expect(trail[0][:name]).to eq "Admin"
-        expect(trail[0][:path]).to eq "/admin"
-      end
-      it "should have a link to /admin/users" do
-        expect(trail[1][:name]).to eq "Users"
-        expect(trail[1][:path]).to eq "/admin/users"
-      end
-    end
-
-    context "when path '/admin/users/1/posts'" do
-      let(:path) { "/admin/users/1/posts" }
-
-      it "should have 3 items" do
-        expect(trail.size).to eq 3
-      end
-      it "should have a link to /admin" do
-        expect(trail[0][:name]).to eq "Admin"
-        expect(trail[0][:path]).to eq "/admin"
-      end
-      it "should have a link to /admin/users" do
-        expect(trail[1][:name]).to eq "Users"
-        expect(trail[1][:path]).to eq "/admin/users"
-      end
-
-      context "when User.find(1) doesn't exist" do
-        before { allow(user_config).to receive(:find_resource) }
-        it "should have a link to /admin/users/1" do
-          expect(trail[2][:name]).to eq "1"
-          expect(trail[2][:path]).to eq "/admin/users/1"
-        end
-      end
-
-      context "when User.find(1) does exist" do
-        it "should have a link to /admin/users/1 using display name" do
-          expect(trail[2][:name]).to eq "Jane Doe"
-          expect(trail[2][:path]).to eq "/admin/users/1"
-        end
-      end
-    end
-
-    context "when path '/admin/users/4e24d6249ccf967313000000/posts'" do
-      let(:path) { "/admin/users/4e24d6249ccf967313000000/posts" }
-
-      it "should have 3 items" do
-        expect(trail.size).to eq 3
-      end
-      it "should have a link to /admin" do
-        expect(trail[0][:name]).to eq "Admin"
-        expect(trail[0][:path]).to eq "/admin"
-      end
-      it "should have a link to /admin/users" do
-        expect(trail[1][:name]).to eq "Users"
-        expect(trail[1][:path]).to eq "/admin/users"
-      end
-
-      context "when User.find(4e24d6249ccf967313000000) doesn't exist" do
-        before { allow(user_config).to receive(:find_resource) }
-        it "should have a link to /admin/users/4e24d6249ccf967313000000" do
-          expect(trail[2][:name]).to eq "4e24d6249ccf967313000000"
-          expect(trail[2][:path]).to eq "/admin/users/4e24d6249ccf967313000000"
-        end
-      end
-
-      context "when User.find(4e24d6249ccf967313000000) does exist" do
-        before do
-          display_name = double(display_name: 'Hello :)')
-          allow(user_config).to receive(:find_resource).and_return(display_name) 
-        end
-        it "should have a link to /admin/users/4e24d6249ccf967313000000 using display name" do
-          expect(trail[2][:name]).to eq "Hello :)"
-          expect(trail[2][:path]).to eq "/admin/users/4e24d6249ccf967313000000"
-        end
-      end
-    end
-
-    context "when path '/admin/users/1/coments/1'" do
-      let(:path) { "/admin/users/1/posts/1" }
-
-      it "should have 4 items" do
-        expect(trail.size).to eq 4
-      end
-      it "should have a link to /admin" do
-        expect(trail[0][:name]).to eq "Admin"
-        expect(trail[0][:path]).to eq "/admin"
-      end
-      it "should have a link to /admin/users" do
-        expect(trail[1][:name]).to eq "Users"
-        expect(trail[1][:path]).to eq "/admin/users"
-      end
-      it "should have a link to /admin/users/1" do
-        expect(trail[2][:name]).to eq "Jane Doe"
-        expect(trail[2][:path]).to eq "/admin/users/1"
-      end
-      it "should have a link to /admin/users/1/posts" do
-        expect(trail[3][:name]).to eq "Posts"
-        expect(trail[3][:path]).to eq "/admin/users/1/posts"
-      end
-    end
-
-    context "when path '/admin/users/1/coments/1/edit'" do
-      let(:path) { "/admin/users/1/posts/1/edit" }
-
-      it "should have 5 items" do
-        expect(trail.size).to eq 5
-      end
-      it "should have a link to /admin" do
-        expect(trail[0][:name]).to eq "Admin"
-        expect(trail[0][:path]).to eq "/admin"
-      end
-      it "should have a link to /admin/users" do
-        expect(trail[1][:name]).to eq "Users"
-        expect(trail[1][:path]).to eq "/admin/users"
-      end
-      it "should have a link to /admin/users/1" do
-        expect(trail[2][:name]).to eq "Jane Doe"
-        expect(trail[2][:path]).to eq "/admin/users/1"
-      end
-      it "should have a link to /admin/users/1/posts" do
-        expect(trail[3][:name]).to eq "Posts"
-        expect(trail[3][:path]).to eq "/admin/users/1/posts"
-      end
-      it "should have a link to /admin/users/1/posts/1" do
-        expect(trail[4][:name]).to eq "Hello World"
-        expect(trail[4][:path]).to eq "/admin/users/1/posts/1"
-      end
-    end
-
-    context "when the 'show' action is disabled" do
-      let(:post_config) { double find_resource: post, resource_name: double(route_key: 'posts'),
-                                 defined_actions: actions - [:show], # this is the change
-                                 belongs_to_config: double(target: user_config) }
-
-      let(:path) { "/admin/posts/1/edit" }
-
-      it "should have 3 items" do
-        expect(trail.size).to eq 3
-      end
-      it "should have a link to /admin" do
-        expect(trail[0][:name]).to eq "Admin"
-        expect(trail[0][:path]).to eq "/admin"
-      end
-      it "should have a link to /admin/posts" do
-        expect(trail[1][:name]).to eq "Posts"
-        expect(trail[1][:path]).to eq "/admin/posts"
-      end
-      it "should not link to the show view for the post" do
-        expect(trail[2]).to eq "Hello World"
-      end
-    end
-
-  end
-end

data/spec/unit/view_helpers/display_helper_spec.rb

@@ -1,165 +0,0 @@
-require 'rails_helper'
-
-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
-
-  def active_admin_namespace
-    active_admin_application.namespaces[:admin]
-  end
-
-  def authorized?(*)
-    true
-  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
-    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 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, Arbre::Element.new].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 from foreign keys' do
-      post = Post.create! author: User.new
-
-      value = format_attribute post, :author_id
-
-      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
-  end
-end

data/spec/unit/view_helpers/download_format_links_helper_spec.rb

@@ -1,39 +0,0 @@
-require 'rails_helper'
-
-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 'active_admin/view_helpers/fields_for'
-
-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,25 +0,0 @@
-require 'rails_helper'
-
-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,43 +0,0 @@
-require 'rails_helper'
-
-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(scope: "All", filter: "None")
-      expect(html).to have_selector("input#hidden_active_admin_scope[name=scope][type=hidden][value=All]")
-      expect(html).to have_selector("input#hidden_active_admin_filter[name=filter][type=hidden][value=None]")
-    end
-
-    it "should generate not default id for hidden input" do
-      expect(view.hidden_field_tags_for(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({scope: "All", filter: "None"}, except: :filter)
-      expect(html).to have_selector("input#hidden_active_admin_scope[name=scope][type=hidden][value=All]")
-    end
-  end
-end
-