andrewroth_activeadmin 0.3.4

data/spec/integration/belongs_to_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe_with_capybara "Belongs To" do
+
+  let(:user){ User.create(:first_name => "John", :last_name => "Doe", :username => "johndoe") }
+  let(:post){ user.posts.create :title => "Hello World", :body => "woot!"}
+
+  before do
+    # Make sure both are created
+    user
+    post
+  end
+
+  describe "the index page" do
+    before do
+      visit admin_user_posts_path(user)
+    end
+
+    describe "the main content" do
+      it "should display the default table" do
+        page.should have_content(post.title)
+      end
+    end
+
+    describe "the breadcrumb" do
+      it "should have a link to the parent's index" do
+        page.body.should have_tag("a", "Users", :attributes => { :href => "/admin/users" })
+      end
+      it "should have a link to the parent" do
+        page.body.should have_tag("a", user.id.to_s, :attributes => { :href => "/admin/users/#{user.id}" })
+      end
+    end
+
+    describe "the view links" do
+      it "should take you to the sub resource" do
+        click_link "View"
+        current_path.should == "/admin/users/#{user.id}/posts/#{post.id}"
+      end
+    end
+  end
+
+end

data/spec/integration/default_namespace.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Application do
+
+  include Rails.application.routes.url_helpers
+
+  [false, nil].each do |value|
+
+    describe "with a #{value} default namespace" do
+
+      before(:all) do
+        @__original_application = ActiveAdmin.application
+        application = ActiveAdmin::Application.new
+        application.default_namespace = value
+        ActiveAdmin.application = application
+        load_defaults!
+        reload_routes!
+      end
+
+      after(:all) do
+        ActiveAdmin.application = @__original_application
+      end
+
+      it "should generate a dashboard controller" do
+        defined?(::DashboardController).should be_true
+      end
+
+      it "should generate a dashboard route" do
+        dashboard_path.should == "/"
+      end
+
+      it "should generate a log out path" do
+        destroy_admin_user_session_path.should == "/admin_users/logout"
+      end
+
+      it "should generate a log in path" do
+        new_admin_user_session_path.should == "/admin_users/login"
+      end
+
+    end
+
+  end
+
+    describe "with a test default namespace" do
+
+      before(:all) do
+        @__original_application = ActiveAdmin.application
+        application = ActiveAdmin::Application.new
+        application.default_namespace = :test
+        ActiveAdmin.application = application
+        load_defaults!
+        reload_routes!
+      end
+
+      after(:all) do
+        ActiveAdmin.application = @__original_application
+      end
+
+      it "should generate a dashboard controller" do
+        defined?(::Test::DashboardController).should be_true
+      end
+
+      it "should generate a dashboard route" do
+        test_dashboard_path.should == "/test"
+      end
+
+      it "should generate a log out path" do
+        destroy_admin_user_session_path.should == "/test/logout"
+      end
+
+      it "should generate a log in path" do
+        new_admin_user_session_path.should == "/test/login"
+      end
+
+    end
+
+end

data/spec/integration/javascript_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'jslint'
+
+%x[which java]
+if $? == 0 # Only run the JS Lint test if Java is installed
+  describe "Javascript" do
+    before do
+      @lint = JSLint::Lint.new(
+        :paths => ['public/javascripts/**/*.js'],
+        :exclude_paths => ['public/javascripts/vendor/**/*.js'],
+        :config_path => 'spec/support/jslint.yml'
+      )
+    end
+
+    it "should not have any syntax errors" do
+      @lint.run
+    end
+  end
+end
+

data/spec/integration/memory_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+# These tests show the memory leak that is currently in Active Admin. They
+# are all marked as pending until they pass. To work on them, comment out the
+# pending method call in #it_should_not_leak
+describe "Memory Leak" do
+
+  def count_instances_of(klass)
+    count = 0
+
+    ObjectSpace.each_object do |o|
+      if o.class == klass
+        count += 1
+      end
+    end
+
+    count
+  end
+
+  def self.it_should_not_leak(klass)
+    it "should not leak #{klass}" do
+      pending
+
+      GC.start
+
+      count = count_instances_of(klass)
+
+      load_defaults!
+      GC.start
+
+      count_instances_of(klass).should == count
+    end
+  end
+
+  it_should_not_leak ActiveAdmin::Namespace
+  it_should_not_leak ActiveAdmin::Resource
+
+end

