activeadministration 0.0.1

data/spec/unit/views/pages/form_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe ActiveAdmin::Views::Pages::Form do
+  describe "#title" do
+    let!(:application){ ActiveAdmin::Application.new }
+    let(:namespace){ ActiveAdmin::Namespace.new(application, "Admin") }
+    let!(:params){ { controller: "UsersController", action: "edit" } }
+    let(:helpers) do
+      helpers = mock_action_view
+      helpers.stub active_admin_config: namespace.register(Post),
+                   params: params
+
+      helpers
+    end
+
+    let(:arbre_context) do
+      OpenStruct.new(params: params, helpers: helpers, assigns: {})
+    end
+
+    context "when page_title is assigned" do
+      it "should show the set page title" do
+        arbre_context.assigns[:page_title] = "My Page Title"
+        page = ActiveAdmin::Views::Pages::Form.new(arbre_context)
+        expect(page.title).to eq "My Page Title"
+      end
+    end
+
+    context "when page_title is not assigned" do
+      it "should show the correct I18n text" do
+        page = ActiveAdmin::Views::Pages::Form.new(arbre_context)
+        expect(page.title).to eq "Edit Post"
+      end
+    end
+  end
+end

data/spec/unit/views/pages/layout_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Views::Pages::Layout do
+
+  let(:assigns){ {} }
+  let(:helpers) do
+    helpers = mock_action_view
+
+    helpers.stub active_admin_application: active_admin_application,
+                 active_admin_config: double('Config', action_items?: nil, breadcrumb: nil, sidebar_sections?: nil),
+                 active_admin_namespace: active_admin_namespace,
+                 breadcrumb_links: [],
+                 content_for: "",
+                 csrf_meta_tag: "",
+                 current_active_admin_user: nil,
+                 :current_active_admin_user? => false,
+                 current_menu: double('Menu', items: []),
+                 flash: {},
+                 javascript_path: "/dummy/",
+                 link_to: "",
+                 render_or_call_method_or_proc_on: "",
+                 stylesheet_link_tag: double(html_safe: ""),
+                 view_factory: view_factory,
+                 params: {controller: 'UsersController', action: 'edit'}
+
+    helpers
+  end
+
+  let(:active_admin_namespace){ ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :myspace) }
+  let(:active_admin_application){ ActiveAdmin.application }
+  let(:view_factory) { ActiveAdmin::ViewFactory.new }
+
+  let(:layout) do
+    render_arbre_component assigns, helpers do
+      insert_tag ActiveAdmin::Views::Pages::Layout
+    end
+  end
+
+  it "should be the @page_title if assigned in the controller" do
+    assigns[:page_title] = "My Page Title"
+
+    expect(layout.title).to eq "My Page Title"
+  end
+
+  it "should be the default translation" do
+    helpers.params[:action] = "edit"
+
+    expect(layout.title).to eq "Edit"
+  end
+
+  describe "the body" do
+
+    it "should have class 'active_admin'" do
+      expect(layout.build.class_list).to include 'active_admin'
+    end
+
+    it "should have namespace class" do
+      expect(layout.build.class_list).to include "#{active_admin_namespace.name}_namespace"
+    end
+
+  end
+
+end

data/spec/unit/views/pages/show_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Views::Pages::Show do
+
+  describe "the resource" do
+    let(:helpers) { double resource: resource }
+    let(:arbre_context) { Arbre::Context.new({}, helpers) }
+
+    context 'when the resource does not respond to #decorator' do
+      let(:resource) { 'Test Resource' }
+
+      it "normally returns the resource" do
+        page = ActiveAdmin::Views::Pages::Show.new(arbre_context)
+        expect(page.resource).to eq 'Test Resource'
+      end
+    end
+
+  end
+
+end

