express_admin 1.1.0 → 1.2.0

data/vendor/gems/express_templates/test/components/configurable_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class ConfigurableTest < ActiveSupport::TestCase
+
+  ETC = ExpressTemplates::Components
+
+  class ConfigurableComponent < ETC::Base
+    include ETC::Capabilities::Configurable
+    emits -> {
+      div.bar(my[:id])
+    }
+  end
+
+  test "a configurable component accepts an id argument" do
+    assert :foo, ConfigurableComponent.new(:foo).my[:id]
+  end
+
+  test "renders id argument as dom id" do
+    compiled_src = ConfigurableComponent.new(:foo).compile
+    assert '<div id="foo" class="bar" />', compiled_src
+  end
+
+  class ConfigurableContainerComponent < ETC::Base
+    include ETC::Capabilities::Configurable
+    include ETC::Capabilities::Parenting
+
+    # make sure a helper can take arguments
+    helper(:name) {|name| name.to_s }
+
+    emits -> {
+      div(my[:id]) {
+        h1 { name(my[:id]) }
+        _yield
+      }
+    }
+  end
+
+  test "a configurable component may have also be a container" do
+    html = ExpressTemplates.render { configurable_container_component(:foo) { p "bar" }}
+    assert_equal '<div id="foo"><h1>foo</h1><p>bar</p></div>', html
+  end
+
+end

data/vendor/gems/express_templates/test/components/container_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+require 'minitest/mock'
+
+class ContainerTest < ActiveSupport::TestCase
+
+  ETC = ExpressTemplates::Components
+
+  def any_container
+    Class.new(ETC::Container)
+  end
+
+  test "a Container is a Component" do
+    assert_kind_of ETC::Base, any_container.new
+  end
+
+  test "a container has children but initially has none" do
+    assert any_container.new.respond_to?(:children)
+    assert_equal [], any_container.new.children
+  end
+
+  def mock_children
+    child1, child2 = Minitest::Mock.new, Minitest::Mock.new
+    child1.expect(:compile, '"one"')
+    child2.expect(:compile, '"two"')
+    child1.expect(:kind_of?, false, [ExpressTemplates::Components::Capabilities::Adoptable])
+    child2.expect(:kind_of?, false, [ExpressTemplates::Components::Capabilities::Adoptable])
+    return child1, child2
+  end
+
+  class TestContainer < ETC::Container
+    emits -> { p { _yield } }
+  end
+
+  test "Container#compile calls #compile on its children" do
+    container = TestContainer.new
+    child1, child2 = mock_children
+    container.children = [child1, child2]
+    container.compile
+    child1.verify
+    child2.verify
+  end
+
+  test "renders children in place of _yield" do
+    container = TestContainer.new
+    child1, child2 = mock_children
+    container.children = [child1, child2]
+
+    assert_equal "<p>onetwo</p>", eval(container.compile)
+  end
+
+  class Context
+    def a_helper
+      "foo"
+    end
+  end
+
+  test "children with interpolations" do
+    markup = ExpressTemplates.render(Context.new) do
+      row {
+        p %q(Should say: {{a_helper}}.)
+      }
+    end
+    assert_equal "<div class=\"row\"><p>Should say: foo.</p></div>", markup
+  end
+
+end

data/vendor/gems/express_templates/test/components/content_for_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+class ContentForTest < ActiveSupport::TestCase
+
+  class Context
+    def content_for(label, markup=nil, &block)
+      @blocks ||= {}
+      if block || markup
+        @blocks[label] = block ? block.call : markup
+        nil
+      else
+        @blocks[label]
+      end
+    end
+  end
+
+  test "content_for accepts a block of express template" do
+    fragment = -> {
+      content_for(:whatever) { h1 'hello' }
+    }
+    context = Context.new
+    markup = ExpressTemplates.render(context, &fragment)
+    assert_equal %Q(<h1>hello</h1>), context.content_for(:whatever)
+  end
+
+  test "content_for accepts a second argument which contains markup" do
+    fragment = -> {
+      content_for :title, "Foo"
+    }
+    context = Context.new
+    markup = ExpressTemplates.render(context, &fragment)
+    assert_equal 'Foo', context.content_for(:title)
+  end
+
+  test "content_for without a body returns the markup" do
+    fragment = -> {
+      content_for :title
+    }
+    context = Context.new
+    context.content_for :title, "Foo"
+    markup = ExpressTemplates.render(context, &fragment)
+    assert_equal 'Foo', markup
+  end
+
+  test "content_for body is html_safe" do
+    arg_frag = -> {
+      content_for :title, "<h1>Foo</h1>"
+    }
+    context = Context.new
+    markup = ExpressTemplates.render(context, &arg_frag)
+    assert context.content_for(:title).html_safe?
+
+    block_frag = -> {
+      content_for(:title) { h1 "Foo" }
+    }
+    markup = ExpressTemplates.render(context, &block_frag)
+    assert context.content_for(:title).html_safe?
+  end
+
+end