data/spec/integration/stylesheets_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "Stylesheets" do
+  if Rails.version[0..2] == '3.1'
+    require "sprockets"
+    context "when Rails 3.1.x" do
+      let(:css) do
+        assets = Rails.application.assets
+        assets.find_asset("active_admin.css")
+      end
+      it "should successfully render the scss stylesheets using sprockets" do
+        css.should_not be_nil
+      end
+      it "should not have any syntax errors" do
+        css.to_s.should_not include("Syntax error:")
+      end
+    end
+  end
+
+  if Rails.version[0..2] == '3.0'
+    context "when Rails 3.0.x" do
+      let(:stylesheet_path) do
+        Rails.root + 'public/stylesheets/active_admin.css'
+      end
+
+      before do
+        "rm #{stylesheet_path}" if File.exists?(stylesheet_path)
+        Sass::Plugin.force_update_stylesheets
+      end
+
+      it "should render the scss stylesheets using SASS" do
+        File.exists?(stylesheet_path).should be_true
+      end
+
+      it "should not have any syntax errors" do
+        css = File.read(stylesheet_path)
+        css.should_not include("Syntax error:")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,167 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH << File.expand_path('../support', __FILE__)
+
+ENV['BUNDLE_GEMFILE'] = File.expand_path('../../Gemfile', __FILE__)
+
+require 'detect_rails_version'
+ENV['RAILS'] = detect_rails_version
+
+require "bundler"
+Bundler.setup
+
+require 'shoulda/active_record'
+include Shoulda::ActiveRecord::Macros
+
+module ActiveAdminIntegrationSpecHelper
+  extend self
+
+  def load_defaults!
+    ActiveAdmin.unload!
+    ActiveAdmin.load!
+    ActiveAdmin.register(Category)
+    ActiveAdmin.register(User)
+    ActiveAdmin.register(Post){ belongs_to :user, :optional => true }
+    reload_menus!
+  end
+
+  def reload_menus!
+    ActiveAdmin.application.namespaces.values.each{|n| n.load_menu! }
+  end
+
+  # Sometimes we need to reload the routes within
+  # the application to test them out
+  def reload_routes!
+    Rails.application.reload_routes!
+  end
+
+  # Helper method to load resources and ensure that Active Admin is
+  # setup with the new configurations.
+  #
+  # Eg:
+  #   load_resources do
+  #     ActiveAdmin.regiser(Post)
+  #   end
+  #
+  def load_resources
+    ActiveAdmin.unload!
+    yield
+    reload_menus!
+    reload_routes!
+  end
+
+  # Sets up a describe block where you can render controller 
+  # actions. Uses the Admin::PostsController as the subject
+  # for the describe block
+  def describe_with_render(*args, &block)
+    describe *args do
+      include RSpec::Rails::ControllerExampleGroup
+      render_views  
+      # metadata[:behaviour][:describes] = ActiveAdmin.namespaces[:admin].resources['Post'].controller
+      module_eval &block
+    end
+  end
+
+  # Sets up an Arbre::Builder context
+  def setup_arbre_context!
+    include Arbre::Builder
+    let(:assigns){ {} }
+    let(:helpers){ mock_action_view }
+    before do
+      @_helpers = helpers
+    end
+  end
+
+  # Setup a describe block which uses capybara and rails integration
+  # test methods.
+  def describe_with_capybara(*args, &block)
+    describe *args do
+      include RSpec::Rails::IntegrationExampleGroup
+      module_eval &block
+    end
+  end
+
+  # Returns a fake action view instance to use with our renderers
+  def mock_action_view(assigns = {})
+    controller = ActionView::TestCase::TestController.new
+    ActionView::Base.send :include, ActionView::Helpers
+    ActionView::Base.send :include, ActiveAdmin::ViewHelpers
+    ActionView::Base.send :include, Rails.application.routes.url_helpers
+    ActionView::Base.new(ActionController::Base.view_paths, assigns, controller)
+  end  
+  alias_method :action_view, :mock_action_view
+
+end
+
+ENV['RAILS_ENV'] = 'test'
+ENV['RAILS_ROOT'] = File.expand_path("../rails/rails-#{ENV["RAILS"]}", __FILE__)
+
+# Create the test app if it doesn't exists
+unless File.exists?(ENV['RAILS_ROOT'])
+  system 'rake setup'
+end
+
+# Ensure the Active Admin load path is happy
+require 'rails'
+require 'active_admin'
+ActiveAdmin.application.load_paths = [ENV['RAILS_ROOT'] + "/app/admin"]
+
+require ENV['RAILS_ROOT'] + '/config/environment'
+require 'rspec/rails'
+
+# Setup Some Admin stuff for us to play with
+include ActiveAdminIntegrationSpecHelper
+load_defaults!
+reload_routes!
+
+# Disabling authentication in specs so that we don't have to worry about
+# it allover the place
+ActiveAdmin.application.authentication_method = false
+ActiveAdmin.application.current_user_method = false
+
+# Don't add asset cache timestamps. Makes it easy to integration
+# test for the presence of an asset file
+ENV["RAILS_ASSET_ID"] = ''
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.use_instantiated_fixtures = false
+end
+
+# All RSpec configuration needs to happen before any examples
+# or else it whines.
+require 'integration_example_group'
+RSpec.configure do |c|
+  c.include RSpec::Rails::IntegrationExampleGroup, :example_group => { :file_path => /\bspec\/integration\// }
+end
+
+# Ensure this is defined for Ruby 1.8
+module MiniTest; class Assertion < Exception; end; end
+
+RSpec::Matchers.define :have_tag do |*args|
+
+  match_unless_raises Test::Unit::AssertionFailedError do |response|
+    tag = args.shift
+    content = args.first.is_a?(Hash) ? nil : args.shift
+    
+    options = {
+      :tag => tag.to_s
+    }.merge(args[0] || {})
+    
+    options[:content] = content if content
+
+    begin
+      begin
+        assert_tag(options)
+      rescue NoMethodError
+        # We are not in a controller, so let's do the checking ourselves
+        doc = HTML::Document.new(response, false, false)
+        tag = doc.find(options)
+        assert tag, "expected tag, but no tag found matching #{options.inspect} in:\n#{response.inspect}"
+      end
+    # In Ruby 1.9, MiniTest::Assertion get's raised, so we'll
+    # handle raising a Test::Unit::AssertionFailedError
+    rescue MiniTest::Assertion => e
+      raise Test::Unit::AssertionFailedError, e.message
+    end
+  end
+end

data/spec/support/detect_rails_version.rb

@@ -0,0 +1,10 @@
+# Detects the current version of Rails that is being used
+#
+# You can pass it in as an ENV variable or it will use
+# the current Gemfile.lock to find it
+def detect_rails_version
+  return nil unless (File.exists?("Gemfile.lock") || File.symlink?("Gemfile.lock"))
+
+  File.read("Gemfile.lock").match(/^\W*rails \(([a-z\d.]*)\)/)
+  return $1
+end

data/spec/support/integration_example_group.rb

@@ -0,0 +1,33 @@
+require 'action_dispatch'
+require 'capybara/rails'
+require 'capybara/dsl'
+
+module RSpec
+  module Rails
+    module IntegrationExampleGroup
+      extend ActiveSupport::Concern
+
+      include ActionDispatch::Integration::Runner
+      include RSpec::Rails::TestUnitAssertionAdapter
+      include ActionDispatch::Assertions
+      include Capybara::DSL
+      include RSpec::Matchers
+
+      module InstanceMethods
+        def app
+          ::Rails.application
+        end
+
+        def last_response
+          page
+        end
+      end
+
+      included do
+        before do
+          @router = ::Rails.application.routes
+        end
+      end
+    end
+  end
+end

data/spec/support/jslint.yml

@@ -0,0 +1,80 @@
+# ------------ rake task options ------------
+
+# JS files to check by default, if no parameters are passed to rake jslint
+# (you may want to limit this only to your own scripts and exclude any external scripts and frameworks)
+
+# this can be overridden by adding 'paths' and 'exclude_paths' parameter to rake command:
+#   rake jslint paths=path1,path2,... exclude_paths=library1,library2,...
+
+paths:
+  - app/assets/javascripts/active_admin/**/*.js
+
+exclude_paths:
+  - app/assets/javascripts/active_admin/vendor.js
+
+# ------------ jslint options ------------
+# see http://www.jslint.com/lint.html#options for more detailed explanations
+
+# "enforce" type options (true means potentially more warnings)
+
+adsafe:   false     # true if ADsafe rules should be enforced. See http://www.ADsafe.org/
+bitwise:  true      # true if bitwise operators should not be allowed
+newcap:   true      # true if Initial Caps must be used with constructor functions
+eqeqeq:   false     # true if === should be required (for ALL equality comparisons)
+immed:    false     # true if immediate function invocations must be wrapped in parens
+nomen:    false     # true if initial or trailing underscore in identifiers should be forbidden
+onevar:   false     # true if only one var statement per function should be allowed
+plusplus: false     # true if ++ and -- should not be allowed
+regexp:   false     # true if . and [^...] should not be allowed in RegExp literals
+safe:     false     # true if the safe subset rules are enforced (used by ADsafe)
+strict:   false     # true if the ES5 "use strict"; pragma is required
+undef:    false     # true if variables must be declared before used
+white:    false     # true if strict whitespace rules apply (see also 'indent' option)
+
+# "allow" type options (false means potentially more warnings)
+
+cap:      false     # true if upper case HTML should be allowed
+css:      true      # true if CSS workarounds should be tolerated
+debug:    false     # true if debugger statements should be allowed (set to false before going into production)
+es5:      false     # true if ECMAScript 5 syntax should be allowed
+evil:     false     # true if eval should be allowed
+forin:    true      # true if unfiltered 'for in' statements should be allowed
+fragment: true      # true if HTML fragments should be allowed
+laxbreak: false     # true if statement breaks should not be checked
+on:       false     # true if HTML event handlers (e.g. onclick="...") should be allowed
+sub:      false     # true if subscript notation may be used for expressions better expressed in dot notation
+
+# other options
+
+maxlen:   300       # Maximum line length
+indent:   2         # Number of spaces that should be used for indentation - used only if 'white' option is set
+maxerr:   50        # The maximum number of warnings reported (per file)
+passfail: false     # true if the scan should stop on first error (per file)
+# following are relevant only if undef = true
+predef:   ''        # Names of predefined global variables - comma-separated string or a YAML array
+browser:  true      # true if the standard browser globals should be predefined
+rhino:    false     # true if the Rhino environment globals should be predefined
+windows:  false     # true if Windows-specific globals should be predefined
+widget:   false     # true if the Yahoo Widgets globals should be predefined
+devel:    true      # true if functions like alert, confirm, console, prompt etc. are predefined
+
+
+# ------------ jslint_on_rails custom lint options (switch to true to disable some annoying warnings) ------------
+
+# ignores "missing semicolon" warning at the end of a function; this lets you write one-liners
+# like: x.map(function(i) { return i + 1 }); without having to put a second semicolon inside the function
+lastsemic: false
+
+# allows you to use the 'new' expression as a statement (without assignment)
+# so you can call e.g. new Ajax.Request(...), new Effect.Highlight(...) without assigning to a dummy variable
+newstat: false
+
+# ignores the "Expected an assignment or function call and instead saw an expression" warning,
+# if the expression contains a proper statement and makes sense; this lets you write things like:
+#    element && element.show();
+#    valid || other || lastChance || alert('OMG!');
+#    selected ? show() : hide();
+# although these will still cause a warning:
+#    element && link;
+#    selected ? 5 : 10;
+statinexp: false