activeadmin 1.3.1 → 1.4.0

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

@@ -1,67 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Views::Tabs do
-  describe "creating with the dsl" do
-    context "when creating tabs with a symbol" do
-      before do
-        expect(I18n).to receive(:t).at_least(:once).with(:tab_key).and_return "テスト"
-      end
-
-      let(:tabs) do
-        render_arbre_component do
-          tabs do
-            tab :overview
-            tab I18n.t(:tab_key), { id: :something_unique }
-          end
-        end
-      end
-
-      let(:subject) { Capybara.string(tabs.to_s) }
-
-      it "should create a tab navigation bar based on the symbol" do
-        expect(subject).to have_content('Overview')
-      end
-
-      it "should have tab with id based on symbol" do
-        expect(subject).to have_selector('div#overview')
-      end
-
-      it "should have link with fragment based on symbol" do
-        expect(subject).to have_selector('a[href="#overview"]')
-      end
-
-      it "should handle translation" do
-        expect(subject).to have_content('テスト')
-      end
-
-      it "should have tab with id based on options" do
-        expect(subject).to have_selector('div#something_unique')
-      end
-
-      it "should have link with fragment based on options" do
-        expect(subject).to have_selector('a[href="#something_unique"]')
-      end
-
-    end
-
-    context "when creating a tab with a block" do
-      let(:tabs) do
-        render_arbre_component do
-          tabs do
-            tab :overview do
-              span 'tab 1'
-            end
-          end
-        end
-      end
-
-      it "should create a tab navigation bar based on the symbol" do
-        expect(tabs.find_by_tag('li').first.content).to include "Overview"
-      end
-
-      it "should create a tab with a span inside of it" do
-        expect(tabs.find_by_tag('span').first.content).to eq('tab 1')
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Views::UnsupportedBrowser do
-  let(:helpers){ mock_action_view }
-  let(:namespace) { double :namespace, unsupported_browser_matcher: /MSIE [1-8]\.0/ }
-  let(:component) { double :unsupported_browser_component }
-  let(:view_factory) { double :view_factory, unsupported_browser: component }
-  let(:base) { ActiveAdmin::Views::Pages::Base.new }
-
-  def build_panel
-    render_arbre_component({}, helpers) do
-      insert_tag ActiveAdmin::Views::UnsupportedBrowser
-    end
-  end
-
-  it "should render the panel" do
-    expect(I18n).to receive(:t).and_return("headline", "recommendation" , "turn_off_compatibility_view")
-    expect(build_panel.content.gsub(/\s+/, "")).to eq "<h1>headline</h1><p>recommendation</p><p>turn_off_compatibility_view</p>"
-  end
-
-  describe "ActiveAdmin::Views::Pages::Base behavior" do
-    context "when the reqex match" do
-      it "should build the unsupported browser panel" do
-        expect(base).to receive(:active_admin_namespace).and_return(namespace)
-        expect(base).to receive_message_chain(:controller, :request, :user_agent).and_return("Mozilla/5.0 (compatible; MSIE 7.0; Windows NT 6.2; Trident/6.0)")
-        expect(base).to receive(:view_factory).and_return(view_factory)
-        expect(base).to receive(:insert_tag).with(component)
-        base.send(:build_unsupported_browser)
-      end
-    end
-
-    context "when the regex not match" do
-      it "should not build the unsupported browser panel" do
-        expect(base).to receive(:active_admin_namespace).and_return(namespace)
-        expect(base).to receive_message_chain(:controller, :request, :user_agent).and_return("Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)")
-        expect(base).to receive(:insert_tag).never
-        base.send(:build_unsupported_browser)
-      end
-    end
-  end
-end

data/spec/unit/views/index_as_blog_spec.rb