data/spec/unit/views/tabbed_navigation_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+include ActiveAdmin
+describe ActiveAdmin::Views::TabbedNavigation do
+
+  let(:menu){ ActiveAdmin::Menu.new }
+
+  let(:assigns){ { active_admin_menu: menu } }
+  let(:helpers){ mock_action_view }
+
+  let(:tabbed_navigation) do
+    arbre(assigns, helpers) {
+      insert_tag(ActiveAdmin::Views::TabbedNavigation, active_admin_menu)
+    }.children.first
+  end
+
+  let(:html) { tabbed_navigation.to_s }
+
+  before do
+    helpers.stub(:admin_logged_in?).and_return(false)
+  end
+
+  describe "rendering a menu" do
+
+    before do
+      menu.add label: "Blog Posts", url: :admin_posts_path
+
+      menu.add label: "Reports", url: "/admin/reports" do |reports|
+        reports.add label: "A Sub Reports", url: "/admin/a-sub-reports"
+        reports.add label: "B Sub Reports", url: "/admin/b-sub-reports"
+        reports.add label: proc{ "Label Proc Sub Reports" }, url: "/admin/label-proc-sub-reports", id: "Label Proc Sub Reports"
+      end
+
+      menu.add label: "Administration", url: "/admin/administration" do |administration|
+        administration.add label: "User administration",
+                           url: '/admin/user-administration',
+                           priority: 10,
+                           if: proc { false }
+      end
+
+      menu.add label: "Management", url: "#" do |management|
+        management.add label: "Order management",
+                       url: '/admin/order-management',
+                       priority: 10,
+                       if: proc { false }
+        management.add label: "Bill management",
+                       url: '/admin/bill-management',
+                       priority: 10,
+                       if: :admin_logged_in?
+      end
+    end
+
+    it "should generate a ul" do
+      expect(html).to have_tag("ul")
+    end
+
+    it "should generate an li for each item" do
+      expect(html).to have_tag("li", parent: { tag: "ul" })
+    end
+
+    it "should generate a link for each item" do
+      expect(html).to have_tag("a", "Blog Posts", attributes: { href: '/admin/posts' })
+    end
+
+    it "should generate a nested list for children" do
+      expect(html).to have_tag("ul", parent: { tag: "li" })
+    end
+
+    it "should generate a nested list with li for each child" do
+      expect(html).to have_tag("li", parent: { tag: "ul" }, attributes: {id: "a_sub_reports"})
+      expect(html).to have_tag("li", parent: { tag: "ul" }, attributes: {id: "b_sub_reports"})
+    end
+
+    it "should generate a valid id from a label proc" do
+      expect(html).to have_tag("li", parent: { tag: "ul" }, attributes: {id: "label_proc_sub_reports"})
+    end
+
+    it "should not generate a link for user administration" do
+      expect(html).to_not have_tag("a", "User administration", attributes: { href: '/admin/user-administration' })
+    end
+
+    it "should generate the administration parent menu" do
+      expect(html).to have_tag("a", "Administration", attributes: { href: '/admin/administration' })
+    end
+
+    it "should not generate a link for order management" do
+      expect(html).to_not have_tag("a", "Order management", attributes: { href: '/admin/order-management' })
+    end
+
+    it "should not generate a link for bill management" do
+      expect(html).to_not have_tag("a", "Bill management", attributes: { href: '/admin/bill-management' })
+    end
+
+    it "should not generate the management parent menu" do
+      expect(html).to_not have_tag("a", "Management", attributes: { href: '#' })
+    end
+
+    describe "marking current item" do
+
+      it "should add the 'current' class to the li" do
+        assigns[:current_tab] = menu["Blog Posts"]
+        expect(html).to have_tag("li", attributes: { class: "current" })
+      end
+
+      it "should add the 'current' and 'has_nested' classes to the li and 'current' to the sub li" do
+        assigns[:current_tab] = menu["Reports"]["A Sub Reports"]
+        expect(html).to have_tag("li", attributes: { id: "reports", class: /current/ })
+        expect(html).to have_tag("li", attributes: { id: "reports", class: /has_nested/ })
+        expect(html).to have_tag("li", attributes: { id: "a_sub_reports", class: "current" })
+      end
+
+    end
+
+  end
+
+  describe "returning the menu items to display" do
+
+    it "should return one item with no if block" do
+      menu.add label: "Hello World", url: "/"
+      expect(tabbed_navigation.menu_items).to eq menu.items
+    end
+
+    it "should not include menu items with an if block that returns false" do
+      menu.add label: "Don't Show", url: "/", priority: 10, if: proc{ false }
+      expect(tabbed_navigation.menu_items).to be_empty
+    end
+
+    it "should not include menu items with an if block that calls a method that returns false" do
+      menu.add label: "Don't Show", url: "/", priority: 10, if: :admin_logged_in?
+      expect(tabbed_navigation.menu_items).to be_empty
+    end
+
+    it "should not display any items that have no children to display" do
+      menu.add label: "Parent", url: "#" do |p|
+        p.add label: "Child", url: "/", priority: 10, if: proc{ false }
+      end
+      expect(tabbed_navigation.menu_items).to be_empty
+    end
+
+    it "should display a parent that has a child to display" do
+      menu.add label: "Parent", url: "#" do |p|
+        p.add label: "Hidden Child", url: "/", priority: 10, if: proc{ false }
+        p.add label: "Child", url: "/"
+      end
+      expect(tabbed_navigation).to have(1).menu_items
+    end
+
+  end
+end

