activeadmin-rb 1.4.0

data/spec/unit/dependency_spec.rb

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

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

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

data/spec/unit/dynamic_settings_spec.rb

@@ -0,0 +1,28 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::DynamicSettingsNode do
+  subject { ActiveAdmin::DynamicSettingsNode.build }
+
+  context "StringSymbolOrProcSetting" do
+    before { subject.register :foo, 'bar', :string_symbol_or_proc }
+
+    it "should pass through a string" do
+      subject.foo = "string"
+      expect(subject.foo(self)).to eq "string"
+    end
+
+    it "should instance_exec if context given" do
+      ctx = Hash[i: 42]
+      subject.foo = proc { self[:i] += 1 }
+      expect(subject.foo(ctx)).to eq 43
+      expect(subject.foo(ctx)).to eq 44
+    end
+
+    it "should send message if symbol given" do
+      ctx = double
+      expect(ctx).to receive(:quux).and_return 'qqq'
+      subject.foo = :quux
+      expect(subject.foo(ctx)).to eq 'qqq'
+    end
+  end
+end

data/spec/unit/filters/active_filter_spec.rb

@@ -0,0 +1,218 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::Filters::ActiveFilter do
+
+  let(:namespace) do
+    ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
+  end
+
+  let(:resource) do
+    namespace.register(Post)
+  end
+
+  let(:user){ User.create! first_name: "John", last_name: "Doe" }
+  let(:category){ Category.create! name: "Category" }
+  let(:post){ Post.create! title: "Hello World", category: category, author: user }
+
+  let(:search) do
+    Post.ransack(title_equals: post.title)
+  end
+
+  let(:condition) do
+    search.conditions[0]
+  end
+
+  subject do
+    ActiveAdmin::Filters::ActiveFilter.new(resource, condition)
+  end
+
+  it 'should have valid values' do
+    expect(subject.values).to eq([post.title])
+  end
+
+  it 'should have valid label' do
+    expect(subject.label).to eq("Title equals")
+  end
+
+  it 'should pick predicate name translation' do
+    expect(subject.predicate_name).to eq(I18n.t("active_admin.filters.predicates.equals"))
+  end
+
+  context 'search by belongs_to association' do
+    let(:search) do
+      Post.ransack(custom_category_id_eq: category.id)
+    end
+
+    it 'should have valid values' do
+      expect(subject.values[0]).to be_a(Category)
+    end
+
+    it 'should have valid label' do
+      expect(subject.label).to eq("Category equals")
+    end
+
+    it 'should pick predicate name translation' do
+      expect(subject.predicate_name).to eq(Ransack::Translate.predicate('eq'))
+    end
+
+  end
+
+  context 'search by polymorphic association' do
+    let(:resource) do
+      namespace.register(ActiveAdmin::Comment)
+    end
+
+    let(:search) do
+      ActiveAdmin::Comment.ransack(resource_id_eq: post.id, resource_type_eq: post.class.to_s)
+    end
+
+    context 'id filter' do
+      let(:condition) do
+        search.conditions[0]
+      end
+      it 'should have valid values' do
+        expect(subject.values[0]).to eq(post.id)
+      end
+
+      it 'should have valid label' do
+        expect(subject.label).to eq("Resource equals")
+      end
+    end
+
+    context 'type filter' do
+      let(:condition) do
+        search.conditions[1]
+      end
+
+      it 'should have valid values' do
+        expect(subject.values[0]).to eq(post.class.to_s)
+      end
+
+      it 'should have valid label' do
+        expect(subject.label).to eq("Resource type equals")
+      end
+    end
+  end
+
+  context 'search by has many association' do
+    let(:resource) do
+      namespace.register(Category)
+    end
+
+    let(:search) do
+      Category.ransack(posts_id_eq: post.id)
+    end
+
+    it 'should have valid values' do
+      expect(subject.values[0]).to be_a(Post)
+    end
+
+    it 'should have valid label' do
+      expect(subject.label).to eq("Post equals")
+    end
+
+    context 'search by has many through association' do
+      let(:resource) do
+        namespace.register(User)
+      end
+
+      let(:search) do
+        User.ransack(posts_category_id_eq: category.id)
+      end
+
+      it 'should have valid values' do
+        expect(subject.values[0]).to be_a(Category)
+      end
+
+      it 'should have valid label' do
+        expect(subject.label).to eq("Category equals")
+      end
+
+    end
+
+  end
+
+  context 'search has no matching records' do
+    let(:search) { Post.ransack(author_id_eq: "foo") }
+
+    it 'should not produce and error' do
+      expect { subject.values }.not_to raise_error
+    end
+
+    it 'should return an enumerable' do
+      expect(subject.values).to respond_to(:map)
+    end
+  end
+
+  context 'a label is set on the filter' do
+    it 'should use the filter label as the label prefix' do
+      label = "#{user.first_name}'s Post Title"
+      resource.add_filter(:title, label: label)
+
+      expect(subject.label).to eq ("#{label} equals")
+    end
+  end
+
+  context "the association uses a different primary_key than the related class' primary_key" do
+    let (:resource_klass) {
+      Class.new(Post) do
+        belongs_to :kategory, class_name: "Category", primary_key: :name, foreign_key: :title
+
+        def self.name
+          "SuperPost"
+        end
+      end
+    }
+
+    let(:resource) do
+      namespace.register(resource_klass)
+    end
+
+    let(:user){ User.create! first_name: "John", last_name: "Doe" }
+    let!(:category){ Category.create! name: "Category" }
+
+    let(:post){ resource_klass.create! title: "Category", author: user }
+
+    let(:search) do
+      resource_klass.ransack(title_equals: post.title)
+    end
+
+    it "should use the association's primary key to find the associated record" do
+      allow(ActiveSupport::Dependencies).to receive(:constantize).with("::SuperPost").and_return(resource_klass)
+
+      resource.add_filter(:kategory)
+
+      expect(subject.values.first).to eq category
+    end
+  end
+
+  context 'when the resource has a custom primary key' do
+    let(:resource_klass) do
+      Class.new(Store) do
+        self.primary_key = 'name'
+        belongs_to :user
+
+        def self.name
+          'SubStore'
+        end
+      end
+    end
+
+    let(:resource) do
+      namespace.register(resource_klass)
+    end
+
+    let(:user) { User.create! first_name: 'John', last_name: 'Doe' }
+    let(:store) { resource_klass.create! name: 'Store 1', user_id: user.id }
+
+    let(:search) do
+      resource_klass.ransack(user_id_eq: user.id)
+    end
+
+    it "should use the association's primary key to find the associated record" do
+      allow(ActiveSupport::Dependencies).to receive(:constantize).with("::#{resource_klass.name}").and_return(resource_klass)
+
+      expect(subject.values.first).to eq user
+    end
+  end
+end