activeadmin_addons 0.12.0 → 1.0.0

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/cancan_adapter_spec.rb

@@ -0,0 +1,43 @@
+require 'rails_helper'
+
+describe ActiveAdmin::CanCanAdapter do
+
+  describe "full integration" do
+
+    let(:application){ ActiveAdmin::Application.new }
+    let(:namespace){ ActiveAdmin::Namespace.new(application, "Admin") }
+    let(:resource){ namespace.register(Post) }
+
+    let :ability_class do
+      Class.new do
+        include CanCan::Ability
+
+        def initialize(user)
+          can :read, Post
+          cannot :update, Post
+        end
+
+      end
+    end
+
+    let(:auth) { namespace.authorization_adapter.new(resource, double) }
+
+    before do
+      namespace.authorization_adapter = ActiveAdmin::CanCanAdapter
+      namespace.cancan_ability_class = ability_class
+    end
+
+    it "should initialize the ability stored in the namespace configuration" do
+      expect(auth.authorized?(:read, Post)).to eq true
+      expect(auth.authorized?(:update, Post)).to eq false
+    end
+
+    it "should scope the collection with accessible_by" do
+      collection = double
+      expect(collection).to receive(:accessible_by).with(auth.cancan_ability, :edit)
+      auth.scope_collection(collection, :edit)
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/comments_spec.rb