data/tasks/docs.rake

@@ -0,0 +1,37 @@
+namespace :docs do
+
+  AUTOGEN_WARNING = <<-EOD
+<!--
+  WARNING: Please DO NOT edit this file! Update
+  source documentation in lib/active_admin/views
+  and execute rake yard to regenerate it.
+-->
+
+EOD
+
+  def filename_from_module(mod)
+    mod.name.to_s.underscore.gsub('_', '-')
+  end
+
+  def write_docstrings_to(path, mods)
+    mods.each do |mod|
+      File.open("#{path}/#{filename_from_module(mod)}.md", 'w+') do |f|
+        f << AUTOGEN_WARNING + mod.docstring + "\n"
+      end
+    end
+  end
+
+  desc "Update docs in the docs folder"
+  task :build do
+    require 'yard'
+    require 'active_support/all'
+
+    YARD::Registry.load!
+    views = YARD::Registry.at("ActiveAdmin::Views")
+
+    # Index Types
+    index_types = views.children.select{|obj| obj.name.to_s =~ /^IndexAs/ }
+    write_docstrings_to "docs/3-index-pages", index_types
+  end
+
+end

data/tasks/js.rake

@@ -0,0 +1,32 @@
+namespace :js do
+
+  desc "Compile the JS for Rails apps without Asset Pipeline"
+  task :compile do
+    require 'sprockets'
+    require 'uglifier'
+    require 'fileutils'
+
+    root_dir = File.expand_path(File.join("..", ".."), __FILE__)
+    js_dir = File.join(root_dir, "app", "assets", "javascripts", "active_admin")
+    generated_file = File.join(root_dir, 'lib', 'generators', 'active_admin', 'assets', 'templates', '3.0', 'active_admin.js')
+
+    # The base.js file requires jquery. We don't need jquery to
+    # compile the assets, however Sprockets will try to look it up
+    # and raise an exception. Insteaad, we move the file out of the directory
+    # then put it back after we compile.
+    base_js = File.join(js_dir, "base.js")
+    tmp_base_js = File.join(root_dir, "base.js")
+    FileUtils.mv base_js, tmp_base_js
+
+    env = Sprockets::Environment.new
+    env.js_compressor = ::Uglifier.new
+    env.append_path js_dir
+
+    File.open generated_file, "w+" do |f|
+      f << env["application"]
+    end
+
+    FileUtils.mv tmp_base_js, base_js
+  end
+
+end

data/tasks/parallel_tests.rake

