aa-rails4 0.6.0

data/spec/unit/view_helpers/display_name_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "display_name" do
+
+  include ActiveAdmin::ViewHelpers
+
+  [:display_name, :full_name, :name, :username, :login, :title, :email, :to_s].each do |m|
+    it "should return #{m} when defined" do
+      r = Class.new do
+        define_method m do
+          m.to_s
+        end
+      end.new
+      display_name(r).should == m.to_s
+    end
+  end
+
+  it "should memeoize the result for the class" do
+    subject { Class.new.new }
+    subject.should_receive(:name).twice.and_return "My Name"
+    display_name(subject).should == "My Name"
+    ActiveAdmin.application.should_not_receive(:display_name_methods)
+    display_name(subject).should == "My Name"
+  end
+
+  it "should not call a method if it's an association" do
+    subject { Class.new.new }
+    subject.stub_chain(:class, :reflect_on_all_associations).and_return [ mock(:name => :login) ]
+    subject.stub :login
+    subject.should_not_receive :login
+    subject.stub(:email).and_return 'foo@bar.baz'
+    display_name(subject).should == 'foo@bar.baz'
+  end
+
+  [nil, false].each do |type|
+    it "should return nil when the passed object is #{type.inspect}" do
+      display_name(type).should eq nil
+    end
+  end
+
+end

data/spec/unit/view_helpers/download_format_links_helper_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper do
+
+  describe "class methods" do
+    before :each do
+
+      begin
+        # The mime type to be used in respond_to |format| style web-services in rails
+        Mime::Type.register "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", :xlsx
+      rescue NameError
+        puts "Mime module not defined. Skipping registration of xlsx"
+      end
+
+      class Foo
+        include ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper
+      end
+    end
+
+    it "extends the class to add a formats class method that returns the default formats." do
+      Foo.formats.should == [:csv, :xml, :json]
+    end
+
+    it "does not let you alter the formats array directly" do
+      Foo.formats << :xlsx
+      Foo.formats.should == [:csv, :xml, :json]
+    end
+
+    it "allows us to add new formats" do
+      Foo.add_format :xlsx
+      Foo.formats.should == [:csv, :xml, :json, :xlsx]
+    end
+
+    it "raises an exception if you provide an unregisterd mime type extension" do
+      expect{ Foo.add_format :hoge }.to raise_error
+    end
+
+  end
+end

data/spec/unit/view_helpers/fields_for_spec.rb

@@ -0,0 +1,50 @@
+require 'active_admin/view_helpers/fields_for'
+
+describe ActiveAdmin::ViewHelpers::FormHelper, ".fields_for" do
+  include ActiveAdmin::ViewHelpers::FormHelper
+
+  it "should skip :action, :controller and :commit" do
+    fields_for_params(
+      :scope => "All", :action => "index", :controller => "PostController", :commit => "Filter", :utf8 => "Yes!").
+      should == [ { :scope => "All" } ]
+  end
+
+  it "should skip the except" do
+    fields_for_params({:scope => "All", :name => "Greg"}, :except => :name).
+      should == [ { :scope => "All" } ]
+  end
+
+  it "should allow an array for the except" do
+    fields_for_params({:scope => "All", :name => "Greg", :age => "12"}, :except => [:name, :age]).
+      should == [ { :scope => "All" } ]
+  end
+
+  it "should work with hashes" do
+    params = fields_for_params(:filters => { :name => "John", :age => "12" })
+
+    params.size.should == 2
+    params.should include({"filters[name]" => "John" })
+    params.should include({ "filters[age]" => "12" })
+  end
+
+  it "should work with nested hashes" do
+    fields_for_params(:filters => { :user => { :name => "John" }}).
+      should == [ { "filters[user][name]" => "John" } ]
+  end
+
+  it "should work with arrays" do
+    fields_for_params(:people => ["greg", "emily", "philippe"]).
+      should == [ { "people[]" => "greg" },
+                  { "people[]" => "emily" },
+                  { "people[]" => "philippe" } ]
+  end
+
+  it "should work with symbols" do
+    fields_for_params(:filter => :id).
+      should == [ { :filter => "id" } ]
+  end
+
+  it "should work with booleans" do
+    fields_for_params(:booleantest => false).should == [ { :booleantest => false } ]
+  end
+end

