activeadmin-rails 1.7.0

data/spec/unit/views/components/index_list_spec.rb

@@ -0,0 +1,49 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::Views::IndexList do
+
+  describe "#index_list_renderer" do
+
+    let(:index_classes) { [ActiveAdmin::Views::IndexAsTable, ActiveAdmin::Views::IndexAsBlock] }
+
+    let(:collection) {
+      Post.create(title: 'First Post', starred: true)
+      Post.where(nil)
+    }
+
+    let(:helpers) do
+      helpers = mock_action_view
+      allow(helpers).to receive(:url_for) { |url| "/?#{ url.to_query }" }
+      allow(helpers.request).to receive(:query_parameters).and_return as: "table", q: { title_contains: "terms" }
+      allow(helpers).to receive(:params).and_return(ActionController::Parameters.new(as: "table", q: { title_contains: "terms" }))
+      allow(helpers).to receive(:collection).and_return(collection)
+      helpers
+    end
+
+    subject do
+      render_component({index_classes: index_classes}, helpers) do
+        index_list_renderer(index_classes)
+      end
+    end
+
+    describe '#tag_name' do
+      subject { super().tag_name }
+      it { is_expected.to eq 'ul'}
+    end
+
+    it "should contain the names of available indexes in links" do
+      a_tags = subject.find_by_tag("a")
+      expect(a_tags.size).to eq 2
+      expect(a_tags.first.to_s).to include("Table")
+      expect(a_tags.last.to_s).to include("List")
+    end
+
+    it "should maintain index filter parameters" do
+      a_tags = subject.find_by_tag("a")
+      expect(a_tags.first.attributes[:href])
+        .to eq("/?#{ { as: "table", q: { title_contains: "terms" } }.to_query }")
+      expect(a_tags.last.attributes[:href])
+        .to eq("/?#{ { as: "block", q: { title_contains: "terms" } }.to_query }")
+    end
+  end
+end

data/spec/unit/views/components/index_table_for_spec.rb

@@ -0,0 +1,127 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::Views::IndexAsTable::IndexTableFor do
+  describe 'creating with the dsl' do
+    let(:collection) do
+      [Post.new(title: 'First Post', starred: true)]
+    end
+    let(:active_admin_config) do
+      namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
+      namespace.batch_actions = [ActiveAdmin::BatchAction.new(:flag, 'Flag') {}]
+      namespace
+    end
+
+    let(:assigns) do
+      {
+        collection: collection,
+        active_admin_config: active_admin_config
+      }
+    end
+    let(:helpers) { mock_action_view }
+
+    context 'when creating a selectable column' do
+      let(:table) do
+        render_component assigns, helpers do
+          insert_tag(ActiveAdmin::Views::IndexAsTable::IndexTableFor, collection, {sortable: true}) do
+            selectable_column
+          end
+        end
+      end
+
+      context 'creates a table header based on the selectable column' do
+        let(:header) do
+          table.find_by_tag('th').first
+        end
+
+        it 'with selectable column class name' do
+          expect(header.attributes[:class]).to include 'col-selectable'
+        end
+
+        it 'not sortable' do
+          expect(header.attributes[:class]).not_to include 'sortable'
+        end
+      end
+    end
+
+    context 'when creating an index column' do
+      let(:base_collection) do
+        posts = [
+          Post.new(title: 'First Post', starred: true),
+          Post.new(title: 'Second Post', starred: true),
+          Post.new(title: 'Third Post', starred: true),
+          Post.new(title: 'Fourth Post', starred: true)
+        ]
+        Kaminari.paginate_array(posts, limit: 2)
+      end
+      let(:collection) do
+        base_collection.page(1)
+      end
+
+      let(:table) do
+        render_component assigns, helpers do
+          insert_tag(ActiveAdmin::Views::IndexAsTable::IndexTableFor, collection, {sortable: true}) do
+            index_column
+          end
+        end
+      end
+
+      context 'creates a table header based on the index column' do
+        let(:header) do
+          table.find_by_tag('th').first
+        end
+
+        it 'with index column class name' do
+          expect(header.attributes[:class]).to include 'col-index'
+        end
+
+        it 'not sortable' do
+          expect(header.attributes[:class]).not_to include 'sortable'
+        end
+      end
+
+      context 'verifying the indices for the rows' do
+        let(:index_values) do
+          table.find_by_tag('tr').map do |row|
+            next unless row.find_by_tag('td').first
+            row.find_by_tag('td').first.content
+          end.compact
+        end
+
+        context 'viewing the first page' do
+          it 'shows the correct indices' do
+            expect(index_values).to eq(['1', '2'])
+          end
+        end
+        context 'viewing the second page' do
+          let(:collection) do
+            base_collection.page(2)
+          end
+          it 'shows the correct indices' do
+            expect(index_values).to eq(['3', '4'])
+          end
+        end
+      end
+
+      context 'allows for zero-based indices' do
+        let(:table) do
+          render_component assigns, helpers do
+            insert_tag(ActiveAdmin::Views::IndexAsTable::IndexTableFor, collection, {sortable: true}) do
+              index_column(0)
+            end
+          end
+        end
+
+        let(:index_values) do
+          table.find_by_tag('tr').map do |row|
+            next unless row.find_by_tag('td').first
+            row.find_by_tag('td').first.content
+          end.compact
+        end
+
+        it 'shows the correct indices' do
+          expect(index_values).to eq(['0', '1'])
+        end
+      end
+    end
+  end
+end