@@ -0,0 +1,188 @@
+require 'rails_helper'
+
+describe "Comments" do
+  let(:application) { ActiveAdmin::Application.new }
+
+  describe ActiveAdmin::Comment do
+    subject(:comment){ ActiveAdmin::Comment.new }
+
+    it "has valid Associations and Validations" do
+      expect(comment).to belong_to :resource
+      expect(comment).to belong_to :author
+      expect(comment).to validate_presence_of :resource
+      expect(comment).to validate_presence_of :body
+      expect(comment).to validate_presence_of :namespace
+    end
+
+    describe ".find_for_resource_in_namespace" do
+      let(:post) { Post.create!(title: "Hello World") }
+      let(:namespace_name) { "admin" }
+
+      before do
+        @comment = ActiveAdmin::Comment.create! resource: post,
+                                                body: "A Comment",
+                                                namespace: namespace_name
+      end
+
+      it "should return a comment for the resource in the same namespace" do
+        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(post, namespace_name)).to eq [@comment]
+      end
+
+      it "should not return a comment for the same resource in a different namespace" do
+        ActiveAdmin.application.namespaces[:public] = ActiveAdmin.application.namespaces[:admin]
+        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(post, 'public')).to eq []
+        ActiveAdmin.application.namespaces.instance_variable_get(:@namespaces).delete(:public)
+      end
+
+      it "should not return a comment for a different resource" do
+        another_post = Post.create! title: "Another Hello World"
+        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(another_post, namespace_name)).to eq []
+      end
+
+      it "should return the most recent comment first" do
+        ActiveAdmin::Comment.class_eval { attr_accessible :created_at } if Rails::VERSION::MAJOR == 3
+        another_comment = ActiveAdmin::Comment.create! resource: post,
+                                                       body: "Another Comment",
+                                                       namespace: namespace_name,
+                                                       created_at: @comment.created_at + 20.minutes
+
+        yet_another_comment = ActiveAdmin::Comment.create! resource: post,
+                                                           body: "Yet Another Comment",
+                                                           namespace: namespace_name,
+                                                           created_at: @comment.created_at + 10.minutes
+
+        comments = ActiveAdmin::Comment.find_for_resource_in_namespace(post, namespace_name)
+        expect(comments.size).to eq 3
+        expect(comments.first).to eq(@comment)
+        expect(comments.second).to eq(yet_another_comment)
+        expect(comments.last).to eq(another_comment)
+      end
+
+      it "should return the correctly ordered comments" do
+        ActiveAdmin::Application.inheritable_setting(
+          :comments_order, "created_at DESC"
+        )
+
+        another_comment = ActiveAdmin::Comment.create!(
+          resource: post,
+          body: "Another Comment",
+          namespace: namespace_name,
+          created_at: @comment.created_at + 20.minutes
+        )
+
+        comments = ActiveAdmin::Comment.find_for_resource_in_namespace(
+          post, namespace_name
+        )
+        expect(comments.size).to eq 2
+        expect(comments.first).to eq(another_comment)
+        expect(comments.last).to eq(@comment)
+      end
+    end
+
+    describe ".resource_id_cast" do
+      let(:post) { Post.create!(title: "Testing.") }
+      let(:namespace_name) { "admin" }
+
+      it "should cast resource_id as string" do
+        comment = ActiveAdmin::Comment.create! resource: post,
+                                                body: "Another Comment",
+                                                namespace: namespace_name
+        expect(ActiveAdmin::Comment.resource_id_cast(comment).class).to eql String
+      end
+    end
+
+    describe ".resource_type" do
+      let(:post) { Post.create!(title: "Testing.") }
+      let(:post_decorator) { double 'PostDecorator' }
+
+      before do
+        allow(post_decorator).to receive(:model).and_return(post)
+        allow(post_decorator).to receive(:decorated?).and_return(true)
+      end
+
+      context "when a decorated object is passed" do
+        let(:resource) { post_decorator }
+
+        it "returns undeorated object class string" do
+          expect(ActiveAdmin::Comment.resource_type resource).to eql 'Post'
+        end
+      end
+
+      context "when an undecorated object is passed" do
+        let(:resource) { post }
+
+        it "returns object class string" do
+          expect(ActiveAdmin::Comment.resource_type resource).to eql 'Post'
+        end
+      end
+    end
+
+    describe ".resource_id_type" do
+      it "should be :string" do
+        expect(ActiveAdmin::Comment.resource_id_type).to eql :string
+      end
+    end
+
+    describe "Commenting on resource with string id" do
+      let(:tag) { Tag.create!(name: "cooltags") }
+      let(:namespace_name) { "admin" }
+
+      it "should allow commenting" do
+        comment = ActiveAdmin::Comment.create!(
+          resource: tag,
+          body: "Another Comment",
+          namespace: namespace_name)
+
+        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(tag, namespace_name)).to eq [comment]
+      end
+    end
+
+    describe "commenting on child of STI resource" do
+      let(:publisher) { Publisher.create!(username: "tenderlove") }
+      let(:namespace_name) { "admin" }
+
+      it "should assign child class as commented resource" do
+        comment = ActiveAdmin::Comment.create!(
+          resource: publisher,
+          body: "Lorem Ipsum",
+          namespace: namespace_name)
+
+        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(publisher, namespace_name).last.resource_type).
+          to eq("User")
+      end
+    end
+  end
+
+  describe ActiveAdmin::Comments::NamespaceHelper do
+    describe "#comments?" do
+
+      it "should have comments when the namespace allows comments" do
+        ns = ActiveAdmin::Namespace.new(application, :admin)
+        ns.comments = true
+        expect(ns.comments?).to be_truthy
+      end
+
+      it "should not have comments when the namespace does not allow comments" do
+        ns = ActiveAdmin::Namespace.new(application, :admin)
+        ns.comments = false
+        expect(ns.comments?).to be_falsey
+      end
+    end
+  end
+
+  describe ActiveAdmin::Comments::ResourceHelper do
+    it "should add an attr_accessor :comments to ActiveAdmin::Resource" do
+      ns = ActiveAdmin::Namespace.new(application, :admin)
+      resource = ActiveAdmin::Resource.new(ns, Post)
+      expect(resource.comments).to be_nil
+      resource.comments = true
+      expect(resource.comments).to be_truthy
+    end
+    it "should disable comments if set to false" do
+      ns = ActiveAdmin::Namespace.new(application, :admin)
+      resource = ActiveAdmin::Resource.new(ns, Post)
+      resource.comments = false
+      expect(resource.comments?).to be_falsey
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/component_spec.rb

@@ -0,0 +1,18 @@
+require 'rails_helper'
+
+class MockComponentClass < ActiveAdmin::Component; end
+
+describe ActiveAdmin::Component do
+
+  let(:component_class){ MockComponentClass }
+  let(:component){ component_class.new }
+
+  it "should be a subclass of an html div" do
+    expect(ActiveAdmin::Component.ancestors).to include(Arbre::HTML::Div)
+  end
+
+  it "should render to a div, even as a subclass" do
+    expect(component.tag_name).to eq 'div'
+  end
+
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/config_shared_examples.rb

