RubyGems - fortitude - Versions diffs - 0.0.4-java - Mend

fortitude 0.0.4-java

Files changed (355) hide show

data/spec/rails/erb_integration_system_spec.rb ADDED

@@ -0,0 +1,23 @@
+describe "Rails ERb integration support", :type => :rails do
+  uses_rails_with_template :erb_integration_system_spec
+  it "should let you call a widget from an ERb file with render :partial" do
+    expect_match("erb_to_widget_with_render_partial", /erb to widget with render partial widget/,
+      /erb_start/, /erb_end/, /erb_start.*erb to widget with render partial widget.*erb_end/m)
+  end
+  it "should prefer ERb partials to Fortitude partials" do
+    expect_match("prefers_erb_partial", /erb partial/,
+      /erb_start.*erb partial.*erb_end/m)
+  end
+  it "should allow you to define a Fortitude partial in a file with an underscore" do
+    expect_match('fortitude_partial_with_underscore', /fortitude partial with underscore partial/,
+      /erb_start.*fortitude partial with underscore partial.*erb_end/m)
+  end
+  it "should let you call an ERb partial from a widget with render :partial" do
+    expect_match('erb_partial_from_widget',
+      /this is the widget.*this is the partial.*this is the widget again/mi)
+  end
+end

data/spec/rails/helpers_include_all_off_system_spec.rb ADDED

@@ -0,0 +1,7 @@
+describe "Fortitude helpers with config.action_controller.include_all_helpers = false", :type => :rails do
+  uses_rails_with_template :helpers_include_all_off_system_spec
+  it "should not include all helpers" do
+    expect_match("include_all_off", /excitedly: awesome!!!; uncertainly: NoMethodError/mi)
+  end
+end

data/spec/rails/helpers_system_spec.rb ADDED