data/spec/unit/views/components/menu_item_spec.rb

@@ -0,0 +1,29 @@
+require 'rails_helper'
+require 'active_admin/menu_item'
+require 'active_admin/views/components/menu_item'
+
+RSpec.describe ActiveAdmin::Views::MenuItem do
+  let(:item) do
+    i = ActiveAdmin::MenuItem.new(label: "Dashboard")
+    i.add label: "Blog", url: 'blogs'
+    i.add label: "Cars", url: 'cars'
+    i.add label: "Restricted", url: 'secret', if: proc{false}
+    i.add label: "Users", priority: 1, url: 'admin_users'
+    i.add label: "Settings", priority: 2, url: 'setup'
+    i.add label: "Analytics", priority: 44, url: 'reports'
+    i
+  end
+
+  let(:arbe_menu_item) do
+    render_component(item: item) do
+      menu_item(item)
+    end
+  end
+
+  let(:html) { Capybara.string(arbe_menu_item.to_s) }
+
+  it "sorts the child items" do
+    ids = html.all('li').map { |i| i[:id] }
+    expect(ids).to eq %w(dashboard users settings blog cars analytics)
+  end
+end

data/spec/unit/views/components/menu_spec.rb

@@ -0,0 +1,168 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::Views::Menu do
+
+  let(:menu){ ActiveAdmin::Menu.new }
+
+  let(:assigns){ { active_admin_menu: menu } }
+  let(:helpers){ mock_action_view }
+
+  let(:menu_component) do
+    arbo(assigns, helpers) {
+      insert_tag(ActiveAdmin::Views::Menu, active_admin_menu)
+    }.children.first
+  end
+
+  let(:html) { Capybara.string(menu_component.to_s) }
+
+  before do
+    load_resources { ActiveAdmin.register Post }
+    allow(helpers).to receive(:admin_logged_in?).and_return(false)
+  end
+
+  describe "rendering a menu" do
+
+    before do
+      menu.add label: "Blog Posts", url: :admin_posts_path
+
+      menu.add label: "Reports", url: "/admin/reports" do |reports|
+        reports.add label: "A Sub Reports", url: "/admin/a-sub-reports"
+        reports.add label: "B Sub Reports", url: "/admin/b-sub-reports"
+        reports.add label: proc{ "Label Proc Sub Reports" }, url: "/admin/label-proc-sub-reports", id: "Label Proc Sub Reports"
+      end
+
+      menu.add label: "Administration", url: "/admin/administration" do |administration|
+        administration.add label: "User administration",
+                           url: '/admin/user-administration',
+                           priority: 10,
+                           if: proc { false }
+      end
+
+      menu.add label: "Management", url: "#" do |management|
+        management.add label: "Order management",
+                       url: '/admin/order-management',
+                       priority: 10,
+                       if: proc { false }
+        management.add label: "Bill management",
+                       url: '/admin/bill-management',
+                       priority: 10,
+                       if: :admin_logged_in?
+      end
+
+      menu.add label: "Charles Smith", id: "current_user", url: -> { nil }
+    end
+
+    it "should generate a ul" do
+      expect(html).to have_selector("ul")
+    end
+
+    it "should generate an li for each item" do
+      expect(html).to have_selector("ul > li")
+    end
+
+    it "should generate a link for each item" do
+      expect(html).to have_selector("a[href='/admin/posts']", text: "Blog Posts")
+    end
+
+    it "should generate a nested list for children" do
+      expect(html).to have_selector("li > ul")
+    end
+
+    it "should generate a nested list with li for each child" do
+      expect(html).to have_selector("ul > li#a_sub_reports")
+      expect(html).to have_selector("ul > li#b_sub_reports")
+    end
+
+    it "should generate a valid id from a label proc" do
+      expect(html).to have_selector("ul > li#label_proc_sub_reports")
+    end
+
+    it "should not generate a link for user administration" do
+      expect(html).to_not have_selector("a[href='/admin/user-administration']", text: "User administration")
+    end
+
+    it "should generate the administration parent menu" do
+      expect(html).to have_selector("a[href='/admin/administration']", text: "Administration")
+    end
+
+    it "should not generate a link for order management" do
+      expect(html).to_not have_selector("a[href='/admin/order-management']", text: "Order management")
+    end
+
+    it "should not generate a link for bill management" do
+      expect(html).to_not have_selector("a[href='/admin/bill-management']", text: "Bill management")
+    end
+
+    it "should not generate the management parent menu" do
+      expect(html).to_not have_selector("a[href='#']", text: "Management")
+    end
+
+    context "when url is nil" do
+      it "should generate a span" do
+        selector = "li#current_user > span"
+        expect(html).to have_selector(selector, text: "Charles Smith")
+      end
+    end
+
+    describe "marking current item" do
+
+      it "should add the 'current' class to the li" do
+        assigns[:current_tab] = menu["Blog Posts"]
+        expect(html).to have_selector("li.current")
+      end
+
+      it "should add the 'current' and 'has_nested' classes to the li and 'current' to the sub li" do
+        assigns[:current_tab] = menu["Reports"]["A Sub Reports"]
+        expect(html).to have_selector("li#reports.current")
+        expect(html).to have_selector("li#reports.has_nested")
+        expect(html).to have_selector("li#a_sub_reports.current")
+      end
+
+    end
+
+  end
+
+  describe "returning the menu items to display" do
+
+    it "should return one item with no if block" do
+      menu.add label: "Hello World", url: "/"
+      expect(menu_component.children.map(&:id)).to eq %w(hello_world)
+    end
+
+    it "should not include menu items with an if block that returns false" do
+      menu.add label: "Don't Show", url: "/", priority: 10, if: proc{ false }
+      expect(menu_component.children).to be_empty
+    end
+
+    it "should not include menu items with an if block that calls a method that returns false" do
+      menu.add label: "Don't Show", url: "/", priority: 10, if: :admin_logged_in?
+      expect(menu_component.children).to be_empty
+    end
+
+    it "should not display any items that have no children to display" do
+      menu.add label: "Parent", url: "#" do |p|
+        p.add label: "Child", url: "/", priority: 10, if: proc{ false }
+      end
+      expect(html.all('li')).to be_empty
+    end
+
+    it "should display a parent that has a child to display" do
+      menu.add label: "Parent", url: "#" do |p|
+        p.add label: "Hidden Child", url: "/", priority: 10, if: proc{ false }
+        p.add label: "Child", url: "/"
+      end
+      expect(menu_component.children.size).to eq(1)
+    end
+
+  end
+
+  describe "sorting items" do
+    it "should sort children by the result of their label proc" do
+      menu.add label: proc{ "G" }, id: "not related 1"
+      menu.add label: proc{ "B" }, id: "not related 2"
+      menu.add label: proc{ "A" }, id: "not related 3"
+
+      expect(menu_component.children.map(&:label)).to eq %w[A B G]
+    end
+  end
+end

