activeadmin 1.1.0 → 2.14.0

data/spec/unit/view_helpers/method_or_proc_helper_spec.rb

@@ -1,138 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe MethodOrProcHelper do
-  let(:receiver) { double }
-
-  let(:context) do
-    obj = double receiver_in_context: receiver
-    obj.extend MethodOrProcHelper
-    obj
-  end
-
-  describe "#call_method_or_exec_proc" do
-
-    it "should call the method in the context when a symbol" do
-      expect(context.call_method_or_exec_proc(:receiver_in_context)).to eq receiver
-    end
-
-    it "should call the method in the context when a string" do
-      expect(context.call_method_or_exec_proc("receiver_in_context")).to eq receiver
-    end
-
-    it "should exec a proc in the context" do
-      test_proc = Proc.new{ raise "Success" if receiver_in_context }
-
-      expect {
-        context.call_method_or_exec_proc(test_proc)
-      }.to raise_error("Success")
-    end
-
-  end
-
-  describe "#call_method_or_proc_on" do
-
-    [:hello, 'hello'].each do |key|
-      context "when a #{key.class}" do
-        it "should call the method on the receiver" do
-          expect(receiver).to receive(key).and_return 'hello'
-
-          expect(context.call_method_or_proc_on(receiver, key)).to eq 'hello'
-        end
-
-        it "should receive additional arguments" do
-          expect(receiver).to receive(key).with(:world).and_return 'hello world'
-
-          expect(context.call_method_or_proc_on(receiver, key, :world)).to eq 'hello world'
-        end
-      end
-    end
-
-    context "when a proc" do
-
-      it "should exec the block in the context and pass in the receiver" do
-        test_proc = Proc.new do |arg|
-          raise "Success!" if arg == receiver_in_context
-        end
-
-        expect {
-          context.call_method_or_proc_on(receiver, test_proc)
-        }.to raise_error("Success!")
-      end
-
-      it "should receive additional arguments" do
-        test_proc = Proc.new do |arg1, arg2|
-          raise "Success!" if arg1 == receiver_in_context && arg2 == "Hello"
-        end
-
-        expect {
-          context.call_method_or_proc_on(receiver, test_proc, "Hello")
-        }.to raise_error("Success!")
-      end
-
-    end
-
-    context "when a proc and exec: false" do
-
-      it "should call the proc and pass in the receiver" do
-        obj_not_in_context = double
-
-        test_proc = Proc.new do |arg|
-          raise "Success!" if arg == receiver && obj_not_in_context
-        end
-
-        expect {
-          context.call_method_or_proc_on(receiver, test_proc, exec: false)
-        }.to raise_error("Success!")
-      end
-
-    end
-
-  end
-
-  describe "#render_or_call_method_or_proc_on" do
-    [ :symbol, Proc.new{} ].each do |key|
-      context "when a #{key.class}" do
-        it "should call #call_method_or_proc_on" do
-          options = { foo: :bar }
-          expect(context).to receive(:call_method_or_proc_on).with(receiver, key, options).and_return("data")
-          expect(context.render_or_call_method_or_proc_on(receiver, key, options)).to eq "data"
-        end
-      end
-    end
-
-    context "when a string" do
-      it "should return the string" do
-        expect(context.render_or_call_method_or_proc_on(receiver, "string")).to eq "string"
-      end
-    end
-  end
-
-  describe "#render_in_context" do
-    let(:args) { [1, 2, 3] }
-
-    context "when a Proc" do
-      let(:object) { Proc.new { } }
-
-      it "should instance_exec the Proc" do
-        expect(receiver).to receive(:instance_exec).with(args, &object).and_return("data")
-        expect(context.render_in_context(receiver, object, args)).to eq "data"
-      end
-    end
-
-    context "when a Symbol" do
-      it "should send the symbol" do
-        expect(receiver).to receive(:public_send).with(:symbol, args).and_return("data")
-        expect(context.render_in_context(receiver, :symbol, args)).to eq "data"
-      end
-    end
-
-    context "when a Object (not Proc or String)" do
-      let(:object) { Object.new }
-
-      it "should return the Object" do
-        expect(context.render_in_context(receiver, object)).to eq object
-      end
-    end
-  end
-
-end

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