@@ -0,0 +1,79 @@
+describe "Rails helper support", :type => :rails do
+  uses_rails_with_template :helpers_system_spec
+  it "should support the built-in Rails helpers by default" do
+    expect_match("basic_helpers",
+      /Three months ago: 3 months/mi,
+      /A million dollars: \$1,000,000\.00/mi,
+      %r{Select datetime:\s*<select.*name="date.*>.*<option.*value="2014".*</option>}mi)
+  end
+  it "should refine the built-in Rails helpers by default" do
+    expect_match("helpers_that_output_when_refined",
+      %r{START.*<img.*src="http://example.com/foo".*/><a href="mailto:test@example.com">test@example.com</a><link.*href="http://example.com/bar".*/>END}mi)
+  end
+  it "should support helpers that use blocks" do
+    expect_match("block_helpers",
+      %r{<body>\s*<form.*action="/form_dest".*>.*<input.*authenticity_token.*/>.*<p>inside the form</p>.*</form>}mi,
+      %r{})
+  end
+  it "should support built-in Rails helpers that output, rather than return, properly" do
+    expect_match("built_in_outputting_helpers",
+      %r{<div class=.concat_container.>.*this is concatted.*</div>.*<div class=.safe_concat_container.>.*this is safe_concatted.*</div>}mi)
+  end
+  it "should support custom-defined helpers" do
+    expect_match("custom_helpers_basic", %r{excited: awesome!!!})
+  end
+  it "should support custom-defined helpers that output, rather than return, properly" do
+    expect_match("custom_helper_outputs", %r{how awesome: super awesome!})
+  end
+  it "should support custom-defined helpers that take a block" do
+    expect_match("custom_helpers_with_a_block", %r{fedxxcbayyabcxxdef})
+  end
+  it "should allow changing a built-in Rails helper from outputting to returning" do
+    expect_match("built_in_outputting_to_returning", %r{<body>\s*<p>\s*text is: this is the_text\s*</p>\s*</body>}mi)
+  end
+  it "should allow changing a built-in Rails helper from returning to outputting" do
+    expect_match("built_in_returning_to_outputting", %r{<body>\s*it was 3 months, yo\s*</body>}mi)
+  end
+  it "should allow changing a custom-defined helper from outputting to returning" do
+    expect_match("custom_outputting_to_returning", %r{and super awesome!, yo}mi)
+  end
+  it "should allow changing a custom-defined helper from returning to outputting" do
+    expect_match("custom_returning_to_outputting", %r{and awesome!!!, yo}mi)
+  end
+  it "should inherit helper settings, but also let them be overridden" do
+    expect_match("helper_settings_inheritance", %r{it is really awesome!!!, yo\s*and super awesome!, too}mi)
+  end
+  it "should allow access to controller methods declared as helpers" do
+    expect_match("controller_helper_method", %r{it is \*\~\* Fred \*\~\*\!}mi)
+  end
+  it "should allow access to methods explicitly imported as helpers" do
+    expect_match("controller_helper_module", %r{and &gt;=== June ===&gt;}mi)
+  end
+  it "should allow turning off automatic helper access" do
+    expect_match("automatic_helpers_disabled", %r{excitedly: NoMethodError; time_ago_in_words: NoMethodError; number_to_currency: \$1,000,000.00})
+  end
+  it "should inherit automatic helper access properly" do
+    expect_match("automatic_helpers_inheritance", %r{C1: excitedly: NoMethodError; time_ago_in_words: NoMethodError; number_to_currency: \$1,000,000.00.*C2: excitedly: awesome!!!; time_ago_in_words: 3 months; number_to_currency: \$1,000,000.00})
+  end
+  it "should allow access to private helpers in exactly the same way as ERb" do
+    expect_match("private_helper_erb", %r{a private helper: private!})
+    expect_match("private_helper_fortitude", %r{a private helper: private!})
+  end
+end

data/spec/rails/helpers_unrefined_system_spec.rb ADDED

@@ -0,0 +1,7 @@
+describe "Fortitude unrefined Rails helper support", :type => :rails do
+  uses_rails_with_template :helpers_unrefined_system_spec
+  it "should not output when refined-outputting helpers are called" do
+    expect_match("helpers_that_output_when_refined", /STARTEND/)
+  end
+end

data/spec/rails/layouts_system_spec.rb ADDED

@@ -0,0 +1,60 @@
+describe "Rails layout support", :type => :rails do
+  uses_rails_with_template :layouts_system_spec
+  it "should let you use a widget in an ERb layout, and render in the right order" do
+    data = get("widget_inside_erb_layout")
+    data.should match(/default_layout_erb/i)
+    data.should match(/this is widget_inside_erb_layout/i)
+    data.should match(/pre_layout order: \[:widget_inside_erb_layout, :layout_pre\]/i)
+    data.should match(/post_layout order: \[:widget_inside_erb_layout, :layout_pre, :layout_post\]/i)
+    data.should match(/order inside widget: \[:widget_inside_erb_layout\]/i)
+    data.should match(/pre_layout foo: foo_from_widget_inside_erb_layout/i)
+    data.should match(/post_layout foo: foo_from_widget_inside_erb_layout/i)
+  end
+  it "should let you use a widget as a layout with an ERb view, and render in the right order" do
+    data = get("erb_inside_widget_layout")
+    data.should match(/widget_layout/i)
+    data.should match(/this is erb_inside_widget_layout/i)
+    data.should match(/pre_layout order: \[:erb_inside_widget_layout, :widget_layout_pre\]/i)
+    data.should match(/post_layout order: \[:erb_inside_widget_layout, :widget_layout_pre, :widget_layout_post\]/i)
+    data.should match(/order inside erb: \[:erb_inside_widget_layout\]/i)
+    data.should match(/pre_layout foo: foo_from_erb_inside_widget_layout/i)
+    data.should match(/post_layout foo: foo_from_erb_inside_widget_layout/i)
+  end
+  it "should let you use a widget as a layout with a widget view, and render in the right order" do
+    data = get("widget_inside_widget_layout")
+    data.should match(/widget_layout/i)
+    data.should match(/this is widget_inside_widget_layout/i)
+    data.should match(/pre_layout order: \[:widget_inside_widget_layout, :widget_layout_pre\]/i)
+    data.should match(/post_layout order: \[:widget_inside_widget_layout, :widget_layout_pre, :widget_layout_post\]/i)
+    data.should match(/order inside widget: \[:widget_inside_widget_layout\]/i)
+    data.should match(/pre_layout foo: foo_from_widget_inside_widget_layout/i)
+    data.should match(/post_layout foo: foo_from_widget_inside_widget_layout/i)
+  end
+  it "should use a layout with render :widget by default" do
+    data = get("render_widget")
+    data.should match(/default_layout_erb/i)
+    data.should match(/this is the_render_widget/i)
+  end
+  it "should let you turn off the layout with render :widget" do
+    data = get("render_widget_without_layout")
+    data.should_not match(/default_layout_erb/i)
+    data.should match(/this is the_render_widget/i)
+  end
+  it "should let you pick an alternate layout for render :widget" do
+    data = get("render_widget_with_alt_layout")
+    data.should match(/alternate_layout_erb/i)
+    data.should match(/this is the_render_widget/i)
+  end
+  it "should let you explicitly yield to the view" do
+    data = get("yield_from_widget_explicitly")
+    data.should match(/explicit_yield_layout/i)
+    data.should match(/this is yield_from_widget_explicitly/i)
+  end
+end

data/spec/rails/localization_system_spec.rb ADDED

@@ -0,0 +1,38 @@
+describe "basic Rails support", :type => :rails do
+  uses_rails_with_template :localization_system_spec
+  it "should allow you to provide localized content methods" do
+    expect_match("content_method?locale=en", /wassup\? this is english/mi)
+    expect_match("content_method?locale=fr", /bienvenue, les mecs/mi)
+    expect_match("content_method?locale=pt", /i don&#(39|x27);t know that language/mi)
+  end
+  it "should let you translate strings with I18n.t" do
+    expect_match("i18n_t?locale=en", /a house is: house/)
+    expect_match("i18n_t?locale=fr", /a house is: maison/)
+  end
+  it "should let you translate strings with just t" do
+    expect_match("t?locale=en", /a house is: house/)
+    expect_match("t?locale=fr", /a house is: maison/)
+  end
+  it "should support dot-notation for I18n translation naming" do
+    expect_match("dot_notation?locale=en", /awesome is: awesome!/)
+    expect_match("dot_notation?locale=fr", /awesome is: formidable!/)
+  end
+  it "should let you translate strings with Fortitude translation support" do
+    expect_match("native_support?locale=en", /not translated; also awesome 127!; also not translated/i)
+    expect_match("native_support?locale=fr", /not translated; encore formidable 127!; also not translated/i)
+  end
+  it "should let you readjust the translation base" do
+    expect_match("readjust_base?locale=en", /SUPA-awesome 127!/)
+    expect_match("readjust_base?locale=fr", /TOUS formidable, 127!/)
+  end
+  it "should not escape explicitly-HTML translations" do
+    expect_match("explicit_html", /one: foo<bar>, two: bar<baz>, one again: foo<bar>, two again: bar<baz>/i)
+  end
+end

data/spec/rails/production_mode_system_spec.rb ADDED

@@ -0,0 +1,13 @@
+describe "Rails production-mode support", :type => :rails do
+  uses_rails_with_template :production_mode_system_spec
+  it "should not, by default, format output" do
+    expect_match("sample_output", %r{<section class="one"><p>hello, Jessica</p></section>}i)
+  end
+  it "should not, by default, output BEGIN/END debugging tags" do
+    data = get_success("sample_output")
+    expect(data).not_to match(%r{<!--\s*BEGIN}mi)
+    expect(data).not_to match(%r{<!--\s*END}mi)
+  end
+end

data/spec/rails/rendering_context_system_spec.rb ADDED

@@ -0,0 +1,64 @@
+describe "Rails RenderingContext support", :type => :rails do
+  uses_rails_with_template :rendering_context_system_spec
+  it "should use the context returned by create_fortitude_rendering_context in the view" do
+    expect_match("uses_specified_context_in_view", /context is: SimpleRc, value 12345/)
+  end
+  it "should still use that context even for partials invoked by ERb" do
+    expect_match("uses_specified_context_in_partials", /before partial.*context is: SimpleRc, value 23456.*after partial/mi)
+  end
+  it "should use that context for partials through multiple layers of nesting" do
+    text = get_success("uses_specified_context_through_nesting")
+    if text =~ /view rc: SimpleRc, 34567, (\d+).*partial.*inner partial rc: SimpleRc, 34567, (\d+)/mi
+      first_value, second_value = Integer($1), Integer($2)
+      expect(first_value).to eq(second_value)
+    else
+      raise "Text did not match: #{text.inspect}"
+    end
+  end
+  it "should use that context for widgets rendered with render :widget" do
+    expect_match("uses_specified_context_in_render_widget", /context is: SimpleRc, value 45678/)
+  end
+  it "should use that context for widgets rendered with render :inline" do
+    expect_match("uses_specified_context_in_render_inline", /context is: SimpleRc, value 56789/)
+  end
+  it "should use the context returned by just plain fortitude_rendering_context in the view" do
+    expect_match("uses_direct_context_in_view", /context is: SimpleRc, value 67890/)
+  end
+  it "should still call that method for all widgets" do
+    expect_match("uses_direct_context_for_all_widgets", /context is: SimpleRc, value 67890.*context is: SimpleRc, value 67891.*context is: SimpleRc, value 67890/mi)
+  end
+  it "should call start_widget! and end_widget! properly on widgets in Rails" do
+    text = get_success("start_end_widget_basic")
+    lines = text.split(/[\r\n]+/)
+    lines = lines.select { |l| l =~ /^\d:/ }.map { |l| l.strip }
+    expect(lines[0]).to eq("0: start Views::RenderingContextSystemSpec::StartEndWidgetBasic")
+    expect(lines[1]).to eq("1: start Views::RenderingContextSystemSpec::StartEndWidgetBasicInner 1")
+    expect(lines[2]).to eq("2: end Views::RenderingContextSystemSpec::StartEndWidgetBasicInner 1")
+    expect(lines[3]).to eq("3: start Views::RenderingContextSystemSpec::StartEndWidgetBasicInner 2")
+    expect(lines[4]).to eq("4: start Views::RenderingContextSystemSpec::StartEndWidgetBasicInner")
+    expect(lines[5]).to eq("5: end Views::RenderingContextSystemSpec::StartEndWidgetBasicInner")
+    expect(lines[6]).to eq("6: end Views::RenderingContextSystemSpec::StartEndWidgetBasicInner 2")
+    expect(lines.length).to eq(7)
+  end
+  it "should call start_widget! and end_widget! through ERb partials, passing them as hashes" do
+    text = get_success("start_end_widget_through_partials")
+    lines = text.split(/[\r\n]+/)
+    lines = lines.select { |l| l =~ /^\d:/ }.map { |l| l.strip }
+    expect(lines[0]).to eq("0: start Views::RenderingContextSystemSpec::StartEndWidgetThroughPartials")
+    expect(lines[1]).to eq("1: start [{:partial=>\"start_end_widget_through_partials_partial\"}]")
+    expect(lines[2]).to eq("2: start Views::RenderingContextSystemSpec::StartEndWidgetThroughPartialsPartialWidget 12345")
+    expect(lines[3]).to eq("3: end Views::RenderingContextSystemSpec::StartEndWidgetThroughPartialsPartialWidget 12345")
+    expect(lines[4]).to eq("4: end [{:partial=>\"start_end_widget_through_partials_partial\"}]")
+    expect(lines.length).to eq(5)
+  end
+end

data/spec/rails/rendering_system_spec.rb ADDED

@@ -0,0 +1,158 @@
+describe "Rails rendering support", :type => :rails do
+  uses_rails_with_template :rendering_system_spec
+  describe "rendering from a controller" do
+    it "should let you specify a widget with 'render :action =>'" do
+      expect_match("render_with_colon_action", /hello, world/)
+    end
+    it "should let you specify a widget with 'render :template =>'" do
+      expect_match("render_with_colon_template", /hello, world/)
+    end
+    it "should let you specify a widget with 'render :widget =>', which should use a layout by default" do
+      data = expect_match("render_widget", /hello from a widget named Fred/)
+      expect(data).to match(/rails_spec_application/)
+    end
+    it "should let you omit the layout with 'render :widget =>', if you ask for it" do
+      data = expect_match("render_widget_without_layout", /hello from a widget named Fred/, :no_layout => true)
+      expect(data).not_to match(/rails_spec_application/)
+    end
+    it "should let you render a widget with 'render \"foo\"'" do
+      expect_match("render_widget_via_file_path", /hello from a widget named Fred/)
+    end
+    it "should let you render a widget with 'render :file =>'" do
+      expect_match("render_widget_via_colon_file", /hello from a widget named Fred/)
+    end
+    it "should let you render a widget inline with 'render :inline =>'" do
+      expect_match("render_widget_via_inline", /this is an inline widget named Fred/)
+    end
+    it "should let you render a widget inline, and use all instance and local variables, with locals overriding instance variables" do
+      expect_match("render_widget_via_inline_with_var_access", /this is an inline widget named Fred, and it is 27 years old, and friends with Mary/)
+    end
+  end
+  describe "rendering in a widget" do
+    it "should let you render a partial in a widget" do
+      expect_match("render_partial_from_widget", /this is the widget.*this is the_partial.*this is the widget again/mi)
+    end
+    it "should let you render :text in a widget" do
+      expect_match("render_text_from_widget", /this is the widget.*this is render_text.*this is the widget again/mi)
+    end
+    it "should let you render :template in a widget" do
+      expect_match("render_template_from_widget", /this is the widget.*widget_with_name: Fred.*this is the widget again/mi)
+    end
+    it "should let you render :inline in a widget" do
+      expect_match("render_inline_from_widget", /this is the widget.*widget_with_name: Fred.*this is the widget again/mi)
+    end
+    it "should let you render :file in a widget" do
+      expect_match("render_file_from_widget", /this is the widget.*widget_with_name: Fred.*this is the widget again/mi)
+    end
+  end
+  describe "render options" do
+    it "should let you set the content-type" do
+      data = get_response("render_with_content_type")
+      expect(data.body.strip).to match(/hello, world/)
+      content_type = data.header['content-type']
+      expect(content_type).to match(%r{^boo/yeah(;.*)?$})
+    end
+    it "should let you set the location" do
+      data = get_response("render_with_location")
+      expect(data.body.strip).to match(/hello, world/)
+      location = data.header['location']
+      expect(location).to eq("http://somewhere/over/the/rainbow")
+    end
+    it "should let you set the status" do
+      data = get_response("render_with_status", :ignore_status_code => true)
+      expect(data.code.to_s).to eq("768")
+    end
+  end
+  describe "rendering partial invocation" do
+    it "should render a collection correctly if so invoked" do
+      expect_match("render_collection", /collection is:.*word: apple.*word: pie.*word: is.*word: nice.*and that's all!/mi)
+    end
+    it "should support :as for rendering" do
+      expect_match("render_collection_as", /collection is:.*widget_with_name: bonita.*widget_with_name: applebaum.*widget_with_name: the.*widget_with_name: dude.*and that's all!/mi)
+    end
+    it "should support :object for rendering" do
+      expect_match("render_object", /partial is:.*word: donkey.*and that's all!/mi)
+    end
+    it "should support ERb partial layouts" do
+      expect_match("render_partial_with_layout", /this is the partial:.*partial_layout before.*partial_with_layout.*partial_layout after.*done!/mi)
+    end
+    it "should support using a widget as an ERb partial layout" do
+      expect_match("render_partial_with_widget_layout", /this is the partial:.*widget_partial_layout before.*partial_with_layout.*widget_partial_layout after.*done!/mi)
+    end
+  end
+  describe "HTML escaping" do
+    it "should only escape strings that aren't raw() or html_safe(), and do the right thing with h()" do
+      expect_match("render_html_safe_strings", /a: foo&lt;bar, b: bar<baz, c: baz<quux, d: quux&lt;marph, e: marph>foo/)
+    end
+  end
+  describe "streaming support" do
+    # Actually trying to get streaming working completely is a VERY finicky business, and we don't want to fail
+    # our tests just because (e.g.) we can't get buffering 100% disabled on this platform. So, we:
+    #
+    # * Use Net::HTTP to collect the HTTP/1.1 transfer chunks of the response; there should be more than one if
+    #   we're actually streaming (and there ends up being just 1 if you don't tell it to stream, or if Rails
+    #   detects that your template engine doesn't support streaming);
+    # * Collect the rendering order server-side and output it; if streaming, we'll render the top of the layout,
+    #   then the widget, then the bottom of the layout, completely differently from Rails' default mechanism of
+    #   rendering the view first, then the layout.
+    def collect_chunks(path)
+      chunks = [ ]
+      uri = rails_server.uri_for(full_path(path))
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        request = Net::HTTP::Get.new uri.request_uri
+        http.request(request) do |response|
+          response.read_body do |chunk|
+            chunks << chunk
+          end
+        end
+      end
+      chunks
+    end
+    it "should let you stream a pure widget" do
+      skip "currently, we can't figure out a way to test this for certain -- we get just one chunk no matter what we do"
+      chunks = collect_chunks("stream_widget")
+      expect(chunks.length).to be > 1
+    end
+    it "should let you stream from a widget that's in an ERb layout" do
+      skip("Fortitude streaming test is not supported under Rails 3.0.x") if @rails_server.rails_version =~ /^3\.0\./
+      skip("Fortitude streaming test is not supported under Ruby 1.8") if RUBY_VERSION =~ /^1\.8\./
+      chunks = collect_chunks("stream_widget_with_layout")
+      expect(chunks.length).to be > 1
+      full_text = chunks.join("")
+      expect(full_text).to match(/start_of_layout order:\s+\[:layout_start\]/mi)
+      expect(full_text).to match(/end_of_widget order:\s+\[:layout_start, :widget\]/mi)
+      expect(full_text).to match(/end_of_layout order:\s+\[:layout_start, :widget, :layout_end\]/mi)
+    end
+  end
+end