data/spec/unit/views/components/paginated_collection_spec.rb

@@ -0,0 +1,249 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::Views::PaginatedCollection do
+  describe "creating with the dsl" do
+
+    before :all do
+      load_defaults!
+      reload_routes!
+    end
+
+    let(:view) do
+      view = mock_action_view
+      allow(view.request).to receive(:query_parameters).and_return page: '1'
+      allow(view.request).to receive(:path_parameters).and_return  controller: 'admin/posts', action: 'index'
+      view
+    end
+
+    # Helper to render paginated collections within an arbo context
+    def paginated_collection(*args)
+      render_component({paginated_collection_args: args}, view) do
+        paginated_collection(*paginated_collection_args)
+      end
+    end
+
+    let(:collection) do
+      posts = [Post.new(title: "First Post"), Post.new(title: "Second Post"), Post.new(title: "Third Post")]
+      Kaminari.paginate_array(posts).page(1).per(5)
+    end
+
+    before do
+      allow(collection).to receive(:except) { collection } unless collection.respond_to? :except
+      allow(collection).to receive(:group_values) { [] }   unless collection.respond_to? :group_values
+    end
+
+    let(:pagination){ paginated_collection collection }
+
+    it "should set :collection as the passed in collection" do
+      expect(pagination.find_by_class('pagination_information').first.content).to eq "Displaying <b>all 3</b> posts"
+    end
+
+    it "should raise error if collection has no pagination scope" do
+      expect {
+        paginated_collection([Post.new, Post.new])
+      }.to raise_error(StandardError, "Collection is not a paginated scope. Set collection.page(params[:page]).per(10) before calling :paginated_collection.")
+    end
+
+    it 'should preserve custom query params' do
+      allow(view.request).to receive(:query_parameters).and_return page: '1', something: 'else'
+      pagination_content = pagination.content
+      expect(pagination_content).to include '/admin/posts.csv?page=1&amp;something=else'
+      expect(pagination_content).to include '/admin/posts.xml?page=1&amp;something=else'
+      expect(pagination_content).to include '/admin/posts.json?page=1&amp;something=else'
+    end
+
+    context "when specifying :param_name option" do
+      let(:collection) do
+        posts = 10.times.map{ Post.new }
+        Kaminari.paginate_array(posts).page(1).per(5)
+      end
+
+      let(:pagination) { paginated_collection(collection, param_name: :post_page) }
+
+      it "should customize the page number parameter in pagination links" do
+        expect(pagination.children.last.content).to match(/\/admin\/posts\?post_page=2/)
+      end
+    end
+
+    context "when specifying :params option" do
+      let(:collection) do
+        posts = 10.times.map{ Post.new }
+        Kaminari.paginate_array(posts).page(1).per(5)
+      end
+
+      let(:pagination) { paginated_collection(collection, param_name: :post_page, params: { anchor: 'here' }) }
+
+      it "should pass it through to Kaminari" do
+        expect(pagination.children.last.content).to match(/\/admin\/posts\?post_page=2#here/)
+      end
+    end
+
+    context "when specifying download_links: false option" do
+      let(:collection) do
+        posts = 10.times.map{ Post.new }
+        Kaminari.paginate_array(posts).page(1).per(5)
+      end
+
+      let(:pagination) { paginated_collection(collection, download_links: false) }
+
+      it "should not render download links" do
+        expect(pagination.find_by_tag('div').last.content).to_not match(/Download:/)
+      end
+    end
+
+    context "when specifying :entry_name option with a single item" do
+      let(:collection) do
+        posts = [Post.new]
+        Kaminari.paginate_array(posts).page(1).per(5)
+      end
+
+      let(:pagination) { paginated_collection(collection, entry_name: "message") }
+
+      it "should use :entry_name as the collection name" do
+        expect(pagination.find_by_class('pagination_information').first.content).to eq "Displaying <b>1</b> message"
+      end
+    end
+
+    context "when specifying :entry_name option with multiple items" do
+      let(:pagination) { paginated_collection(collection, entry_name: "message") }
+
+      it "should use :entry_name as the collection name" do
+        expect(pagination.find_by_class('pagination_information').first.content).to eq "Displaying <b>all 3</b> messages"
+      end
+    end
+
+    context "when specifying :entry_name and :entries_name option with a single item" do
+      let(:collection) do
+        posts = [Post.new]
+        Kaminari.paginate_array(posts).page(1).per(5)
+      end
+
+      let(:pagination) { paginated_collection(collection, entry_name: "singular", entries_name: "plural") }
+
+      it "should use :entry_name as the collection name" do
+        expect(pagination.find_by_class('pagination_information').first.content).to eq "Displaying <b>1</b> singular"
+      end
+    end
+
+    context "when specifying :entry_name and :entries_name option with a multiple items" do
+      let(:pagination) { paginated_collection(collection, entry_name: "singular", entries_name: "plural") }
+
+      it "should use :entries_name as the collection name" do
+        expect(pagination.find_by_class('pagination_information').first.content).to eq "Displaying <b>all 3</b> plural"
+      end
+    end
+
+    context "when omitting :entry_name with a single item" do
+      let(:collection) do
+        posts = [Post.new]
+        Kaminari.paginate_array(posts).page(1).per(5)
+      end
+
+      it "should use 'post' as the collection name when there is no I18n translation" do
+        expect(pagination.find_by_class('pagination_information').first.content).to eq "Displaying <b>1</b> post"
+      end
+
+      it "should use 'Singular' as the collection name when there is an I18n translation" do
+        allow(I18n).to receive(:translate) { "Singular" }
+        expect(pagination.find_by_class('pagination_information').first.content).to eq "Displaying <b>1</b> Singular"
+      end
+    end
+
+    context "when omitting :entry_name with multiple items" do
+      it "should use 'posts' as the collection name when there is no I18n translation" do
+        expect(pagination.find_by_class('pagination_information').first.content).to eq "Displaying <b>all 3</b> posts"
+      end
+
+      it "should use 'Plural' as the collection name when there is an I18n translation" do
+        allow(I18n).to receive(:translate) { "Plural" }
+        expect(pagination.find_by_class('pagination_information').first.content).to eq "Displaying <b>all 3</b> Plural"
+      end
+    end
+
+    context "when specifying an empty collection" do
+      let(:collection) do
+        posts = []
+        Kaminari.paginate_array(posts).page(1).per(5)
+      end
+
+      it "should display 'No entries found'" do
+        expect(pagination.find_by_class('pagination_information').first.content).to eq "No entries found"
+      end
+    end
+
+    context "when collection comes from find with GROUP BY" do
+      let(:collection) do
+        %w{Foo Foo Bar}.each {|title| Post.create(title: title) }
+        Post.select(:title).group(:title).page(1).per(5)
+      end
+
+      it "should display proper message (including number and not hash)" do
+        expect(pagination.find_by_class('pagination_information').first.content).to eq "Displaying <b>all 2</b> posts"
+      end
+    end
+
+    context "when collection with many pages comes from find with GROUP BY" do
+      let(:collection) do
+        %w{Foo Foo Bar Baz}.each {|title| Post.create(title: title) }
+        Post.select(:title).group(:title).page(1).per(2)
+      end
+
+      it "should display proper message (including number and not hash)" do
+        expect(pagination.find_by_class('pagination_information').first.content.gsub('&nbsp;', ' ')).
+          to eq "Displaying posts <b>1 - 2</b> of <b>3</b> in total"
+      end
+    end
+
+    context "when viewing the last page of a collection that has multiple pages" do
+      let(:collection) do
+        Kaminari.paginate_array([Post.new] * 81).page(3).per(30)
+      end
+
+      it "should show the proper item counts" do
+        expect(pagination.find_by_class('pagination_information').first.content.gsub('&nbsp;', ' ')).
+          to eq "Displaying posts <b>61 - 81</b> of <b>81</b> in total"
+      end
+    end
+
+    context "with :pagination_total" do
+      let(:collection) do
+        Kaminari.paginate_array([Post.new] * 256).page(1).per(30)
+      end
+
+      describe "set to false" do
+        it "should not show the total item counts" do
+          expect(collection).not_to receive(:total_pages)
+          pagination = paginated_collection(collection, pagination_total: false)
+          info = pagination.find_by_class('pagination_information').first.content.gsub('&nbsp;', ' ')
+          expect(info).to eq "Displaying posts <b>1 - 30</b>"
+        end
+      end
+
+      describe "set to true" do
+        let(:pagination) { paginated_collection(collection, pagination_total: true) }
+
+        it "should show the total item counts" do
+          info = pagination.find_by_class('pagination_information').first.content.gsub('&nbsp;', ' ')
+          expect(info).to eq "Displaying posts <b>1 - 30</b> of <b>256</b> in total"
+        end
+      end
+    end
+
+    context "when specifying per_page: array option" do
+      let(:collection) do
+        posts = 10.times.map { Post.new }
+        Kaminari.paginate_array(posts).page(1).per(5)
+      end
+
+      let(:pagination) { paginated_collection(collection, per_page: [1, 2, 3]) }
+      let(:pagination_html) { pagination.find_by_class("pagination_per_page").first }
+      let(:pagination_node) { Capybara.string(pagination_html.to_s) }
+
+      it "should render per_page select tag" do
+        expect(pagination_html.content).to match(/Per page:/)
+        expect(pagination_node).to have_css("select option", count: 3)
+      end
+    end
+
+  end
+end

data/spec/unit/views/components/panel_spec.rb

@@ -0,0 +1,58 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::Views::Panel do
+  let(:arbo_panel) do
+    render_component do
+      panel "My Title" do
+        header_action link_to("My Link", "https://www.github.com/activeadmin/activeadmin")
+        span("Hello World")
+      end
+    end
+  end
+
+  let(:panel_html) { Capybara.string(arbo_panel.to_s) }
+
+  it "should have a title h3" do
+    expect(panel_html).to have_css 'h3', text: "My Title"
+  end
+
+  it "should add panel actions to the panel header" do
+    link = panel_html.find('h3 > div.header_action a')
+    expect(link.text).to eq('My Link')
+    expect(link[:href]).to eq("https://www.github.com/activeadmin/activeadmin")
+  end
+
+  it "should have a contents div" do
+    expect(panel_html).to have_css 'div.panel_contents'
+  end
+
+  it "should add children to the contents div" do
+    expect(panel_html).to have_css 'div.panel_contents > span', text: "Hello World"
+  end
+
+  context "with html-safe title" do
+    let(:arbo_panel) do
+      title_with_html = %q[Title with <abbr>HTML</abbr>].html_safe
+      render_component do
+        panel(title_with_html)
+      end
+    end
+
+    it "should allow a html_safe title" do
+      expect(panel_html).to have_css "h3", text: "Title with HTML"
+      expect(panel_html).to have_css "h3 > abbr", text: "HTML"
+    end
+  end
+
+  describe "#children?" do
+    let(:arbo_panel) do
+      render_component do
+        panel("A Panel")
+      end
+    end
+
+    it "returns false if no children have been added to the panel" do
+      expect(arbo_panel.children?).to eq false
+    end
+  end
+end