data/spec/unit/view_helpers/form_helper_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe ActiveAdmin::ViewHelpers::FormHelper do
+
+  describe '.active_admin_form_for' do
+    let(:view) { action_view }
+    let(:resource) { stub('resource') }
+    let(:default_options) { { builder: ActiveAdmin::FormBuilder } }
+
+    it 'calls semantic_form_for with the ActiveAdmin form builder' do
+      view.should_receive(:semantic_form_for).with(resource, builder: ActiveAdmin::FormBuilder)
+      view.active_admin_form_for(resource)
+    end
+
+    it 'allows the form builder to be customized' do
+      # We can't use a stub here because options gets marshalled, and a new
+      # instance built. Any constant will work.
+      custom_builder = Object
+      view.should_receive(:semantic_form_for).with(resource, builder: custom_builder)
+      view.active_admin_form_for(resource, builder: custom_builder)
+    end
+
+    context 'with a decorated resource' do
+      let(:decorated) { stub('decorated_resource', model: resource) }
+
+      it 'can disable automatic decoration' do
+        view.should_receive(:semantic_form_for).with(resource, default_options.merge(decorate: false))
+        view.active_admin_form_for(decorated, decorate: false)
+      end
+
+      it 'can enable automatic decoration' do
+        view.should_receive(:semantic_form_for).with(decorated, default_options.merge(decorate: true))
+        view.active_admin_form_for(decorated, decorate: true)
+      end
+    end
+  end
+
+  describe ".hidden_field_tags_for" do
+    let(:view) { action_view }
+
+    it "should render hidden field tags for params" do
+      view.hidden_field_tags_for(:scope => "All", :filter => "None").should ==
+        %{<input id="hidden_active_admin_scope" name="scope" type="hidden" value="All" />\n<input id="hidden_active_admin_filter" name="filter" type="hidden" value="None" />}
+    end
+
+    it "should generate not default id for hidden input" do
+      view.hidden_field_tags_for(:scope => "All")[/id="([^"]+)"/, 1].should_not == "scope"
+    end
+
+    it "should filter out the field passed via the option :except" do
+      view.hidden_field_tags_for({:scope => "All", :filter => "None"}, :except => :filter).should ==
+        %{<input id="hidden_active_admin_scope" name="scope" type="hidden" value="All" />}
+    end
+  end
+end
+

data/spec/unit/view_helpers/method_or_proc_helper_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe MethodOrProcHelper do
+  let(:receiver) { mock }
+
+  let(:context) do
+    obj = mock(: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
+      context.call_method_or_exec_proc(:receiver_in_context).
+        should == receiver
+    end
+
+    it "should call the method in the context when a string" do
+      context.call_method_or_exec_proc("receiver_in_context").
+        should == 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
+
+    context "when a symbol" do
+
+      it 'should call the method on the receiver' do
+        receiver.should_receive(:hello).and_return("hello")
+
+        context.call_method_or_proc_on(receiver, "hello").
+          should == "hello"
+      end
+
+      it "should receive additional arguments" do
+        receiver.should_receive(:hello).with("world").and_return("hello world")
+
+        context.call_method_or_proc_on(receiver, :hello, "world").
+          should == "hello world"
+      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 = mock
+
+        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
+
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Views::ActionListPopover do
+
+  let(:the_popover) do
+    arbre {
+      action_list_popover :id => "my_awesome_action_list_popover" do
+        action "My First Great Action", "#"
+        action "My Second Great Action", "http://www.google.com"
+      end
+    }.children.first
+  end
+
+  it "should have an id" do
+    the_popover.id.should == "my_awesome_action_list_popover"
+  end
+
+  describe "the action list" do
+    subject do
+      the_popover.find_by_class("popover_contents").first
+    end
+
+    its(:tag_name) { should eql("ul") }
+
+    its(:content){ should include("<li><a href=\"#\">My First Great Action</a></li>") }
+    its(:content){ should include("<li><a href=\"http://www.google.com\">My Second Great Action</a></li>") }
+
+  end
+
+end

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

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+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
+      post.stub!(:id){ 1 }
+      post.stub!(: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
+          table.tag_name.should == 'div'
+          table.attr(:class).should include('attributes_table')
+        end
+
+        it "should add id and type class" do
+          table.class_names.should include("post")
+          table.id.should == "attributes_table_post_1"
+        end
+
+        it "should render 3 rows" do
+          table.find_by_tag("tr").size.should == 3
+        end
+
+        describe "rendering the rows" do
+          [
+            ["Id" , "1"],
+            ["Title" , "Hello World"],
+            ["Body" , "<span class=\"empty\">Empty</span>"]
+          ].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
+                current_row.find_by_tag("th").first.content.should == title
+              end
+              it "should have the content '#{set[1]}'" do
+                current_row.find_by_tag("td").first.content.chomp.strip.should == content
+              end
+            end
+          end
+        end # describe rendering rows
+
+      end
+    end # describe dsl styles
+
+    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
+      }
+      table.find_by_tag("tr").first.to_s.
+        split("\n").first.lstrip.
+          should == '<tr class="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
+      }
+      table.find_by_tag("td").first.content.chomp.strip.should == "<span class=\"id\">1</span>"
+    end
+
+    it "should check if an association exists when an attribute has id in it" do
+      post.author = User.new :username => 'john_doe', :first_name => 'John', :last_name => 'Doe'
+      table = render_arbre_component(assigns) {
+        attributes_table_for post, :author_id
+      }
+      table.find_by_tag('td').first.content.should == 'John Doe'
+    end
+
+  end
+
+end