@@ -0,0 +1,60 @@
+require 'parallel'
+
+desc "Run the full suite using parallel_tests to run on multiple cores"
+task :parallel_tests => ['parallel:setup_parallel_tests', 'parallel:spec', 'parallel:features', 'cucumber:class_reloading']
+
+namespace :parallel do
+
+  def rails_app_rake(task)
+    require 'rails/version'
+    system "cd spec/rails/rails-#{Rails::VERSION::STRING}; rake #{task}"
+  end
+
+  task :after_setup_hook do
+    rails_app_rake "parallel:load_schema"
+    rails_app_rake "parallel:create_cucumber_db"
+    rails_app_rake "parallel:load_schema_cucumber_db"
+  end
+
+  def parallel_tests_setup?
+    require 'rails/version'
+    database_config = File.join "spec", "rails", "rails-#{Rails::VERSION::STRING}", "config", "database.yml"
+    File.exists?(database_config) && File.read(database_config).include?("TEST_ENV_NUMBER")
+  end
+
+  desc "Setup parallel_tests DBs"
+  task :setup_parallel_tests do
+    unless parallel_tests_setup?
+      puts "parallel_tests is not set up. (Re)building spec/rails/rails-#{Rails::VERSION::STRING} App. Please wait."
+      require 'rails/version'
+      system("rm -Rf spec/rails/rails-#{Rails::VERSION::STRING}")
+      Rake::Task['setup'].invoke
+    end
+  end
+
+  def run_in_parallel(command)
+    system("ENV['TEST_ENV_NUMBER']=#{Parallel.processor_count} #{command}")
+  end
+
+  desc "Run the specs in parallel"
+  task :spec => :setup_parallel_tests do
+    run_in_parallel "parallel_rspec spec/"
+  end
+
+  namespace :spec do
+
+    %w(unit integration).each do |type|
+      desc "Run the #{type} specs in parallel"
+      task type => :setup_parallel_tests do
+        run_in_parallel "parallel_rspec spec/#{type}"
+      end
+    end
+
+  end
+
+  desc "Run the cucumber features in parallel"
+  task :features => :setup_parallel_tests do
+    run_in_parallel "parallel_cucumber features/"
+  end
+
+end

data/tasks/test.rake

@@ -0,0 +1,79 @@
+desc "Creates a test rails app for the specs to run against"
+task :setup do
+  require 'rails/version'
+  system("mkdir spec/rails") unless File.exists?("spec/rails")
+  system "bundle exec rails new spec/rails/rails-#{Rails::VERSION::STRING} -m spec/support/rails_template.rb"
+  Rake::Task['parallel:after_setup_hook'].invoke
+end
+
+desc "Run the full suite using 1 core"
+task test: ['spec:unit', 'spec:integration', 'cucumber', 'cucumber:class_reloading']
+
+require 'coveralls/rake/task'
+Coveralls::RakeTask.new
+task test_with_coveralls: [:test, 'coveralls:push']
+
+namespace :test do
+
+  def run_tests_against(*versions)
+    current_version = detect_rails_version if File.exists?("Gemfile.lock")
+
+    versions.each do |version|
+      puts
+      puts "== Using Rails #{version}"
+
+      cmd "./script/use_rails #{version}"
+      cmd "bundle exec rspec spec"
+      cmd "bundle exec cucumber features"
+      cmd "bundle exec cucumber -p class-reloading features"
+    end
+
+    cmd "./script/use_rails #{current_version}" if current_version
+  end
+
+  desc "Run the full suite against the important versions of rails"
+  task :major_supported_rails do
+    run_tests_against *TRAVIS_RAILS_VERSIONS
+  end
+
+  desc "Alias for major_supported_rails"
+  task :all => :major_supported_rails
+
+end
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :spec do
+
+  desc "Run the unit specs"
+  RSpec::Core::RakeTask.new(:unit) do |t|
+    t.pattern = "spec/unit/**/*_spec.rb"
+  end
+
+  desc "Run the integration specs"
+  RSpec::Core::RakeTask.new(:integration) do |t|
+    t.pattern = "spec/integration/**/*_spec.rb"
+  end
+
+end
+
+
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:cucumber) do |t|
+  t.profile = 'default'
+end
+
+namespace :cucumber do
+
+  Cucumber::Rake::Task.new(:wip, "Run the cucumber scenarios with the @wip tag") do |t|
+    t.profile = 'wip'
+  end
+
+  Cucumber::Rake::Task.new(:class_reloading, "Run the cucumber scenarios that test reloading") do |t|
+    t.profile = 'class-reloading'
+  end
+
+end