data/vendor/gems/express_templates/test/components/forms/basic_fields_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class BasicFieldsTest < ActiveSupport::TestCase
+
+  BASIC_FIELDS = %w(email phone text password color date datetime
+                    datetime_local number range
+                    search telephone time url week)
+
+  test "text requires parent" do
+    fragment = -> {
+      text :name
+    }
+    assert_raises(RuntimeError) {
+      ExpressTemplates.compile(&fragment)
+    }
+  end
+
+  test "all fields work" do
+    BASIC_FIELDS.each do |type|
+      fragment = -> {
+        express_form(:foo) {
+          send(type, :bar)
+        }
+      }
+      assert_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
+      assert_match "#{type}_field(:foo, :bar)", ExpressTemplates.compile(&fragment)
+    end
+  end
+
+  test "textarea uses rails text_area helper" do
+    fragment = -> {
+      express_form(:foo) {
+        textarea :bar
+      }
+    }
+    assert_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
+    assert_match "text_area(:foo, :bar)", ExpressTemplates.compile(&fragment)
+  end
+
+
+  test "hidden uses rails hidden_tag helper" do
+    fragment = -> {
+      express_form(:foo) {
+        hidden :bar
+      }
+    }
+    assert_no_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
+    assert_match "hidden_field(:foo, :bar)", ExpressTemplates.compile(&fragment)
+  end
+
+end
+

data/vendor/gems/express_templates/test/components/forms/checkbox_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class CheckboxTest < ActiveSupport::TestCase
+
+  test "Checkbox requires a parent form" do
+    fragment = -> {
+      checkbox :permission_granted
+    }
+    assert_raises(RuntimeError) {
+      ExpressTemplates.compile(&fragment)
+    }
+  end
+
+  test "checkbox places the label before the input" do
+    fragment = -> {
+      express_form(:account) {
+        checkbox :eula
+      }
+    }
+    compiled = ExpressTemplates.compile(&fragment)
+    label_helper = '#{label_tag("account_eula", "Eula")}'
+    field_helper = '#{check_box(:account, :eula, {}, "1", "0")}'
+    assert_match label_helper, compiled
+    assert_match field_helper, compiled
+    label_idx = compiled.index(label_helper)
+    field_idx = compiled.index(field_helper)
+    assert (field_idx > label_idx), "label must come first"
+  end
+
+  test "checkbox respects label_after: true " do
+    fragment = -> {
+      express_form(:account) {
+        checkbox :eula, label_after: true
+      }
+    }
+    compiled = ExpressTemplates.compile(&fragment)
+    label_helper = '#{label_tag("account_eula", "Eula")}'
+    field_helper = '#{check_box(:account, :eula, {}, "1", "0")}'
+    label_idx = compiled.index(label_helper)
+    field_idx = compiled.index(field_helper)
+    assert (field_idx < label_idx), "label must come after when label_after: true"
+  end
+
+end

data/vendor/gems/express_templates/test/components/forms/express_form_test.rb