@@ -0,0 +1,59 @@
+shared_examples_for "ActiveAdmin::Resource" do
+  describe "namespace" do
+    it "should return the namespace" do
+      expect(config.namespace).to eq(namespace)
+    end
+  end
+
+  describe "page_presenters" do
+    it "should return an empty hash by default" do
+      expect(config.page_presenters).to eq({})
+    end
+  end
+
+  it { respond_to :controller_name }
+  it { respond_to :controller }
+  it { respond_to :route_prefix }
+  it { respond_to :route_collection_path }
+  it { respond_to :comments? }
+  it { respond_to :belongs_to? }
+  it { respond_to :action_items? }
+  it { respond_to :sidebar_sections? }
+
+  describe "Naming" do
+    it "implements #resource_label" do
+      expect { config.resource_label }.to_not raise_error
+    end
+
+    it "implements #plural_resource_label" do
+      expect { config.plural_resource_label }.to_not raise_error
+    end
+  end
+
+  describe "Menu" do
+    describe "#menu_item_options" do
+
+      it "initializes a new menu item with defaults" do
+          expect(config.menu_item_options[:label].call).to eq(config.plural_resource_label)
+      end
+
+      it "initialize a new menu item with custom options" do
+        config.menu_item_options = { label: "Hello" }
+        expect(config.menu_item_options[:label]).to eq("Hello")
+      end
+
+    end
+
+    describe "#include_in_menu?" do
+      it "should be included in menu by default" do
+        expect(config.include_in_menu?).to eq(true)
+      end
+
+      it "should not be included in menu when menu set to false" do
+        config.menu_item_options = false
+        expect(config.include_in_menu?).to eq(false)
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/controller_filters_spec.rb

@@ -0,0 +1,41 @@
+require 'rails_helper'
+
+describe ActiveAdmin::Application do
+  let(:application){ ActiveAdmin::Application.new }
+  let(:controllers){ application.controllers_for_filters }
+
+  it 'controllers_for_filters' do
+    expect(application.controllers_for_filters).to eq [
+      ActiveAdmin::BaseController, ActiveAdmin::Devise::SessionsController,
+      ActiveAdmin::Devise::PasswordsController, ActiveAdmin::Devise::UnlocksController,
+      ActiveAdmin::Devise::RegistrationsController, ActiveAdmin::Devise::ConfirmationsController
+    ]
+  end
+
+  expected_actions = (
+    prefixes = %w(skip append prepend) << nil
+    positions = %w(before around after)
+    suffixes = %w(filter)
+    base = %w(skip_filter)
+    if Rails::VERSION::MAJOR >= 4
+      suffixes += %w(action)
+      base += %w(skip_action_callback)
+    end
+
+    prefixes.each_with_object(base) do |prefix, stack|
+      positions.each do |position|
+        suffixes.each do |suffix|
+          stack << [prefix, position, suffix].compact.join("_").to_sym
+        end
+      end
+    end
+  )
+
+  expected_actions.each do |action|
+    it action do
+      args = [:my_filter, { only: :show }]
+      controllers.each { |c| expect(c).to receive(action).with(args) }
+      application.public_send action, args
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/csv_builder_spec.rb

