activeadmin 1.3.0 → 2.0.0.rc1

data/spec/unit/csv_builder_spec.rb

@@ -1,313 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::CSVBuilder do
-
-  describe '.default_for_resource using Post' do
-    let(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-    let(:resource){ ActiveAdmin::Resource.new(namespace, Post, {}) }
-    let(:csv_builder) { ActiveAdmin::CSVBuilder.default_for_resource(resource).tap(&:exec_columns) }
-
-    it 'returns a default csv_builder for Post' do
-      expect(csv_builder).to be_a(ActiveAdmin::CSVBuilder)
-    end
-
-    it 'defines Id as the first column' do
-      expect(csv_builder.columns.first.name).to eq 'Id'
-      expect(csv_builder.columns.first.data).to eq :id
-    end
-
-    it "has Post's content_columns" do
-      csv_builder.columns[1..-1].each_with_index do |column, index|
-        expect(column.name).to eq resource.content_columns[index].to_s.humanize
-        expect(column.data).to eq resource.content_columns[index]
-      end
-    end
-
-    context 'when column has a localized name' do
-      let(:localized_name) { 'Titulo' }
-
-      before do
-        allow(Post).to receive(:human_attribute_name).and_call_original
-        allow(Post).to receive(:human_attribute_name).with(:title){ localized_name }
-      end
-
-      it 'gets name from I18n' do
-        title_index =  resource.content_columns.index(:title) + 1 # First col is always id
-        expect(csv_builder.columns[title_index].name).to eq localized_name
-      end
-    end
-  end
-
-  context 'when empty' do
-    let(:builder){ ActiveAdmin::CSVBuilder.new.tap(&:exec_columns) }
-
-    it "should have no columns" do
-      expect(builder.columns).to eq []
-    end
-  end
-
-  context "with a symbol column (:title)" do
-    let(:builder) do
-      ActiveAdmin::CSVBuilder.new do
-        column :title
-      end.tap(&:exec_columns)
-    end
-
-    it "should have one column" do
-      expect(builder.columns.size).to eq 1
-    end
-
-    describe "the column" do
-      let(:column){ builder.columns.first }
-
-      it "should have a name of 'Title'" do
-        expect(column.name).to eq "Title"
-      end
-
-      it "should have the data :title" do
-        expect(column.data).to eq :title
-      end
-    end
-  end
-
-  context "with a block and title" do
-    let(:builder) do
-      ActiveAdmin::CSVBuilder.new do
-        column "My title" do
-          # nothing
-        end
-      end.tap(&:exec_columns)
-    end
-
-    it "should have one column" do
-      expect(builder.columns.size).to eq 1
-    end
-
-    describe "the column" do
-      let(:column){ builder.columns.first }
-
-      it "should have a name of 'My title'" do
-        expect(column.name).to eq "My title"
-      end
-
-      it "should have the data :title" do
-        expect(column.data).to be_an_instance_of(Proc)
-      end
-    end
-  end
-
-  context "with a humanize_name column option" do
-    context "with symbol column name" do
-      let(:builder) do
-        ActiveAdmin::CSVBuilder.new do
-          column :my_title, humanize_name: false
-        end.tap(&:exec_columns)
-      end
-
-      describe "the column" do
-        let(:column){ builder.columns.first }
-
-        it "should have a name of 'my_title'" do
-          expect(column.name).to eq "my_title"
-        end
-      end
-    end
-
-    context "with string column name" do
-      let(:builder) do
-        ActiveAdmin::CSVBuilder.new do
-          column "my_title", humanize_name: false
-        end.tap(&:exec_columns)
-      end
-
-      describe "the column" do
-        let(:column){ builder.columns.first }
-
-        it "should have a name of 'my_title'" do
-          expect(column.name).to eq "my_title"
-        end
-      end
-    end
-  end
-
-  context "with a separator" do
-    let(:builder) do
-      ActiveAdmin::CSVBuilder.new(col_sep: ";").tap(&:exec_columns)
-    end
-
-    it "should have proper separator" do
-      expect(builder.options).to eq({col_sep: ";"})
-    end
-  end
-
-  context "with humanize_name option" do
-    let(:builder) do
-      ActiveAdmin::CSVBuilder.new(humanize_name: false) do
-        column :my_title
-      end.tap(&:exec_columns)
-    end
-
-    describe "the column" do
-      let(:column){ builder.columns.first }
-
-      it "should have humanize_name option set" do
-        expect(column.options).to eq humanize_name: false
-      end
-
-      it "should have a name of 'my_title'" do
-        expect(column.name).to eq "my_title"
-      end
-    end
-  end
-
-  context "with csv_options" do
-    let(:builder) do
-      ActiveAdmin::CSVBuilder.new(force_quotes: true).tap(&:exec_columns)
-    end
-
-    it "should have proper separator" do
-      expect(builder.options).to eq({force_quotes: true})
-    end
-  end
-
-  context "with access to the controller" do
-    let(:dummy_view_context) { double(controller: dummy_controller) }
-    let(:dummy_controller) { double(names: %w(title summary updated_at created_at))}
-    let(:builder) do
-      ActiveAdmin::CSVBuilder.new do
-        column "id"
-        controller.names.each do |name|
-          column(name)
-        end
-      end.tap{ |b| b.exec_columns(dummy_view_context) }
-    end
-
-    it "should build columns provided by the controller" do
-      expect(builder.columns.map(&:data)).to match_array([:id, :title, :summary, :updated_at, :created_at])
-    end
-  end
-
-  context "build csv using the supplied order" do
-    before do
-      @post1 = Post.create!(title: "Hello1", published_date: Date.today - 2.day)
-      @post2 = Post.create!(title: "Hello2", published_date: Date.today - 1.day)
-    end
-    let(:dummy_controller) {
-      class DummyController
-        def find_collection(*)
-          collection
-        end
-
-        def collection
-          Post.order('published_date DESC')
-        end
-
-        def apply_decorator(resource)
-          resource
-        end
-
-        def view_context
-        end
-      end
-      DummyController.new
-    }
-    let(:builder) do
-      ActiveAdmin::CSVBuilder.new do
-        column "id"
-        column "title"
-        column "published_date"
-      end
-    end
-
-    it "should generate data with the supplied order" do
-      expect(builder).to receive(:build_row).and_return([]).once.ordered { |post| expect(post.id).to eq @post2.id }
-      expect(builder).to receive(:build_row).and_return([]).once.ordered { |post| expect(post.id).to eq @post1.id }
-      builder.build dummy_controller, []
-    end
-
-    it "should generate data ignoring pagination" do
-      expect(dummy_controller).to receive(:find_collection).
-        with(except: :pagination).once.
-        and_call_original
-      expect(builder).to receive(:build_row).and_return([]).twice
-      builder.build dummy_controller, []
-    end
-
-    it "should disable the ActiveRecord query cache" do
-      expect(builder).to receive(:build_row).twice do
-        expect(ActiveRecord::Base.connection.query_cache_enabled).to be_falsy
-        []
-      end
-      ActiveRecord::Base.cache do
-        builder.build dummy_controller, []
-      end
-    end
-  end
-
-  context "build csv using specified encoding and encoding_options" do
-    let(:dummy_controller) do
-      class DummyController
-        def find_collection(*)
-          collection
-        end
-
-        def collection
-          Post
-        end
-
-        def apply_decorator(resource)
-          resource
-        end
-
-        def view_context
-        end
-      end
-      DummyController.new
-    end
-    let(:encoding) { Encoding::ASCII }
-    let(:opts) { {} }
-    let(:builder) do
-      ActiveAdmin::CSVBuilder.new(encoding: encoding, encoding_options: opts) do
-        column "おはようございます"
-        column "title"
-      end
-    end
-
-    context "Shift-JIS with options" do
-      let(:encoding) { Encoding::Shift_JIS }
-      let(:opts) { { invalid: :replace, undef: :replace, replace: "?" } }
-
-      it "encodes the CSV" do
-        receiver = []
-        builder.build dummy_controller, receiver
-        line = receiver.last
-        expect(line.encoding).to eq(encoding)
-      end
-    end
-
-    context "ASCII with options" do
-      let(:encoding) { Encoding::ASCII }
-      let(:opts) do
-        { invalid: :replace, undef: :replace, replace: "__REPLACED__" }
-      end
-
-      it "encodes the CSV without errors" do
-        receiver = []
-        builder.build dummy_controller, receiver
-        line = receiver.last
-        expect(line.encoding).to eq(encoding)
-        expect(line).to include("__REPLACED__")
-      end
-    end
-  end
-
-  skip '#exec_columns'
-
-  skip '#build_row' do
-    it 'renders non-strings'
-    it 'encodes values correctly'
-    it 'passes custom encoding options to String#encode!'
-  end
-
-end

data/spec/unit/dependency_spec.rb

@@ -1,135 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Dependency do
-
-  k = ActiveAdmin::Dependency
-
-  describe 'method_missing' do
-    before do
-      allow(Gem).to receive(:loaded_specs)
-        .and_return 'foo' => Gem::Specification.new('foo', '1.2.3')
-    end
-
-    it 'returns a Matcher' do
-      expect(k.foo).to be_a ActiveAdmin::Dependency::Matcher
-      expect(k.foo.inspect).to eq '<ActiveAdmin::Dependency::Matcher for foo 1.2.3>'
-      expect(k.bar.inspect).to eq '<ActiveAdmin::Dependency::Matcher for (missing)>'
-    end
-
-    describe '`?`' do
-      it 'base' do
-        expect(k.foo?).to eq true
-        expect(k.bar?).to eq false
-      end
-      it '=' do
-        expect(k.foo? '= 1.2.3').to eq true
-        expect(k.foo? '= 1').to eq false
-      end
-      it '>' do
-        expect(k.foo? '> 1').to eq true
-        expect(k.foo? '> 2').to eq false
-      end
-      it '<' do
-        expect(k.foo? '< 2').to eq true
-        expect(k.foo? '< 1').to eq false
-      end
-      it '>=' do
-        expect(k.foo? '>= 1.2.3').to eq true
-        expect(k.foo? '>= 1.2.2').to eq true
-        expect(k.foo? '>= 1.2.4').to eq false
-      end
-      it '<=' do
-        expect(k.foo? '<= 1.2.3').to eq true
-        expect(k.foo? '<= 1.2.4').to eq true
-        expect(k.foo? '<= 1.2.2').to eq false
-      end
-      it '~>' do
-        expect(k.foo? '~> 1.2.0').to eq true
-        expect(k.foo? '~> 1.1').to eq true
-        expect(k.foo? '~> 1.2.4').to eq false
-      end
-    end
-
-    describe '`!`' do
-      it 'raises an error if requirement not met' do
-        expect{ k.foo! '5'            }.to raise_error ActiveAdmin::DependencyError,
-          'You provided foo 1.2.3 but we need: 5.'
-      end
-      it 'accepts multiple arguments' do
-        expect{ k.foo! '> 1', '< 1.2' }.to raise_error ActiveAdmin::DependencyError,
-          'You provided foo 1.2.3 but we need: > 1, < 1.2.'
-      end
-      it 'raises an error if not provided' do
-        expect{ k.bar!                }.to raise_error ActiveAdmin::DependencyError,
-          'To use bar you need to specify it in your Gemfile.'
-      end
-    end
-  end
-
-  describe '[]' do
-    before do
-      allow(Gem).to receive(:loaded_specs)
-        .and_return 'a-b' => Gem::Specification.new('a-b', '1.2.3')
-    end
-
-    it 'allows access to gems with an arbitrary name' do
-      expect(k['a-b']).to be_a ActiveAdmin::Dependency::Matcher
-      expect(k['a-b'].inspect).to eq '<ActiveAdmin::Dependency::Matcher for a-b 1.2.3>'
-      expect(k['c-d'].inspect).to eq '<ActiveAdmin::Dependency::Matcher for (missing)>'
-    end
-
-    # Note: more extensive tests for match? and match! are above.
-
-    it 'match?' do
-      expect(k['a-b'].match?).to eq true
-      expect(k['a-b'].match? '1.2.3').to eq true
-      expect(k['b-c'].match?).to eq false
-    end
-
-    it 'match!' do
-      expect(k['a-b'].match!).to eq nil
-      expect(k['a-b'].match! '1.2.3').to eq nil
-
-      expect{ k['a-b'].match! '2.5' }.to raise_error ActiveAdmin::DependencyError,
-        'You provided a-b 1.2.3 but we need: 2.5.'
-
-      expect{ k['b-c'].match!       }.to raise_error ActiveAdmin::DependencyError,
-        'To use b-c you need to specify it in your Gemfile.'
-    end
-
-    # Note: Ruby comparison operators are separate from the `foo? '> 1'` syntax
-
-    describe 'Ruby comparison syntax' do
-
-      it '==' do
-        expect(k['a-b'] == '1.2.3').to eq true
-        expect(k['a-b'] == '1.2').to eq false
-        expect(k['a-b'] == 1).to eq false
-      end
-      it '>' do
-        expect(k['a-b'] > 1).to eq true
-        expect(k['a-b'] > 2).to eq false
-      end
-      it '<' do
-        expect(k['a-b'] < 2).to eq true
-        expect(k['a-b'] < 1).to eq false
-      end
-      it '>=' do
-        expect(k['a-b'] >= '1.2.3').to eq true
-        expect(k['a-b'] >= '1.2.2').to eq true
-        expect(k['a-b'] >= '1.2.4').to eq false
-      end
-      it '<=' do
-        expect(k['a-b'] <= '1.2.3').to eq true
-        expect(k['a-b'] <= '1.2.4').to eq true
-        expect(k['a-b'] <= '1.2.2').to eq false
-      end
-
-      it 'throws a custom error if the gem is missing' do
-        expect{ k['b-c'] < 23 }.to raise_error ActiveAdmin::DependencyError,
-          'To use b-c you need to specify it in your Gemfile.'
-      end
-    end
-  end
-
-end

data/spec/unit/devise_spec.rb

@@ -1,110 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Devise::Controller do
-
-  let(:controller_class) do
-    klass = Class.new do
-      def self.layout(*); end
-      def self.helper(*); end
-    end
-    klass.send(:include, ActiveAdmin::Devise::Controller)
-    klass
-  end
-
-  let(:controller) { controller_class.new }
-  let(:action_controller_config) { Rails.configuration.action_controller }
-
-  def with_temp_relative_url_root(relative_url_root)
-    previous_relative_url_root = action_controller_config[:relative_url_root]
-    action_controller_config[:relative_url_root] = relative_url_root
-
-    yield
-  ensure
-    action_controller_config[:relative_url_root] = previous_relative_url_root
-  end
-
-  context 'with a RAILS_RELATIVE_URL_ROOT set' do
-
-    around do |example|
-      with_temp_relative_url_root('/foo') { example.call }
-    end
-
-    it "should set the root path to the default namespace" do
-      expect(controller.root_path).to eq "/foo/admin"
-    end
-
-    it "should set the root path to '/' when no default namespace" do
-      allow(ActiveAdmin.application).to receive(:default_namespace).and_return(false)
-      expect(controller.root_path).to eq "/foo/"
-    end
-
-  end
-
-  context 'without a RAILS_RELATIVE_URL_ROOT set' do
-
-    around do |example|
-      with_temp_relative_url_root(nil) { example.call }
-    end
-
-    it "should set the root path to the default namespace" do
-      expect(controller.root_path).to eq "/admin"
-    end
-
-    it "should set the root path to '/' when no default namespace" do
-      allow(ActiveAdmin.application).to receive(:default_namespace).and_return(false)
-      expect(controller.root_path).to eq "/"
-    end
-
-  end
-
-  context "within a scoped route" do
-
-    SCOPE = '/aa_scoped'
-
-    before do
-      # Remove existing routes
-      routes = Rails.application.routes
-      routes.clear!
-
-      # Add scoped routes
-      routes.draw do
-        scope path: SCOPE do
-          ActiveAdmin.routes(self)
-          devise_for :admin_users, ActiveAdmin::Devise.config
-        end
-      end
-    end
-
-    after do
-      # Resume default routes
-      reload_routes!
-    end
-
-    it "should include scope path in root_path" do
-      expect(controller.root_path).to eq "#{SCOPE}/admin"
-    end
-
-  end
-
-  describe "#config" do
-    let(:config) { ActiveAdmin::Devise.config }
-
-    describe ":sign_out_via option" do
-      it "should contain the application.logout_link_method" do
-        expect(::Devise).to receive(:sign_out_via).and_return(:delete)
-        expect(ActiveAdmin.application).to receive(:logout_link_method).and_return(:get)
-
-        expect(config[:sign_out_via]).to include(:get)
-      end
-
-      it "should contain Devise's logout_via_method(s)" do
-        expect(::Devise).to receive(:sign_out_via).and_return([:delete, :post])
-        expect(ActiveAdmin.application).to receive(:logout_link_method).and_return(:get)
-
-        expect(config[:sign_out_via]).to eq [:delete, :post, :get]
-      end
-
-    end # describe ":sign_out_via option"
-  end # describe "#config"
-
-end

data/spec/unit/dsl_spec.rb

@@ -1,120 +0,0 @@
-require 'rails_helper'
-
-module MockModuleToInclude
-  def self.included(dsl)
-  end
-end
-
-RSpec.describe ActiveAdmin::DSL do
-
-  let(:application) { ActiveAdmin::Application.new }
-  let(:namespace) { ActiveAdmin::Namespace.new application, :admin }
-  let(:resource_config) { namespace.register Post }
-  let(:dsl){ ActiveAdmin::DSL.new(resource_config) }
-
-  describe "#include" do
-
-    it "should call the included class method on the module that is included" do
-      expect(MockModuleToInclude).to receive(:included).with(dsl)
-      dsl.run_registration_block do
-        include MockModuleToInclude
-      end
-    end
-
-  end
-
-  describe '#action_item' do
-    before do
-      @default_items_count = resource_config.action_items.size
-
-      dsl.run_registration_block do
-        action_item :awesome, only: :show do
-          "Awesome ActionItem"
-        end
-      end
-    end
-
-    it "adds action_item to the action_items of config" do
-      expect(resource_config.action_items.size).to eq(@default_items_count + 1)
-    end
-
-    context 'DEPRECATED: when used without a name' do
-      it "is configured for only the show action" do
-        expect(ActiveAdmin::Deprecation).to receive(:warn).with(instance_of(String))
-
-        dsl.run_registration_block do
-          action_item only: :edit do
-            "Awesome ActionItem"
-          end
-        end
-
-        item = resource_config.action_items.last
-        expect(item.display_on?(:edit)).to be true
-        expect(item.display_on?(:index)).to be false
-      end
-    end
-  end
-
-  describe "#menu" do
-
-    it "should set the menu_item_options on the configuration" do
-      expect(resource_config).to receive(:menu_item_options=).with({parent: "Admin"})
-      dsl.run_registration_block do
-        menu parent: "Admin"
-      end
-    end
-
-  end
-
-  describe "#navigation_menu" do
-
-    it "should set the navigation_menu_name on the configuration" do
-      expect(resource_config).to receive(:navigation_menu_name=).with(:admin)
-      dsl.run_registration_block do
-        navigation_menu :admin
-      end
-    end
-
-    it "should accept a block" do
-      dsl = ActiveAdmin::DSL.new(resource_config)
-      dsl.run_registration_block do
-        navigation_menu { :dynamic_menu }
-      end
-      expect(resource_config.navigation_menu_name).to eq :dynamic_menu
-    end
-
-  end
-
-  describe "#sidebar" do
-
-    before do
-      dsl.config.sidebar_sections << ActiveAdmin::SidebarSection.new(:email)
-    end
-
-    it "add sidebar_section to the sidebar_sections of config" do
-      dsl.run_registration_block do
-        sidebar :help
-      end
-      expect(dsl.config.sidebar_sections.map(&:name)).to match_array ['filters', 'Search status:', 'email', 'help']
-    end
-
-  end
-
-  describe "#batch_action" do
-    it "should add a batch action by symbol" do
-      dsl.run_registration_block do
-        config.batch_actions = true
-        batch_action :foo
-      end
-      expect(resource_config.batch_actions.map(&:sym)).to eq [:foo, :destroy]
-    end
-
-    it "should add a batch action by title" do
-      dsl.run_registration_block do
-        config.batch_actions = true
-        batch_action "foo bar"
-      end
-      expect(resource_config.batch_actions.map(&:sym)).to eq [:foo_bar, :destroy]
-    end
-  end
-end