@@ -0,0 +1,108 @@
+require 'test_helper'
+require 'ostruct'
+
+class ExpressFormTest < ActiveSupport::TestCase
+  class Context
+    def initialize(resource)
+      @resource = resource
+    end
+  end
+
+  def resource
+    OpenStruct.new(
+      id: 1,
+      name: 'Foo',
+      body: 'Hello world',
+      email: 'some@email.com',
+      phone: '123123123',
+      url: 'http://someurl.com',
+      number: 123,
+      dropdown: 'yes',
+      gender: 'Male'
+    )
+  end
+
+  def simplest_form(resource)
+    ctx = Context.new(resource)
+    fragment = -> {
+      express_form(:resource) {
+        submit value: 'Save it!'
+      }
+    }
+    return ctx, fragment
+  end
+
+  def express_form
+    "ExpressTemplates::Components::Forms::ExpressForm".constantize
+  end
+
+  test "express_form component exists" do
+    assert express_form
+  end
+
+  def compile_simplest_form
+    ctx, fragment = simplest_form(resource)
+    ExpressTemplates.compile(&fragment)
+  end
+
+  test "simplest form renders" do
+    assert compile_simplest_form
+  end
+
+  test "simplest form contains form tag" do
+    assert_match "<form", compile_simplest_form
+  end
+
+  test "simplest form contains rails form helpers" do
+    compiled_src = compile_simplest_form
+    assert_match "utf8_enforcer_tag", compiled_src
+    assert_match "method_tag(", compiled_src
+    assert_match "token_tag", compiled_src
+  end
+
+  test "simplest_form contains submit" do
+    assert_match 'submit_tag', compile_simplest_form
+  end
+
+  test "simplest_form adopts children (submit has reference to parent)" do
+    ctx, fragment = simplest_form(resource)
+    expanded_nodes = ExpressTemplates::Expander.new(nil).expand(fragment.source_body)
+    assert_instance_of ExpressTemplates::Components::Forms::ExpressForm,
+                       expanded_nodes.first.children.last.parent
+  end
+
+  test "#form_action uses url helpers" do
+    assert_equal "{{@foo.try(:persisted?) ? foo_path(@foo) : foos_path}}", express_form.new(:foo).form_action
+  end
+
+  test "#form_action uses correct path helper for update/patch" do
+    assert_equal "{{@foo.try(:persisted?) ? foo_path(@foo) : foos_path}}", express_form.new(:foo, method: :put).form_action
+  end
+
+  test "simplest_form uses form_action for the action" do
+    form_open_tag = compile_simplest_form.match(/<form[^>]*>/)[0]
+    assert_match 'action=\"#{@resource.try(:persisted?) ? resource_path(@resource) : resources_path}\"', form_open_tag
+  end
+
+  test "express_form default method is POST" do
+    form_open_tag = compile_simplest_form.match(/<form[^>]*>/)[0]
+    assert_match 'method=\"POST\"', form_open_tag
+  end
+
+  test "express_form accepts :resource_name for removing namespace" do
+    fragment = -> {
+      express_form(:admin_foo, resource_name: 'foo') {
+        submit "Save!"
+      }
+    }
+    expanded_nodes = ExpressTemplates::Expander.new(nil).expand(fragment.source_body)
+    assert_equal 'foo', expanded_nodes.first.resource_name
+  end
+
+  # test "express_form has a namespace option with nil default" do
+  #   form = ExpressTemplates::Components::Forms::ExpressForm
+  #   assert_nil form.new(:person).namespace
+  #   assert_equal 'express_engine', form.new(:person, namespace: 'express_engine').namespace
+  # end
+
+end

data/vendor/gems/express_templates/test/components/forms/radio_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+class RadioTest < ActiveSupport::TestCase
+
+  test "radio requires a parent component" do
+    fragment = -> {
+      radio :preferred_email_format, ['HTML', 'Text']
+    }
+    assert_raises(RuntimeError) {
+      ExpressTemplates.compile(&fragment)
+    }
+  end
+
+  def radio_with_array_options
+    fragment = -> {
+      express_form(:person) {
+        radio :preferred_email_format, ['HTML', 'Text']
+      }
+    }
+  end
+
+  test "radio has correct label field name and text" do
+    assert_match '#{label_tag("person_preferred_email_format", "Preferred Email Format")}',
+                  ExpressTemplates.compile(&radio_with_array_options)
+  end
+
+  test "radio options present with class 'radio'" do
+    compiled = ExpressTemplates.compile(&radio_with_array_options)
+    assert_match 'radio_button(:person, :preferred_email_format, "Text", class: "radio"', compiled
+    assert_match '_format, "HTML", class: "radio"', compiled
+  end
+
+  def radio_with_hash_options
+    fragment = -> {
+      express_form(:person) {
+        radio :subscribed, {1 => 'Yes', 0 => 'No'}, wrapper_class: 'my-wrapper'
+      }
+    }
+  end
+
+  test "radio options may be specified with a hash" do
+    compiled = ExpressTemplates.compile(&radio_with_hash_options)
+    assert_match '<label class=\"my-wrapper\">', compiled
+    assert_match 'radio_button(:person, :subscribed, 0, class: "radio"', compiled
+    assert_match 'radio_button(:person, :subscribed, 1, class: "radio"', compiled
+  end
+
+  test "radio throws error if given improper options" do
+    fragment = -> {
+      express_form(:person) {
+        radio :subscribed, "Garbage options"
+      }
+    }
+    assert_raises(RuntimeError) {
+      ExpressTemplates.compile(&fragment)
+    }
+  end
+
+  def radio_with_options_omitted
+    fragment = -> {
+      express_form(:employee) {
+        radio :department_id
+      }
+    }
+  end
+
+  class ::Department
+    def self.columns
+      [OpenStruct.new(name: 'id'), OpenStruct.new(name: 'name')]
+    end
+  end
+  class ::Employee
+    def self.reflect_on_association(name)
+      if name.eql? :department
+        dummy_association = Object.new
+        class << dummy_association
+          def macro ; :belongs_to ; end
+          def klass ; ::Department ; end
+          def polymorphic? ; false ; end
+        end
+        return dummy_association
+      end
+    end
+  end
+
+  test "radio options from collection when options omitted" do
+    assert_match 'collection_radio_buttons(:employee, :department_id, Department.all.select(:id, :name).order(:name), :id, :name, {}, {}',
+                  ExpressTemplates.compile(&radio_with_options_omitted)
+  end
+
+  # test "radio supports html options"
+
+  # test "html_options passed correctly when collection is omitted"
+
+  # test "radio helper options passed to collection_radio_buttons"
+end