@@ -1,76 +0,0 @@
-require 'rails_helper'
-
-include ActiveAdmin
-RSpec.describe ActiveAdmin::Views::IndexAsBlog do
-  subject { described_class.new }
-
-  describe '#build' do
-    let(:page_presenter) { double('page_presenter', block: nil) }
-    let(:collection) { double('collection') }
-
-    before do
-      expect(subject).to receive('build_posts')
-      expect(subject).to receive('add_class').with('index')
-    end
-
-    context 'when page_presenter has no block' do
-      before do
-        subject.build(page_presenter, collection)
-      end
-
-      it do
-        expect(subject.instance_variable_get(:@page_presenter))
-          .to eq(page_presenter)
-        expect(subject.instance_variable_get(:@collection)).to eq(collection)
-      end
-    end
-
-    context 'when page_presenter has block' do
-      let(:block) { Proc.new { double('proc_method') } }
-
-      before do
-        allow(page_presenter).to receive(:block).and_return(block)
-        allow(subject).to receive('instance_exec')
-        subject.build(page_presenter, collection)
-      end
-
-      it do
-        expect(subject).to have_received('instance_exec')
-      end
-    end
-  end
-
-  %w(title body).each do |method|
-    describe "#{method}" do
-      context 'when block given' do
-        let(:block_result) { double('block_result') }
-
-        it "should use the block to set the #{method}" do
-          expect(
-            subject.public_send("#{method}") do
-              block_result
-            end.yield
-          ).to eq(block_result)
-        end
-      end
-
-      context 'when no block and method given' do
-        let(:method) { double('method') }
-
-        it "should use method to set the #{method}" do
-          expect(subject.public_send("#{method}", method)).to eq(method)
-        end
-      end
-
-      context 'when no block and no method given' do
-        it 'should be nil' do
-          expect(subject.public_send("#{method}")).to eq(nil)
-        end
-      end
-    end
-  end
-
-  describe '.index_name' do
-    it { expect(described_class.index_name).to eq('blog') }
-  end
-end

data/spec/unit/views/pages/form_spec.rb

@@ -1,54 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Views::Pages::Form do
-  describe "#title" do
-    let!(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ ActiveAdmin::Namespace.new(application, "Admin") }
-    let!(:http_params){ { controller: "UsersController", action: "edit" } }
-    let!(:params) { ActionController::Parameters.new(http_params) }
-
-    let(:helpers) do
-      helpers = mock_action_view
-      allow(helpers).to receive(:active_admin_config).and_return(namespace.register(Post))
-      allow(helpers).to receive(:params).and_return(params)
-      helpers
-    end
-
-    let(:arbre_context) do
-      OpenStruct.new(params: params, helpers: helpers, assigns: {})
-    end
-
-    context "when :title is set" do
-      it "should show the set page title" do
-
-        page = ActiveAdmin::Views::Pages::Form.new(arbre_context)
-        expect(page).to receive(:resource)
-        expect(page).to receive(:form_presenter).twice.and_return({ title: "My Page Title" })
-        expect(page.title).to eq "My Page Title"
-      end
-    end
-
-    context "when page_title is assigned" do
-      it "should show the set page title" do
-        arbre_context.assigns[:page_title] = "My Page Title"
-        page = ActiveAdmin::Views::Pages::Form.new(arbre_context)
-        expect(page.title).to eq "My Page Title"
-      end
-    end
-
-    context "when page_title is not assigned" do
-      {
-        "new" => "New Post",
-        "create" => "New Post",
-        "edit" => "Edit Post",
-        "update" => "Edit Post"
-      }.each do |action, title|
-        it "should show the correct I18n text on the #{action} action" do
-          params[:action] = action
-          page = ActiveAdmin::Views::Pages::Form.new(arbre_context)
-          expect(page.title).to eq title
-        end
-      end
-    end
-  end
-end

data/spec/unit/views/pages/index_spec.rb

@@ -1,60 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Views::Pages::Index do
-  describe "#title" do
-    let!(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ ActiveAdmin::Namespace.new(application, "Admin") }
-    let!(:params){ ActionController::Parameters.new(controller: "UsersController", action: "edit") }
-    let(:helpers) do
-      helpers = mock_action_view
-      allow(helpers).to receive(:active_admin_config).and_return(namespace.register(Post))
-      allow(helpers).to receive(:params).and_return(params)
-      helpers
-    end
-
-    let(:arbre_context) do
-      OpenStruct.new(params: params, helpers: helpers, assigns: {})
-    end
-
-    context "when config[:title] is assigned" do
-      context "with a Proc" do
-        it "should return the value of the assigned Proc" do
-          page = ActiveAdmin::Views::Pages::Index.new(arbre_context)
-          allow(page).to receive(:config).and_return(title: ->{ "My Page Title" })
-          expect(page.title).to eq "My Page Title"
-        end
-      end
-
-      context "with a String" do
-        it "should return the assigned String" do
-          page = ActiveAdmin::Views::Pages::Index.new(arbre_context)
-          allow(page).to receive(:config).and_return(title: ->{ "My Page Title" })
-          expect(page.title).to eq "My Page Title"
-        end
-      end
-
-      context "with a Integer" do
-        it "should return the Integer" do
-          page = ActiveAdmin::Views::Pages::Index.new(arbre_context)
-          allow(page).to receive(:config).and_return(title: 1)
-          expect(page.title).to eq 1
-        end
-      end
-    end
-
-    context "when page_title is assigned" do
-      it "should return the set page title" do
-        arbre_context.assigns[:page_title] = "My Page Title"
-        page = ActiveAdmin::Views::Pages::Index.new(arbre_context)
-        expect(page.title).to eq "My Page Title"
-      end
-    end
-
-    context "when page_title is not assigned" do
-      it "should return the correct I18n text" do
-        page = ActiveAdmin::Views::Pages::Index.new(arbre_context)
-        expect(page.title).to eq "Posts"
-      end
-    end
-  end
-end

