activeadmin 1.0.0.pre1 → 2.9.0

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

@@ -1,235 +0,0 @@
-require 'rails_helper'
-
-describe ActiveAdmin::Views::StatusTag do
-
-  describe "#status_tag" do
-
-    # Helper method to build StatusTag objects in an Arbre context
-    def status_tag(*args)
-      render_arbre_component(status_tag_args: args) do
-        status_tag(*assigns[:status_tag_args])
-      end
-    end
-
-    subject { status_tag(nil) }
-
-    describe '#tag_name' do
-      subject { super().tag_name }
-      it      { is_expected.to eq 'span' }
-    end
-
-    describe '#class_list' do
-      subject { super().class_list }
-      it      { is_expected.to include('status_tag') }
-    end
-
-    context "when status is 'completed'" do
-      subject { status_tag('completed') }
-
-      describe '#tag_name' do
-        subject { super().tag_name }
-        it      { is_expected.to eq 'span' }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('status_tag') }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('completed') }
-      end
-
-      describe '#content' do
-        subject { super().content }
-        it      { is_expected.to eq 'Completed' }
-      end
-    end
-
-    context "when status is 'in_progress'" do
-      subject { status_tag('in_progress') }
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('in_progress') }
-      end
-
-      describe '#content' do
-        subject { super().content }
-        it      { is_expected.to eq 'In Progress' }
-      end
-    end
-
-    context "when status is 'In progress'" do
-      subject { status_tag('In progress') }
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('in_progress') }
-      end
-
-      describe '#content' do
-        subject { super().content }
-        it      { is_expected.to eq 'In Progress' }
-      end
-    end
-
-    context "when status is an empty string" do
-      subject { status_tag('') }
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('status_tag') }
-      end
-
-      describe '#content' do
-        subject { super().content }
-        it      { is_expected.to eq '' }
-      end
-    end
-
-    context "when status is false" do
-      subject { status_tag('false') }
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('status_tag') }
-      end
-
-      describe '#content' do
-        subject { super().content }
-        it      { is_expected.to eq('No') }
-      end
-    end
-
-    context "when status is nil" do
-      subject { status_tag(nil) }
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('status_tag') }
-      end
-
-      describe '#content' do
-        subject { super().content }
-        it      { is_expected.to eq('No') }
-      end
-    end
-
-    context "when status is 'Active' and type is :ok" do
-      subject { status_tag('Active', :ok) }
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('status_tag') }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('active') }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('ok') }
-      end
-    end
-
-    context "when status is 'Active' and class is 'ok'" do
-      subject { status_tag('Active', class: 'ok') }
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('status_tag') }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('active') }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('ok') }
-      end
-    end
-
-    context "when status is 'Active' and label is 'on'" do
-      subject { status_tag('Active', label: 'on') }
-
-      describe '#content' do
-        subject { super().content }
-        it      { is_expected.to eq 'on' }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('status_tag') }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('active') }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.not_to include('on') }
-      end
-    end
-
-    context "when status is 'So useless', type is :ok, class is 'woot awesome' and id is 'useless'" do
-      subject { status_tag('So useless', :ok, class: 'woot awesome', id: 'useless') }
-
-      describe '#content' do
-        subject { super().content }
-        it      { is_expected.to eq 'So Useless' }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('status_tag') }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('ok') }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('so_useless') }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('woot') }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.to include('awesome') }
-      end
-
-      describe '#id' do
-        subject { super().id }
-        it      { is_expected.to eq 'useless' }
-      end
-    end
-
-    context "when status is set to a Fixnum" do
-      subject { status_tag(42) }
-
-      describe '#content' do
-        subject { super().content }
-        it      { is_expected.to eq '42' }
-      end
-
-      describe '#class_list' do
-        subject { super().class_list }
-        it      { is_expected.not_to include('42') }
-      end
-    end
-  end
-end

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