@@ -1,271 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Views::AttributesTable do
-
-  describe "creating with the dsl" do
-    let(:helpers) { action_view }
-
-    let(:post) do
-      post = Post.new title: "Hello World", body: nil
-      allow(post).to receive(:id){ 1 }
-      allow(post).to receive(:new_record?){ false }
-      post
-    end
-
-    let(:assigns){ { post: post } }
-
-    # Loop through a few different ways to make the same table
-    # and ensure that they produce the same results
-    {
-      "when attributes are passed in to the builder methods" => proc {
-        render_arbre_component(assigns) {
-          attributes_table_for post, :id, :title, :body
-        }
-      },
-      "when attributes are built using the block" => proc {
-        render_arbre_component(assigns) {
-          attributes_table_for post do
-            rows :id, :title, :body
-          end
-        }
-      },
-      "when each attribute is passed in by itself" => proc {
-        render_arbre_component(assigns) {
-          attributes_table_for post do
-            row :id
-            row :title
-            row :body
-          end
-        }
-      },
-      "when you create each row with a custom block" => proc {
-        render_arbre_component(assigns) {
-          attributes_table_for post do
-            row("Id")   { post.id }
-            row("Title"){ post.title }
-            row("Body") { post.body }
-          end
-        }
-      },
-      "when you create each row with a custom block that returns nil" => proc {
-        render_arbre_component(assigns) {
-          attributes_table_for post do
-            row("Id")   { text_node post.id; nil }
-            row("Title"){ text_node post.title; nil }
-            row("Body") { text_node post.body; nil }
-          end
-        }
-      },
-    }.each do |context_title, table_decleration|
-      context context_title do
-        let(:table) { instance_eval &table_decleration }
-
-        it "should render a div wrapper with the class '.attributes_table'" do
-          expect(table.tag_name).to eq 'div'
-          expect(table.attr(:class)).to include('attributes_table')
-        end
-
-        it "should add id and type class" do
-          expect(table.class_names).to include("post")
-          expect(table.id).to eq "attributes_table_post_1"
-        end
-
-        it "should render 3 rows" do
-          expect(table.find_by_tag("tr").size).to eq 3
-        end
-
-        describe "rendering the rows" do
-          [
-            ["Id" , "1"],
-            ["Title" , "Hello World"],
-            ["Body" , "<span class=\"empty\">Empty</span>"]
-          ].each_with_index do |(title, content), i|
-            describe "for #{title}" do
-              let(:current_row){ table.find_by_tag("tr")[i] }
-
-              it "should have the title '#{title}'" do
-                expect(current_row.find_by_tag("th").first.content).to eq title
-              end
-
-              it "should have the content '#{content}'" do
-                expect(current_row.find_by_tag("td").first.content.chomp.strip).to eq content
-              end
-            end
-          end
-        end # describe rendering rows
-
-      end
-    end # describe dsl styles
-
-    it "should add a class for each row based on the col name" do
-      table = render_arbre_component(assigns) {
-        attributes_table_for(post) do
-          row :title
-          row :created_at
-        end
-      }
-      expect(table.find_by_tag("tr").first.to_s.
-        split("\n").first.lstrip).
-          to eq '<tr class="row row-title">'
-
-      expect(table.find_by_tag("tr").last.to_s.
-        split("\n").first.lstrip).
-          to eq '<tr class="row row-created_at">'
-    end
-
-    it "should allow html options for the row itself" do
-      table = render_arbre_component(assigns) {
-        attributes_table_for(post) do
-          row("Wee", class: "custom_row", style: "custom_style") { }
-        end
-      }
-      expect(table.find_by_tag("tr").first.to_s.split("\n").first.lstrip).
-        to eq '<tr class="row custom_row" style="custom_style">'
-    end
-
-    it "should allow html content inside the attributes table" do
-      table = render_arbre_component(assigns) {
-        attributes_table_for(post) do
-          row("ID"){ span(post.id, class: 'id') }
-        end
-      }
-      expect(table.find_by_tag("td").first.content.chomp.strip).to eq "<span class=\"id\">1</span>"
-    end
-
-    context 'an attribute ending in _id' do
-      before do
-        post.foo_id = 23
-        post.author = User.new username: 'john_doe', first_name: 'John', last_name: 'Doe'
-      end
-      it 'should call the association if one exists' do
-        table = render_arbre_component assigns do
-          attributes_table_for post, :author
-        end
-        expect(table.find_by_tag('th').first.content).to eq 'Author'
-        expect(table.find_by_tag('td').first.content).to eq 'John Doe'
-      end
-      it 'should not attempt to call a nonexistant association' do
-        table = render_arbre_component assigns do
-          attributes_table_for post, :foo_id
-        end
-        expect(table.find_by_tag('th').first.content).to eq 'Foo'
-        expect(table.find_by_tag('td').first.content).to eq '23'
-      end
-    end
-
-    context "with a collection" do
-      let(:posts) do
-        [Post.new(title: "Hello World", id: 1), Post.new(title: "Multi Column", id: 2)].each_with_index do |post, index|
-          allow(post).to receive(:id).and_return(index + 1)
-          allow(post).to receive(:new_record?).and_return(false)
-        end
-      end
-
-      let(:assigns) { { posts: posts } }
-
-      let(:table) do
-        render_arbre_component(assigns) do
-          attributes_table_for posts, :id, :title
-        end
-      end
-
-      it "does not set id on the table" do
-        expect(table.attr(:id)).to eq nil
-      end
-
-      context "colgroup" do
-        let(:cols) { table.find_by_tag "col" }
-
-        it "contains a col for each record (plus headers)" do
-          expect(cols.size).to eq (2 + 1)
-        end
-
-        it "assigns an id to each col" do
-          cols[1..-1].each_with_index do |col, index|
-            expect(col.id).to eq "attributes_table_post_#{index + 1}"
-          end
-        end
-
-        it "assigns a class to each col" do
-          cols[1..-1].each_with_index do |col, index|
-            expect(col.class_names).to include("post")
-          end
-        end
-
-        it "assigns alternation classes to each col" do
-          cols[1..-1].each_with_index do |col, index|
-            expect(col.class_names).to include(["even", "odd"][index % 2])
-          end
-        end
-      end
-
-      context "when rendering the rows" do
-        it "should contain 3 columns" do
-          expect(table.find_by_tag("tr").first.children.size).to eq 3
-        end
-
-        [
-          ["Id" , "1", "2"],
-          ["Title", "Hello World", "Multi Column"],
-        ].each_with_index do |set, i|
-          describe "for #{set[0]}" do
-            let(:title){ set[0] }
-            let(:content){ set[1] }
-            let(:current_row){ table.find_by_tag("tr")[i] }
-
-            it "should have the title '#{set[0]}'" do
-              expect(current_row.find_by_tag("th").first.content).to eq title
-            end
-
-            context "with defined attribute name translation" do
-              it "should have the translated attribute name in the title" do
-                with_translation activerecord: {attributes: {post: {title: 'Translated Title', id: 'Translated Id'}}} do
-                  expect(current_row.find_by_tag("th").first.content).to eq "Translated #{title}"
-                end
-              end
-            end
-
-            set[1..-1].each_with_index do |content, index|
-              it "column #{index} should have the content '#{content}'" do
-                expect(current_row.find_by_tag("td")[index].content.chomp.strip).to eq content
-              end
-            end
-          end
-        end
-      end # describe rendering rows
-    end # with a collection
-
-    context "when using a single Hash" do
-      let(:table) do
-        render_arbre_component nil, helpers do
-          attributes_table_for foo: 1, bar: 2 do
-            row :foo
-            row :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
-          attributes_table_for [{foo: 1}, {foo: 2}] do
-            row :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
-  end
-
-end

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