@@ -0,0 +1,244 @@
+require 'rails_helper'
+
+describe ActiveAdmin::CSVBuilder do
+
+  describe '.default_for_resource using Post' do
+    let(:csv_builder) { ActiveAdmin::CSVBuilder.default_for_resource(Post).tap(&:exec_columns) }
+
+    it 'returns a default csv_builder for Post' do
+      expect(csv_builder).to be_a(ActiveAdmin::CSVBuilder)
+    end
+
+    it 'defines Id as the first column' do
+      expect(csv_builder.columns.first.name).to eq 'Id'
+      expect(csv_builder.columns.first.data).to eq :id
+    end
+
+    it "has Post's content_columns" do
+      csv_builder.columns[1..-1].each_with_index do |column, index|
+        expect(column.name).to eq Post.content_columns[index].name.humanize
+        expect(column.data).to eq Post.content_columns[index].name.to_sym
+      end
+    end
+
+    context 'when column has a localized name' do
+      let(:localized_name) { 'Titulo' }
+
+      before do
+        allow(Post).to receive(:human_attribute_name).and_call_original
+        allow(Post).to receive(:human_attribute_name).with(:title){ localized_name }
+      end
+
+      it 'gets name from I18n' do
+        title_index = Post.content_columns.map(&:name).index('title') + 1 # First col is always id
+        expect(csv_builder.columns[title_index].name).to eq localized_name
+      end
+    end
+  end
+
+  context 'when empty' do
+    let(:builder){ ActiveAdmin::CSVBuilder.new.tap(&:exec_columns) }
+
+    it "should have no columns" do
+      expect(builder.columns).to eq []
+    end
+  end
+
+  context "with a symbol column (:title)" do
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new do
+        column :title
+      end.tap(&:exec_columns)
+    end
+
+    it "should have one column" do
+      expect(builder.columns.size).to eq 1
+    end
+
+    describe "the column" do
+      let(:column){ builder.columns.first }
+
+      it "should have a name of 'Title'" do
+        expect(column.name).to eq "Title"
+      end
+
+      it "should have the data :title" do
+        expect(column.data).to eq :title
+      end
+    end
+  end
+
+  context "with a block and title" do
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new do
+        column "My title" do
+          # nothing
+        end
+      end.tap(&:exec_columns)
+    end
+
+    it "should have one column" do
+      expect(builder.columns.size).to eq 1
+    end
+
+    describe "the column" do
+      let(:column){ builder.columns.first }
+
+      it "should have a name of 'My title'" do
+        expect(column.name).to eq "My title"
+      end
+
+      it "should have the data :title" do
+        expect(column.data).to be_an_instance_of(Proc)
+      end
+    end
+  end
+
+  context "with a humanize_name column option" do
+    context "with symbol column name" do
+      let(:builder) do
+        ActiveAdmin::CSVBuilder.new do
+          column :my_title, humanize_name: false
+        end.tap(&:exec_columns)
+      end
+
+      describe "the column" do
+        let(:column){ builder.columns.first }
+
+        it "should have a name of 'my_title'" do
+          expect(column.name).to eq "my_title"
+        end
+      end
+    end
+
+    context "with string column name" do
+      let(:builder) do
+        ActiveAdmin::CSVBuilder.new do
+          column "my_title", humanize_name: false
+        end.tap(&:exec_columns)
+      end
+
+      describe "the column" do
+        let(:column){ builder.columns.first }
+
+        it "should have a name of 'my_title'" do
+          expect(column.name).to eq "my_title"
+        end
+      end
+    end
+  end
+
+  context "with a separator" do
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new(col_sep: ";").tap(&:exec_columns)
+    end
+
+    it "should have proper separator" do
+      expect(builder.options).to eq({col_sep: ";"})
+    end
+  end
+
+  context "with humanize_name option" do
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new(humanize_name: false) do
+        column :my_title
+      end.tap(&:exec_columns)
+    end
+
+    describe "the column" do
+      let(:column){ builder.columns.first }
+
+      it "should have humanize_name option set" do
+        expect(column.options).to eq humanize_name: false
+      end
+
+      it "should have a name of 'my_title'" do
+        expect(column.name).to eq "my_title"
+      end
+    end
+  end
+
+  context "with csv_options" do
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new(force_quotes: true).tap(&:exec_columns)
+    end
+
+    it "should have proper separator" do
+      expect(builder.options).to eq({force_quotes: true})
+    end
+  end
+
+  context "with access to the controller" do
+    let(:dummy_view_context) { double(controller: dummy_controller) }
+    let(:dummy_controller) { double(names: %w(title summary updated_at created_at))}
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new do
+        column "id"
+        controller.names.each do |name|
+          column(name)
+        end
+      end.tap{ |b| b.exec_columns(dummy_view_context) }
+    end
+
+    it "should build columns provided by the controller" do
+      expect(builder.columns.map(&:data)).to match_array([:id, :title, :summary, :updated_at, :created_at])
+    end
+  end
+
+  context "build csv using the supplied order" do
+    before do
+      @post1 = Post.create!(title: "Hello1", published_at: Date.today - 2.day )
+      @post2 = Post.create!(title: "Hello2", published_at: Date.today - 1.day )
+    end
+    let(:dummy_controller) {
+      class DummyController
+        def find_collection(*)
+          collection
+        end
+
+        def collection
+          Post.order('published_at DESC')
+        end
+
+        def apply_decorator(resource)
+          resource
+        end
+
+        def view_context
+        end
+      end
+      DummyController.new
+    }
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new do
+        column "id"
+        column "title"
+        column "published_at"
+      end
+    end
+
+    it "should generate data with the supplied order" do
+      expect(builder).to receive(:build_row).and_return([]).once.ordered { |post| expect(post.id).to eq @post2.id }
+      expect(builder).to receive(:build_row).and_return([]).once.ordered { |post| expect(post.id).to eq @post1.id }
+      builder.build dummy_controller, []
+    end
+
+    it "should generate data ignoring pagination" do
+      expect(dummy_controller).to receive(:find_collection).
+        with(except: :pagination).once.
+        and_call_original
+      expect(builder).to receive(:build_row).and_return([]).twice
+      builder.build dummy_controller, []
+    end
+
+  end
+
+  skip '#exec_columns'
+
+  skip '#build_row' do
+    it 'renders non-strings'
+    it 'encodes values correctly'
+    it 'passes custom encoding options to String#encode!'
+  end
+
+end