@@ -1,384 +0,0 @@
-require 'rails_helper'
-
-describe ActiveAdmin::Views::TableFor do
-  describe "creating with the dsl" do
-
-    let(:collection) do
-      [Post.new(title: "First Post", starred: true), Post.new(title: "Second Post"), Post.new(title: "Third Post", starred: false)]
-    end
-
-    let(:assigns){ { collection: collection } }
-    let(:helpers){ mock_action_view }
-
-    context "when creating a column using symbol argument" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection, :title)
-        end
-      end
-
-      it "should create a table header based on the symbol" do
-        expect(table.find_by_tag("th").first.content).to eq "Title"
-      end
-
-      it "should create a table row for each element in the collection" do
-        expect(table.find_by_tag("tr").size).to eq 4 # 1 for head, 3 for rows
-      end
-
-      ["First Post", "Second Post", "Third Post"].each_with_index do |content, index|
-        it "should create a cell with #{content}" do
-          expect(table.find_by_tag("td")[index].content).to eq content
-        end
-      end
-    end
-
-    context "when creating many columns using symbol arguments" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection, :title, :created_at)
-        end
-      end
-
-      it "should create a table header based on the symbol" do
-        expect(table.find_by_tag("th").first.content).to eq "Title"
-        expect(table.find_by_tag("th").last.content).to eq "Created At"
-      end
-
-      it "should add a class to each table header based on the col name" do
-        expect(table.find_by_tag("th").first.class_list.to_a.join(' ')).to eq "col col-title"
-        expect(table.find_by_tag("th").last.class_list.to_a.join(' ')).to eq "col col-created_at"
-      end
-
-      it "should create a table row for each element in the collection" do
-        expect(table.find_by_tag("tr").size).to eq 4 # 1 for head, 3 for rows
-      end
-
-      it "should create a cell for each column" do
-        expect(table.find_by_tag("td").size).to eq 6
-      end
-
-      it "should add a class for each cell based on the col name" do
-        expect(table.find_by_tag("td").first.class_list.to_a.join(' ')).to eq "col col-title"
-        expect(table.find_by_tag("td").last.class_list.to_a.join(' ')).to eq "col col-created_at"
-      end
-    end
-
-    context "when creating a column using symbol arguments and another using block" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection, :title) do
-            column :created_at
-          end
-        end
-      end
-
-      it "should create a table header based on the symbol" do
-        expect(table.find_by_tag("th").first.content).to eq "Title"
-        expect(table.find_by_tag("th").last.content).to eq "Created At"
-      end
-
-      it "should add a class to each table header based on the col name" do
-        expect(table.find_by_tag("th").first.class_list.to_a.join(' ')).to eq "col col-title"
-        expect(table.find_by_tag("th").last.class_list.to_a.join(' ')).to eq "col col-created_at"
-      end
-
-      it "should create a table row for each element in the collection" do
-        expect(table.find_by_tag("tr").size).to eq 4 # 1 for head, 3 for rows
-      end
-
-      it "should create a cell for each column" do
-        expect(table.find_by_tag("td").size).to eq 6
-      end
-
-      it "should add a class for each cell based on the col name" do
-        expect(table.find_by_tag("td").first.class_list.to_a.join(' ')).to eq "col col-title"
-        expect(table.find_by_tag("td").last.class_list.to_a.join(' ')).to eq "col col-created_at"
-      end
-    end
-
-    context "when creating a column with a symbol" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection) do
-            column :title
-          end
-        end
-      end
-
-      it "should create a table header based on the symbol" do
-        expect(table.find_by_tag("th").first.content).to eq "Title"
-      end
-
-      it "should create a table row for each element in the collection" do
-        expect(table.find_by_tag("tr").size).to eq 4 # 1 for head, 3 for rows
-      end
-
-      ["First Post", "Second Post", "Third Post"].each_with_index do |content, index|
-        it "should create a cell with #{content}" do
-          expect(table.find_by_tag("td")[index].content).to eq content
-        end
-      end
-    end
-
-    context "when creating many columns with symbols" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection) do
-            column :title
-            column :created_at
-          end
-        end
-      end
-
-      it "should create a table header based on the symbol" do
-        expect(table.find_by_tag("th").first.content).to eq "Title"
-        expect(table.find_by_tag("th").last.content).to eq "Created At"
-      end
-
-      it "should add a class to each table header based on the col name" do
-        expect(table.find_by_tag("th").first.class_list.to_a.join(' ')).to eq "col col-title"
-        expect(table.find_by_tag("th").last.class_list.to_a.join(' ')).to eq "col col-created_at"
-      end
-
-      it "should create a table row for each element in the collection" do
-        expect(table.find_by_tag("tr").size).to eq 4 # 1 for head, 3 for rows
-      end
-
-      it "should create a cell for each column" do
-        expect(table.find_by_tag("td").size).to eq 6
-      end
-
-      it "should add a class for each cell based on the col name" do
-        expect(table.find_by_tag("td").first.class_list.to_a.join(' ')).to eq "col col-title"
-        expect(table.find_by_tag("td").last.class_list.to_a.join(' ')).to eq "col col-created_at"
-      end
-    end
-
-    context "when creating a column with block content" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection) do
-            column :title do |post|
-              span(post.title)
-            end
-          end
-        end
-      end
-
-      it "should add a class to each table header based on the col name" do
-        expect(table.find_by_tag("th").first.class_list).to include("col-title")
-      end
-
-      [ "<span>First Post</span>",
-        "<span>Second Post</span>",
-        "<span>Third Post</span>" ].each_with_index do |content, index|
-        it "should create a cell with #{content}" do
-          expect(table.find_by_tag("td")[index].content.strip).to eq content
-        end
-      end
-    end
-
-    context "when creating a column with multiple block content" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection) do
-            column :title do |post|
-              span(post.title)
-              span(post.title)
-            end
-          end
-        end
-      end
-
-      3.times do |index|
-        it "should create a cell with multiple elements in row #{index}" do
-          expect(table.find_by_tag("td")[index].find_by_tag("span").size).to eq 2
-        end
-      end
-    end
-
-
-    context "when creating many columns with symbols, blocks and strings" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection) do
-            column "My Custom Title", :title
-            column :created_at , class:"datetime"
-          end
-        end
-      end
-
-
-      it "should add a class to each table header  based on class option or the col name" do
-        expect(table.find_by_tag("th").first.class_list.to_a.join(' ')).to eq "col col-my_custom_title"
-        expect(table.find_by_tag("th").last.class_list.to_a.join(' ')).to eq "col datetime"
-      end
-
-      it "should add a class to each cell based  on class option or the col name" do
-        expect(table.find_by_tag("td").first.class_list.to_a.join(' ')).to eq "col col-my_custom_title"
-        expect(table.find_by_tag("td").last.class_list.to_a.join(' ')).to eq "col datetime"
-      end
-    end
-
-    context "when using a single record instead of a collection" do
-      let(:table) do
-        render_arbre_component nil, helpers do
-          table_for Post.new do
-            column :title
-          end
-        end
-      end
-      it "should render" do
-        expect(table.find_by_tag("th").first.content).to eq "Title"
-      end
-    end
-
-    context "when using a single Hash" do
-      let(:table) do
-        render_arbre_component nil, helpers do
-          table_for foo: 1, bar: 2 do
-            column :foo
-            column :bar
-          end
-        end
-      end
-      it "should render" do
-        expect(table.find_by_tag("th")[0].content).to eq "Foo"
-        expect(table.find_by_tag("th")[1].content).to eq "Bar"
-        expect(table.find_by_tag("td")[0].content).to eq "1"
-        expect(table.find_by_tag("td")[1].content).to eq "2"
-      end
-    end
-
-    context "when using an Array of Hashes" do
-      let(:table) do
-        render_arbre_component nil, helpers do
-          table_for [{foo: 1},{foo: 2}] do
-            column :foo
-          end
-        end
-      end
-      it "should render" do
-        expect(table.find_by_tag("th")[0].content).to eq "Foo"
-        expect(table.find_by_tag("td")[0].content).to eq "1"
-        expect(table.find_by_tag("td")[1].content).to eq "2"
-      end
-    end
-
-    context "when record attribute is boolean" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection) do
-            column :starred
-          end
-        end
-      end
-
-      it "should render boolean attribute within status tag" do
-        expect(table.find_by_tag("span").first.class_list.to_a.join(' ')).to eq "status_tag yes"
-        expect(table.find_by_tag("span").first.content).to eq "Yes"
-        expect(table.find_by_tag("span").last.class_list.to_a.join(' ')).to eq "status_tag no"
-        expect(table.find_by_tag("span").last.content).to eq "No"
-      end
-    end
-
-    context 'when row_class' do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection, row_class: -> e { 'starred' if e.starred }) do
-            column :starred
-          end
-        end
-      end
-
-      it 'should render boolean attribute within status tag' do
-        trs = table.find_by_tag('tr')
-        expect(trs.size).to eq 4
-        expect(trs.first.class_list.to_a.join(' ')).to eq ''
-        expect(trs.second.class_list.to_a.join(' ')).to eq 'odd starred'
-        expect(trs.third.class_list.to_a.join(' ')).to eq 'even'
-        expect(trs.fourth.class_list.to_a.join(' ')).to eq 'odd'
-      end
-    end
-
-  end
-
-  describe "column sorting" do
-
-    def build_column(*args, &block)
-      ActiveAdmin::Views::TableFor::Column.new(*args, &block)
-    end
-
-    subject { table_column }
-
-    context "when default" do
-      let(:table_column){ build_column(:username) }
-      it { is_expected.to be_sortable }
-
-      describe '#sort_key' do
-        subject { super().sort_key }
-        it{ is_expected.to eq("username") }
-      end
-    end
-
-    context "when a block given with no sort key" do
-      let(:table_column){ build_column("Username"){ } }
-      it { is_expected.to be_sortable }
-    end
-
-    context "when a block given with a sort key" do
-      let(:table_column){ build_column("Username", sortable: :username){ } }
-      it { is_expected.to be_sortable }
-
-      describe '#sort_key' do
-        subject { super().sort_key }
-        it{ is_expected.to eq("username") }
-      end
-    end
-
-    context 'when a block given with virtual attribute and no sort key' do
-      let(:table_column) { build_column(:virtual, nil, Post) { } }
-      it { is_expected.not_to be_sortable }
-    end
-
-    context 'when symbol given as a data column should be sortable' do
-      let(:table_column){ build_column('Username column', :username) }
-      it { is_expected.to be_sortable }
-
-      describe '#sort_key' do
-        subject { super().sort_key }
-        it { is_expected.to eq 'username' }
-      end
-    end
-
-    context 'when sortable: true with a symbol and string' do
-      let(:table_column){ build_column('Username column', :username, sortable: true) }
-      it { is_expected.to be_sortable }
-
-      describe '#sort_key' do
-        subject { super().sort_key }
-        it { is_expected.to eq 'username' }
-      end
-    end
-
-    context "when sortable: false with a symbol" do
-      let(:table_column){ build_column(:username, sortable: false) }
-      it { is_expected.not_to be_sortable }
-    end
-
-    context "when sortable: false with a symbol and string" do
-      let(:table_column){ build_column("Username", :username, sortable: false) }
-      it { is_expected.not_to be_sortable }
-    end
-
-    context "when :sortable column is an association" do
-      let(:table_column){ build_column("Category", :category, Post) }
-      it { is_expected.not_to be_sortable }
-    end
-
-    context 'when :sortable column is an association and block given' do
-      let(:table_column){ build_column('Category', :category, Post) { } }
-      it { is_expected.not_to be_sortable }
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-require 'rails_helper'
-
-describe ActiveAdmin::Views::Tabs do
-  describe "creating with the dsl" do
-    context "when creating tabs with a symbol" do
-      let(:tabs) do
-        render_arbre_component do
-          tabs do
-            tab :overview
-          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
-    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,47 +0,0 @@
-require 'rails_helper'
-
-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(:env).and_return({ "HTTP_USER_AGENT" => "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(:env).and_return({ "HTTP_USER_AGENT" => "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