@@ -1,43 +0,0 @@
-require 'rails_helper'
-require 'active_admin/batch_actions/views/batch_action_selector'
-
-RSpec.describe ActiveAdmin::BatchActions::BatchActionSelector do
-
-  let(:dropdown) do
-    render_arbre_component do
-      batch_action_selector [
-        ActiveAdmin::BatchAction.new(:action_1, "Action 1"),
-        ActiveAdmin::BatchAction.new(:action_2, "Action 2"),
-        ActiveAdmin::BatchAction.new(:action_3, "Action 3")
-      ]
-    end
-  end
-
-  describe "the action list" do
-    subject do
-      dropdown.find_by_class("dropdown_menu_list").first
-    end
-
-    describe '#tag_name' do
-      subject { super().tag_name }
-      it { is_expected.to eql("ul") }
-    end
-
-    describe '#content' do
-      subject { super().content }
-      it{ is_expected.to include("class=\"batch_action\" data-action=\"action_1\"") }
-    end
-
-    describe '#content' do
-      subject { super().content }
-      it{ is_expected.to include("class=\"batch_action\" data-action=\"action_2\"") }
-    end
-
-    describe '#content' do
-      subject { super().content }
-      it{ is_expected.to include("class=\"batch_action\" data-action=\"action_3\"") }
-    end
-
-  end
-
-end

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

@@ -1,27 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Views::BlankSlate do
-
-  describe "#blank_slate" do
-    subject do
-      render_arbre_component do
-        blank_slate("There are no Posts yet. <a href=\"/posts/new\">Create one</a></span>")
-      end
-    end
-
-    describe '#tag_name' do
-      subject { super().tag_name }
-      it      { is_expected.to eql 'div' }
-    end
-
-    describe '#class_list' do
-      subject { super().class_list }
-      it      { is_expected.to include('blank_slate_container') }
-    end
-
-    describe '#content' do
-      subject { super().content }
-      it      { is_expected.to include '<span class="blank_slate">There are no Posts yet. <a href="/posts/new">Create one</a></span>' }
-    end
-  end
-end

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