data/spec/unit/views/pages/layout_spec.rb

@@ -1,59 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Views::Pages::Layout do
-
-  let(:assigns){ {} }
-  let(:helpers) do
-    helpers = mock_action_view
-
-    { active_admin_application:   active_admin_application,
-      active_admin_config:        double('Config', action_items?: nil, breadcrumb: nil, sidebar_sections?: nil),
-      active_admin_namespace:     active_admin_namespace,
-      csrf_meta_tag:              '',
-      current_active_admin_user:  nil,
-      current_active_admin_user?: false,
-      current_menu:               double('Menu', items: []),
-      params:                     {controller: 'UsersController', action: 'edit'},
-      env:                        {}
-    }.each do |method, returns|
-      allow(helpers).to receive(method).and_return returns
-    end
-
-    helpers
-  end
-
-  let(:active_admin_namespace){ ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :myspace) }
-  let(:active_admin_application){ ActiveAdmin.application }
-  let(:view_factory) { ActiveAdmin::ViewFactory.new }
-
-  let(:layout) do
-    render_arbre_component assigns, helpers do
-      insert_tag ActiveAdmin::Views::Pages::Layout
-    end
-  end
-
-  it "should be the @page_title if assigned in the controller" do
-    assigns[:page_title] = "My Page Title"
-
-    expect(layout.title).to eq "My Page Title"
-  end
-
-  it "should be the default translation" do
-    helpers.params[:action] = "edit"
-
-    expect(layout.title).to eq "Edit"
-  end
-
-  describe "the body" do
-
-    it "should have class 'active_admin'" do
-      expect(layout.build.class_list).to include 'active_admin'
-    end
-
-    it "should have namespace class" do
-      expect(layout.build.class_list).to include "#{active_admin_namespace.name}_namespace"
-    end
-
-  end
-
-end

data/spec/unit/views/pages/show_spec.rb

@@ -1,32 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Views::Pages::Show do
-
-  describe "the resource" do
-    let(:helpers) { double resource: resource }
-    let(:arbre_context) { Arbre::Context.new({}, helpers) }
-    subject(:page) { ActiveAdmin::Views::Pages::Show.new(arbre_context) }
-
-    context 'when the resource does not respond to #decorator' do
-      let(:resource) { 'Test Resource' }
-
-      it "normally returns the resource" do
-        expect(page.resource).to eq 'Test Resource'
-      end
-    end
-
-    context 'when you pass a block to main content' do
-      let(:block) { lambda { } }
-      let(:resource) { double('resource') }
-
-      before { allow(page).to receive(:active_admin_config).and_return(double(comments?: false, resource_columns: [:field]))}
-
-      it 'appends it to the output' do
-        expect(page).to receive(:attributes_table).with(:field).and_yield
-        page.default_main_content(&block)
-      end
-    end
-
-  end
-
-end

data/spec/unit/views/tabbed_navigation_spec.rb

@@ -1,158 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Views::TabbedNavigation do
-
-  let(:menu){ ActiveAdmin::Menu.new }
-
-  let(:assigns){ { active_admin_menu: menu } }
-  let(:helpers){ mock_action_view }
-
-  let(:tabbed_navigation) do
-    arbre(assigns, helpers) {
-      insert_tag(ActiveAdmin::Views::TabbedNavigation, active_admin_menu)
-    }.children.first
-  end
-
-  let(:html) { Capybara.string(tabbed_navigation.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(tabbed_navigation.menu_items).to eq menu.items
-    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(tabbed_navigation.menu_items).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(tabbed_navigation.menu_items).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(tabbed_navigation.menu_items).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(tabbed_navigation.menu_items.size).to eq(1)
-    end
-
-  end
-end