yousty-activeadmin 1.0.4.pre → 1.0.5.pre

data/spec/unit/view_helpers/display_name_spec.rb

@@ -1,40 +1,68 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe "display_name" do
 
   include ActiveAdmin::ViewHelpers
 
-  [:display_name, :full_name, :name, :username, :login, :title, :email, :to_s].each do |m|
+  ActiveAdmin::Application.new.display_name_methods.map(&: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 eq m.to_s
+      klass = Class.new do
+        define_method(m) { m }
+      end
+      expect(display_name klass.new).to eq m
     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 eq "My Name"
-    ActiveAdmin.application.should_not_receive(:display_name_methods)
-    display_name(subject).should eq "My Name"
+  it "should memoize the result for the class" do
+    subject = Class.new.new
+    expect(subject).to receive(:name).twice.and_return "My Name"
+    expect(display_name subject).to eq "My Name"
+    expect(ActiveAdmin.application).to_not receive(:display_name_methods)
+    expect(display_name subject).to eq "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 [ double(name: :login) ]
-    subject.stub :login
-    subject.should_not_receive :login
-    subject.stub(:email).and_return 'foo@bar.baz'
-    display_name(subject).should eq 'foo@bar.baz'
+    klass = Class.new
+    subject = klass.new
+    allow(klass).to receive(:reflect_on_all_associations).and_return [ double(name: :login) ]
+    allow(subject).to receive :login
+    expect(subject).to_not receive :login
+    allow(subject).to receive(:email).and_return 'foo@bar.baz'
+    expect(display_name subject).to eq '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
+      expect(display_name type).to eq nil
+    end
+  end
+
+  it "should default to `to_s`" do
+    subject = Class.new.new
+    expect(display_name subject).to eq subject.to_s
+  end
+
+  context "when no display name method is defined" do
+    context "on a Rails model" do
+      it "should show the model name" do
+        class ThisModel
+          extend ActiveModel::Naming
+        end
+        subject = ThisModel.new
+        expect(display_name subject).to eq "This model"
+      end
+
+      it "should show the model name, plus the ID if in use" do
+        subject = Tagging.create!
+        expect(display_name subject).to eq "Tagging #1"
+      end
+
+      it "should translate the model name" do
+        with_translation activerecord: {models: {tagging: {one: "Different"}}} do
+          subject = Tagging.create!
+          expect(display_name subject).to eq "Different #1"
+        end
+      end
     end
   end
 

data/spec/unit/view_helpers/download_format_links_helper_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper do
 
   describe "class methods" do
-    before :each do
+    before :all do
 
       begin
         # The mime type to be used in respond_to |format| style web-services in rails
@@ -18,17 +18,17 @@ describe ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper do
     end
 
     it "extends the class to add a formats class method that returns the default formats." do
-      Foo.formats.should == [:csv, :xml, :json]
+      expect(Foo.formats).to eq [:csv, :xml, :json]
     end
 
     it "does not let you alter the formats array directly" do
       Foo.formats << :xlsx
-      Foo.formats.should == [:csv, :xml, :json]
+      expect(Foo.formats).to eq [:csv, :xml, :json]
     end
 
     it "allows us to add new formats" do
       Foo.add_format :xlsx
-      Foo.formats.should == [:csv, :xml, :json, :xlsx]
+      expect(Foo.formats).to eq [:csv, :xml, :json, :xlsx]
     end
 
     it "raises an exception if you provide an unregisterd mime type extension" do

data/spec/unit/view_helpers/fields_for_spec.rb

@@ -4,47 +4,47 @@ 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" } ]
+    expect(fields_for_params(
+      scope: "All", action: "index", controller: "PostController", commit: "Filter", utf8: "Yes!")).
+      to eq [ { scope: "All" } ]
   end
 
   it "should skip the except" do
-    fields_for_params({:scope => "All", :name => "Greg"}, :except => :name).
-      should == [ { :scope => "All" } ]
+    expect(fields_for_params({scope: "All", name: "Greg"}, except: :name)).
+      to eq [ { 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" } ]
+    expect(fields_for_params({scope: "All", name: "Greg", age: "12"}, except: [:name, :age])).
+      to eq [ { scope: "All" } ]
   end
 
   it "should work with hashes" do
-    params = fields_for_params(:filters => { :name => "John", :age => "12" })
+    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" })
+    expect(params.size).to eq 2
+    expect(params).to include({"filters[name]" => "John" })
+    expect(params).to include({ "filters[age]" => "12" })
   end
 
   it "should work with nested hashes" do
-    fields_for_params(:filters => { :user => { :name => "John" }}).
-      should == [ { "filters[user][name]" => "John" } ]
+    expect(fields_for_params(filters: { user: { name: "John" }})).
+      to eq [ { "filters[user][name]" => "John" } ]
   end
 
   it "should work with arrays" do
-    fields_for_params(:people => ["greg", "emily", "philippe"]).
-      should == [ { "people[]" => "greg" },
+    expect(fields_for_params(people: ["greg", "emily", "philippe"])).
+      to eq [ { "people[]" => "greg" },
                   { "people[]" => "emily" },
                   { "people[]" => "philippe" } ]
   end
 
   it "should work with symbols" do
-    fields_for_params(:filter => :id).
-      should == [ { :filter => "id" } ]
+    expect(fields_for_params(filter: :id)).
+      to eq [ { filter: "id" } ]
   end
 
   it "should work with booleans" do
-    fields_for_params(:booleantest => false).should == [ { :booleantest => false } ]
+    expect(fields_for_params(booleantest: false)).to eq [ { booleantest: false } ]
   end
 end

data/spec/unit/view_helpers/flash_helper_spec.rb

@@ -0,0 +1,25 @@
+require 'rails_helper'
+
+describe ActiveAdmin::ViewHelpers::FlashHelper do
+
+  describe '.flash_messages' do
+    let(:view) { action_view }
+
+    it "should not include 'timedout' flash messages by default" do
+      view.request.flash[:alert] = "Alert"
+      view.request.flash[:timedout] = true
+      expect(view.flash_messages).to include 'alert'
+      expect(view.flash_messages).to_not include 'timedout'
+    end
+
+    it "should not return flash messages included in flash_keys_to_except" do
+      expect(view.active_admin_application).to receive(:flash_keys_to_except).and_return ["hideme"]
+      view.request.flash[:alert] = "Alert"
+      view.request.flash[:hideme] = "Do not show"
+      expect(view.flash_messages).to include 'alert'
+      expect(view.flash_messages).to_not include 'hideme'
+    end
+
+  end
+end
+

data/spec/unit/view_helpers/form_helper_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::ViewHelpers::FormHelper do
 
@@ -8,7 +8,7 @@ describe ActiveAdmin::ViewHelpers::FormHelper do
     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)
+      expect(view).to receive(:semantic_form_for).with(resource, builder: ActiveAdmin::FormBuilder)
       view.active_admin_form_for(resource)
     end
 
@@ -16,40 +16,27 @@ describe ActiveAdmin::ViewHelpers::FormHelper 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)
+      expect(view).to 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) { double '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" />}
+      html = Capybara.string view.hidden_field_tags_for(scope: "All", filter: "None")
+      expect(html).to have_selector("input#hidden_active_admin_scope[name=scope][type=hidden][value=All]")
+      expect(html).to have_selector("input#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"
+      expect(view.hidden_field_tags_for(scope: "All")[/id="([^"]+)"/, 1]).to_not eq "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" />}
+      html = Capybara.string view.hidden_field_tags_for({scope: "All", filter: "None"}, except: :filter)
+      expect(html).to have_selector("input#hidden_active_admin_scope[name=scope][type=hidden][value=All]")
     end
   end
 end

data/spec/unit/view_helpers/method_or_proc_helper_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe MethodOrProcHelper do
   let(:receiver) { double }
@@ -12,13 +12,11 @@ describe MethodOrProcHelper do
   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
+      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
-      context.call_method_or_exec_proc("receiver_in_context").
-        should == receiver
+      expect(context.call_method_or_exec_proc("receiver_in_context")).to eq receiver
     end
 
     it "should exec a proc in the context" do
@@ -33,22 +31,20 @@ describe MethodOrProcHelper do
 
   describe "#call_method_or_proc_on" do
 
-    context "when a symbol" 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'
 
-      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
+          expect(context.call_method_or_proc_on(receiver, key)).to eq 'hello'
+        end
 
-      it "should receive additional arguments" do
-        receiver.should_receive(:hello).with("world").and_return("hello world")
+        it "should receive additional arguments" do
+          expect(receiver).to receive(key).with(:world).and_return 'hello world'
 
-        context.call_method_or_proc_on(receiver, :hello, "world").
-          should == "hello world"
+          expect(context.call_method_or_proc_on(receiver, key, :world)).to eq 'hello world'
+        end
       end
-
     end
 
     context "when a proc" do
@@ -75,7 +71,7 @@ describe MethodOrProcHelper do
 
     end
 
-    context "when a proc and :exec => false" do
+    context "when a proc and exec: false" do
 
       it "should call the proc and pass in the receiver" do
         obj_not_in_context = double
@@ -85,7 +81,7 @@ describe MethodOrProcHelper do
         end
 
         expect {
-          context.call_method_or_proc_on(receiver,test_proc, :exec => false)
+          context.call_method_or_proc_on(receiver,test_proc, exec: false)
         }.to raise_error("Success!")
       end
 
@@ -94,8 +90,50 @@ describe MethodOrProcHelper do
 
   end
 
-  pending "#render_or_call_method_or_proc_on"
+  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
 
-  pending "#render_in_context"
+  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/action_list_popover_spec.rb

@@ -1,10 +1,10 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::Views::ActionListPopover do
 
   let(:the_popover) do
     arbre {
-      action_list_popover :id => "my_awesome_action_list_popover" do
+      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
@@ -12,7 +12,7 @@ describe ActiveAdmin::Views::ActionListPopover do
   end
 
   it "should have an id" do
-    the_popover.id.should == "my_awesome_action_list_popover"
+    expect(the_popover.id).to eq "my_awesome_action_list_popover"
   end
 
   describe "the action list" do
@@ -20,10 +20,20 @@ describe ActiveAdmin::Views::ActionListPopover do
       the_popover.find_by_class("popover_contents").first
     end
 
-    its(:tag_name) { should eql("ul") }
+    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("<li><a href=\"#\">My First Great Action</a></li>") }
+    end
 
-    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>") }
+    describe '#content' do
+      subject { super().content }
+      it{ is_expected.to include("<li><a href=\"http://www.google.com\">My Second Great Action</a></li>") }
+    end
 
   end