@@ -1,187 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Views::Columns do
-
-  describe "Rendering zero columns" do
-    let(:cols) do
-      render_arbre_component do
-        columns do
-        end
-      end
-    end
-
-    it "should have the class .columns" do
-      expect(cols.class_list).to include("columns")
-    end
-
-    it "should have one column" do
-      expect(cols.children.first.class_list).not_to include("column")
-    end
-  end
-
-  describe "Rendering one column" do
-    let(:cols) do
-      render_arbre_component do
-        columns do
-          column { span "Hello World" }
-        end
-      end
-    end
-
-    it "should have the class .columns" do
-      expect(cols.class_list).to include("columns")
-    end
-
-    it "should have one column" do
-      expect(cols.children.size).to eq 1
-      expect(cols.children.first.class_list).to include("column")
-    end
-
-    it "should have one column with the width 100.0%" do
-      expect(cols.children.first.attr(:style)).to include("width: 100.0%")
-    end
-  end
-
-  describe "Rendering two columns" do
-    let(:cols) do
-      render_arbre_component do
-        columns do
-          column { span "Hello World" }
-          column { span "Hello World" }
-        end
-      end
-    end
-
-    it "should have two columns" do
-      expect(cols.children.size).to eq 2
-    end
-
-    it "should have a first column with width 49% and margin 2%" do
-      expect(cols.children.first.attr(:style)).to eq "width: 49.0%; margin-right: 2%;"
-    end
-
-    it "should have a second column with width 49% and no right margin" do
-      expect(cols.children.last.attr(:style)).to eq "width: 49.0%;"
-    end
-  end
-
-  describe "Rendering four columns" do
-    let(:cols) do
-      render_arbre_component do
-        columns do
-          column { span "Hello World" }
-          column { span "Hello World" }
-          column { span "Hello World" }
-          column { span "Hello World" }
-        end
-      end
-    end
-
-    it "should have four columns" do
-      expect(cols.children.size).to eq 4
-    end
-
-    (0..2).to_a.each do |index|
-      it "should have column #{index + 1} with width 49% and margin 2%" do
-        expect(cols.children[index].attr(:style)).to eq "width: 23.5%; margin-right: 2%;"
-      end
-    end
-
-    it "should have column 4 with width 49% and no margin" do
-      expect(cols.children[3].attr(:style)).to eq "width: 23.5%;"
-    end
-  end
-
-  describe "Column Spans" do
-    let(:cols) do
-      render_arbre_component do
-        columns do
-          column(span: 2){ "Hello World" }
-          column(){ "Hello World" }
-          column(){ "Hello World" }
-        end
-      end
-    end
-
-    it "should set the span when declared" do
-      expect(cols.children.first.attr(:style)).to eq "width: 49.0%; margin-right: 2%;"
-    end
-
-    it "should default to 1 if not passed in" do
-      expect(cols.children.last.attr(:style)).to eq "width: 23.5%;"
-    end
-  end
-
-  describe "Column max width" do
-
-    let(:cols) do
-      render_arbre_component do
-        columns do
-          column(max_width: "100px"){ "Hello World" }
-          column(){ "Hello World" }
-        end
-      end
-    end
-
-    it "should set the max with if passed in" do
-      expect(cols.children.first.attr(:style)).to eq "width: 49.0%; max-width: 100px; margin-right: 2%;"
-    end
-
-    it "should omit the value if not present" do
-      expect(cols.children.last.attr(:style)).to eq "width: 49.0%;"
-    end
-
-    context "when passed an integer value" do
-      let(:cols) do
-        render_arbre_component do
-          columns do
-            column(max_width: 100){ "Hello World" }
-            column(){ "Hello World" }
-          end
-        end
-      end
-
-      it "should be treated as pixels" do
-        expect(cols.children.first.attr(:style)).to eq "width: 49.0%; max-width: 100px; margin-right: 2%;"
-      end
-    end
-
-  end
-
-  describe "Column min width" do
-
-    let(:cols) do
-      render_arbre_component do
-        columns do
-          column(min_width: "100px"){ "Hello World" }
-          column(){ "Hello World" }
-        end
-      end
-    end
-
-    it "should set the min with if passed in" do
-      expect(cols.children.first.attr(:style)).to eq "width: 49.0%; min-width: 100px; margin-right: 2%;"
-    end
-
-    it "should omit the value if not present" do
-      expect(cols.children.last.attr(:style)).to eq "width: 49.0%;"
-    end
-
-    context "when passed an integer value" do
-      let(:cols) do
-        render_arbre_component do
-          columns do
-            column(min_width: 100){ "Hello World" }
-            column(){ "Hello World" }
-          end
-        end
-      end
-
-      it "should be treated as pixels" do
-        expect(cols.children.first.attr(:style)).to eq "width: 49.0%; min-width: 100px; margin-right: 2%;"
-      end
-    end
-
-  end
-
-end