fortitude 0.0.4-java

data/spec/system/tag_return_value_system_spec.rb

@@ -0,0 +1,41 @@
+describe "Fortitude tag return values", :type => :system do
+  context "should blow up when calling a method on" do
+    def expect_nrv(name, &block)
+      e = capture_exception(Fortitude::Errors::NoReturnValueFromTag) { render(widget_class_with_content(&block)) }
+      expect(e).to be
+      expect(e.method_name).to eq(name)
+    end
+
+    it "a simple tag" do
+      expect_nrv(:foo) { p.foo }
+    end
+
+    it "a tag with attributes" do
+      expect_nrv(:foo) { p(:foo => :bar).foo }
+    end
+
+    it "a tag with direct content" do
+      expect_nrv(:foo) { p("whatever").foo }
+    end
+
+    it "a tag with a block" do
+      expect_nrv(:foo) { p { text "whatever" }.foo }
+    end
+
+    it "a tag with a block and direct content" do
+      expect_nrv(:foo) { p("foo") { text "whatever" }.foo }
+    end
+
+    it "a tag with direct content and attributes" do
+      expect_nrv(:foo) { p("foo", :foo => :bar).foo }
+    end
+
+    it "a tag with a block and attributes" do
+      expect_nrv(:foo) { p(:foo => :bar) { text "whatever" }.foo }
+    end
+
+    it "a tag with a block, direct content, and attributes" do
+      expect_nrv(:foo) { p("foo", :foo => :bar) { text "whatever" }.foo }
+    end
+  end
+end

data/spec/system/tag_rules_system_spec.rb

@@ -0,0 +1,196 @@
+describe "Fortitude tag rules enforcement", :type => :system do
+  def widget_class(options = { }, &block)
+    out = super(options, &block)
+    out.class_eval { enforce_element_nesting_rules true } unless options[:no_enforcement]
+    out
+  end
+
+  it "should not allow a <div> inside a <p>" do
+    expect { render(widget_class_with_content { p { div } })}.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should quote HTML specifications at you when you screw up" do
+    expect { render(widget_class_with_content { p { div } })}.to raise_error(Fortitude::Errors::InvalidElementNesting, /THE_SPEC_FOR_P/)
+  end
+
+  it "should allow a <b> inside a <p>" do
+    expect(render(widget_class_with_content { p { b } })).to eq('<p><b></b></p>')
+  end
+
+  it "should not allow text where it's, well, not allowed, when specified directly" do
+    expect { render(widget_class_with_content { div "hi" }) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should not allow text where it's, well, not allowed, when specified directly and with a hash" do
+    expect { render(widget_class_with_content { div "hi", :class => "something" }) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should not allow text where it's, well, not allowed, when specified indirectly" do
+    expect { render(widget_class_with_content { div { text "hi" } }) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should always allow rawtext" do
+    expect(render(widget_class_with_content { div { rawtext "yo" }})).to eq("<div>yo</div>")
+  end
+
+  it "should always allow html_safe text, when specified indirectly" do
+    expect(render(widget_class_with_content { div { text "yo".html_safe } })).to eq("<div>yo</div>")
+  end
+
+  it "should always allow html_safe text, when specified directly" do
+    expect(render(widget_class_with_content { div "yo".html_safe })).to eq("<div>yo</div>")
+  end
+
+  it "should not enforce rules inside a widget with the setting off, even if surrounding widgets have it on" do
+    outer = widget_class do
+      attr_accessor :inner
+      def content
+        p do
+          widget inner
+        end
+      end
+    end
+
+    middle = widget_class(:no_enforcement => true) do
+      attr_accessor :inner
+      def content
+        div do
+          p do
+            widget inner
+          end
+        end
+      end
+    end
+
+    inner = widget_class_with_content do
+      text "yo"
+    end
+
+    outer_instance = outer.new
+    middle_instance = middle.new
+    inner_instance = inner.new
+
+    outer_instance.inner = middle_instance
+    middle_instance.inner = inner_instance
+
+    expect(render(outer_instance)).to eq("<p><div><p>yo</p></div></p>")
+  end
+
+  it "should still enforce rules from one widget to the next" do
+    outer = widget_class do
+      attr_accessor :inner
+      def content
+        p do
+          widget inner
+        end
+      end
+    end
+
+    middle = widget_class do
+      def content
+        div do
+          text "hi"
+        end
+      end
+    end
+
+    outer_instance = outer.new
+    middle_instance = middle.new
+
+    outer_instance.inner = middle_instance
+
+    expect { render(outer_instance) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should allow you to disable enforcement with a block" do
+    wc = widget_class_with_content do
+      p do
+        with_element_nesting_rules(false) do
+          div do
+            text "hi"
+          end
+        end
+      end
+    end
+
+    expect(render(wc)).to eq("<p><div>hi</div></p>")
+  end
+
+  it "should allow you to disable enforcement with a block, even across widget boundaries" do
+    outer = widget_class do
+      attr_accessor :inner
+      def content
+        p do
+          with_element_nesting_rules(false) do
+            widget inner
+          end
+        end
+      end
+    end
+
+    inner = widget_class_with_content { div { text "hi" } }
+
+    outer_instance = outer.new
+    inner_instance = inner.new
+    outer_instance.inner = inner_instance
+
+    expect(render(outer_instance)).to eq("<p><div>hi</div></p>")
+  end
+
+  it "should allow you to re-enable enforcement with a block" do
+    wc = widget_class_with_content do
+      with_element_nesting_rules(false) do
+        p do
+          with_element_nesting_rules(true) do
+            div do
+              text "hi"
+            end
+          end
+        end
+      end
+    end
+
+    expect { render(wc) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should let you re-enable enforcement with a block, even across widget boundaries" do
+    outer = widget_class do
+      attr_accessor :inner
+      def content
+        with_element_nesting_rules(false) do
+          p do
+            widget inner
+          end
+        end
+      end
+    end
+
+    inner = widget_class_with_content { with_element_nesting_rules(true) { div { text "hi" } } }
+
+    outer_instance = outer.new
+    inner_instance = inner.new
+    outer_instance.inner = inner_instance
+
+    expect { render(outer_instance) }.to raise_error(Fortitude::Errors::InvalidElementNesting)
+  end
+
+  it "should raise an error if you try to enable enforcement with a block in a widget that isn't enforcing in the first place" do
+    wc = widget_class_with_content(:no_enforcement => true) do
+      with_element_nesting_rules(true) do
+        text "hi"
+      end
+    end
+
+    expect { render(wc) }.to raise_error(ArgumentError)
+  end
+
+  it "should not raise an error if you try to DISable enforcement with a block in a widget that isn't enforcing in the first place" do
+    wc = widget_class_with_content(:no_enforcement => true) do
+      with_element_nesting_rules(false) do
+        text "hi"
+      end
+    end
+
+    expect(render(wc)).to eq("hi")
+  end
+end

data/spec/system/tag_updating_system_spec.rb

@@ -0,0 +1,171 @@
+describe "Fortitude tag updating", :type => :system do
+  before :each do
+    @base_class = widget_class do
+      enforce_attribute_rules true
+      enforce_element_nesting_rules true
+
+      tag :foo, :valid_attributes => %w{bar baz}
+    end
+
+    @derived_class = widget_class(:superclass => @base_class)
+  end
+
+  it "should be enforcing rules" do
+    @base_class.class_eval do
+      def content
+        foo :something => 'whatever'
+      end
+    end
+
+    expect { render(@base_class) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should allow replacing a tag completely" do
+    @derived_class.tag :foo, :can_enclose => %w{p}
+    @derived_class.class_eval do
+      def content
+        foo :something => 'whatever' do
+          p "hi"
+        end
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<foo something=\"whatever\"><p>hi</p></foo>")
+  end
+
+  it "should not change the parent class's tag when replacing a tag completely" do
+    @derived_class.tag :foo, :can_enclose => %w{p}
+    @derived_class.class_eval do
+      def content
+        foo :something => 'whatever' do
+          p "hi"
+        end
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<foo something=\"whatever\"><p>hi</p></foo>")
+
+    @base_class.class_eval do
+      def content
+        foo :something => 'something_else'
+      end
+    end
+
+    expect { render(@base_class) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should not change the parent class's tag when modifying a tag" do
+    @derived_class.modify_tag(:foo) { |t| t.valid_attributes += %w{quux} }
+    @derived_class.class_eval do
+      def content
+        foo :quux => 'baz'
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<foo quux=\"baz\"></foo>")
+
+    @base_class.class_eval do
+      def content
+        foo :quux => 'baz'
+      end
+    end
+
+    expect { render(@base_class) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should allow modifying a tag's :valid_attributes" do
+    @derived_class.modify_tag(:foo) { |t| t.valid_attributes += %w{quux} }
+    @derived_class.class_eval do
+      def content
+        foo :quux => 'baz'
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<foo quux=\"baz\"></foo>")
+  end
+
+  it "should allow modifying a tag's :can_enclose" do
+    @derived_class.modify_tag(:div) { |t| t.can_enclose += %w{_text} }
+    @derived_class.modify_tag(:p) { |t| t.can_enclose += %w{div} }
+    @derived_class.class_eval do
+      def content
+        p do
+          div "whatever"
+        end
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<p><div>whatever</div></p>")
+  end
+
+  it "should allow modifying a tag's :newline_before" do
+    @derived_class.modify_tag(:a) { |t| t.newline_before = true }
+    @derived_class.class_eval do
+      format_output true
+
+      def content
+        p do
+          text "hello"
+          a "there"
+          text "goodbye"
+        end
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<p>\n  hello\n  <a>there</a>\n  goodbye\n</p>")
+  end
+
+  it "should allow modifying a tag's :content_allowed" do
+    @derived_class.modify_tag(:br) { |t| t.content_allowed = true }
+    @derived_class.class_eval do
+      def content
+        br "hello"
+      end
+    end
+
+    expect(render(@derived_class)).to eq("<br>hello</br>")
+  end
+
+  it "should allow modifying a tag's :allow_data_attributes" do
+    @derived_class.modify_tag(:p) { |t| t.allow_data_attributes = false }
+    @derived_class.class_eval do
+      def content
+        p :'data-foo' => 'bar'
+      end
+    end
+
+    expect { render(@derived_class) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should allow modifying a tag's :allow_aria_attributes" do
+    @derived_class.modify_tag(:p) { |t| t.allow_aria_attributes = false }
+    @derived_class.class_eval do
+      def content
+        p :'aria-foo' => 'bar'
+      end
+    end
+
+    expect { render(@derived_class) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+
+  it "should allow overriding a doctype's tags, but shouldn't modify the doctype itself" do
+    @base_class.modify_tag(:p) { |t| t.valid_attributes += %w{bonk} }
+    @base_class.class_eval do
+      def content
+        p :bonk => "whatever"
+      end
+    end
+
+    expect(render(@base_class)).to eq("<p bonk=\"whatever\"></p>")
+
+    other_widget = widget_class do
+      enforce_attribute_rules true
+
+      def content
+        p :bonk => :whatever
+      end
+    end
+
+    expect { render(other_widget) }.to raise_error(Fortitude::Errors::InvalidElementAttributes)
+  end
+end

data/spec/system/tilt_system_spec.rb

@@ -0,0 +1,382 @@
+require "tilt"
+require "fileutils"
+
+describe "Fortitude Tilt integration", :type => :system do
+  def tempdir
+    @tempdir ||= begin
+      out = File.join(File.dirname(File.dirname(File.dirname(__FILE__))), 'tmp', 'spec', 'tilt_system_spec')
+      FileUtils.rm_rf(out)
+      FileUtils.mkdir_p(out)
+      out
+    end
+  end
+
+  def splat!(filename, text)
+    full_path = File.join(tempdir, filename)
+    FileUtils.mkdir_p(File.dirname(full_path))
+    File.open(full_path, 'w') { |f| f << text }
+    full_path
+  end
+
+  def render_with_tilt(full_path, evaluation_scope = context_object, variables = { }, options = { }, &block)
+    template = Tilt.new(full_path, options)
+    template.render(evaluation_scope, variables, &block)
+  end
+
+  def render_text_with_tilt(filename, text, evaluation_scope = context_object, variables = { }, options = { }, &block)
+    full_path = splat!(filename, text)
+    render_with_tilt(full_path, evaluation_scope, variables, options, &block)
+  end
+
+  it "should render a very simple template via Tilt" do
+    text = <<-EOS
+class SimpleTemplate < Fortitude::Widgets::Html5
+  def content
+    text "this is"
+    p "a simple widget"
+    text "!"
+  end
+end
+EOS
+
+    expect(render_text_with_tilt("simple_template.rb", text)).to eq("this is<p>a simple widget</p>!")
+  end
+
+  it "should allow the Tilt template to be created with an empty string, since earlier versions of Tilt do that" do
+    expect { Fortitude::Tilt::FortitudeTemplate.new { "" } }.not_to raise_error
+  end
+
+  SIMPLE_TEMPLATE_WITH_VARIABLES = <<-EOS
+class SimpleTemplateWithVariables < Fortitude::Widgets::Html5
+  needs :foo, :bar => 'whatever'
+
+  def content
+    text "foo: \#{foo}, bar: \#{bar}"
+  end
+end
+EOS
+
+  SIMPLE_TEMPLATE_WITH_VARIABLES_NO_EXTRA_ASSIGNS = <<-EOS
+class SimpleTemplateWithVariablesNoExtraAssigns < Fortitude::Widgets::Html5
+  extra_assigns :error
+  needs :foo, :bar => 'whatever'
+
+  def content
+    text "foo: \#{foo}, bar: \#{bar}"
+  end
+end
+EOS
+
+  SIMPLE_TEMPLATE_WITH_VARIABLES_WANTS_EXTRA_ASSIGNS = <<-EOS
+class SimpleTemplateWithVariablesWantsExtraAssigns < Fortitude::Widgets::Html5
+  extra_assigns :use
+  needs :foo, :bar => 'whatever'
+
+  def content
+    text "foo: \#{foo}, bar: \#{bar}, baz: \#{assigns[:baz] || 'nil'}"
+  end
+end
+EOS
+
+  it "should pass explicit locals to the template" do
+    result = render_text_with_tilt("simple_template_with_variables.rb", SIMPLE_TEMPLATE_WITH_VARIABLES, context_object, { :foo => 'the_foo', :bar => 'the_bar' })
+    expect(result).to eq("foo: the_foo, bar: the_bar")
+  end
+
+  def context_object(variable_mappings = { }, klass = Object.class, &block)
+    out = klass.new
+    variable_mappings.each do |name, value|
+      out.instance_variable_set("@#{name}", value)
+    end
+    out.instance_eval(&block) if block
+    out
+  end
+
+  it "should make variables defined on the context object available to the template as needs" do
+    co = context_object(:foo => 'the_foo', :bar => 'the_bar')
+
+    result = render_text_with_tilt("simple_template_with_variables.rb", SIMPLE_TEMPLATE_WITH_VARIABLES, co, { })
+    expect(result).to eq("foo: the_foo, bar: the_bar")
+  end
+
+  it "should allow passing locals as strings, and overriding context-object variables" do
+    co = context_object(:foo => 'co_foo', :bar => 'co_bar')
+    result = render_text_with_tilt("simple_template_with_variables.rb", SIMPLE_TEMPLATE_WITH_VARIABLES, co, { 'bar' => 'local_bar' })
+    expect(result).to eq("foo: co_foo, bar: local_bar")
+  end
+
+  it "should allow passing locals as symbols, and overriding context-object variables" do
+    co = context_object(:foo => 'co_foo', :bar => 'co_bar')
+    result = render_text_with_tilt("simple_template_with_variables.rb", SIMPLE_TEMPLATE_WITH_VARIABLES, co, { :bar => 'local_bar' })
+    expect(result).to eq("foo: co_foo, bar: local_bar")
+  end
+
+  it "should ignore passed locals that the template doesn't actually need" do
+    result = render_text_with_tilt("simple_template_with_variables_no_extra_assigns.rb", SIMPLE_TEMPLATE_WITH_VARIABLES_NO_EXTRA_ASSIGNS,
+      context_object, { :foo => 'the_foo', :baz => 'baz!'})
+    expect(result).to eq("foo: the_foo, bar: whatever")
+  end
+
+  it "should pass extra locals if the template wants extra assigns" do
+    result = render_text_with_tilt("simple_template_with_variables_wants_extra_assigns.rb", SIMPLE_TEMPLATE_WITH_VARIABLES_WANTS_EXTRA_ASSIGNS,
+      context_object, { :foo => 'the_foo', :baz => 'baz!'})
+    expect(result).to eq("foo: the_foo, bar: whatever, baz: baz!")
+  end
+
+  it "should ignore context-object instance variables that the template doesn't actually need" do
+    result = render_text_with_tilt("simple_template_with_variables_no_extra_assigns.rb", SIMPLE_TEMPLATE_WITH_VARIABLES_NO_EXTRA_ASSIGNS,
+      context_object(:foo => 'the_foo', :baz => 'baz!'), { })
+    expect(result).to eq("foo: the_foo, bar: whatever")
+  end
+
+  it "should pass extra context-object instance variables if the template wants extra assigns" do
+    result = render_text_with_tilt("simple_template_with_variables_wants_extra_assigns.rb", SIMPLE_TEMPLATE_WITH_VARIABLES_WANTS_EXTRA_ASSIGNS,
+      context_object(:foo => 'the_foo', :baz => 'baz!'), { })
+    expect(result).to eq("foo: the_foo, bar: whatever, baz: baz!")
+  end
+
+  SHARED_VARIABLE_ACCESS = <<-EOS
+class SharedVariableAccess < Fortitude::Widgets::Html5
+  def content
+    data = shared_variables[:foo]
+    text "foo is: \#{data}"
+    shared_variables[:foo] = 'new_foo'
+  end
+end
+EOS
+
+  it "should allow instance variables on the context object to be accessed via #shared_variables" do
+    co = context_object(:foo => 'the_foo')
+    result = render_text_with_tilt("shared_variable_access.rb", SHARED_VARIABLE_ACCESS, co, { })
+    expect(result).to eq("foo is: the_foo")
+    expect(co.instance_variable_get("@foo")).to eq("new_foo")
+  end
+
+  IMPLICIT_SHARED_VARIABLE_ACCESS = <<-EOS
+class ImplicitSharedVariableAccess < Fortitude::Widgets::Html5
+  implicit_shared_variable_access true
+  def content
+    text "foo is: \#{@foo}"
+    @foo = "new_foo"
+  end
+end
+EOS
+
+  it "should allow instance variables on the context object to be read and written implicitly if implicit_shared_variable_access is set" do
+    co = context_object(:foo => 'the_foo')
+    result = render_text_with_tilt("implicit_shared_variable_access.rb", IMPLICIT_SHARED_VARIABLE_ACCESS, co, { })
+    expect(result).to eq("foo is: the_foo")
+    expect(co.instance_variable_get("@foo")).to eq("new_foo")
+  end
+
+  WIDGET_WITH_BLOCK = <<-EOS
+class WidgetWithBlock < Fortitude::Widgets::Html5
+  def content
+    data = yield("foo")
+    text "data is: \#{data}"
+  end
+end
+EOS
+
+  it "should forward the passed block to the widget" do
+    result = render_text_with_tilt("widget_with_block.rb", WIDGET_WITH_BLOCK,
+      context_object, { }) { |a| "xx#{a}yy" }
+    expect(result).to eq("data is: xxfooyy")
+  end
+
+  WIDGET_CALLING_FOO = <<-EOS
+class WidgetCallingFoo < Fortitude::Widgets::Html5
+  def content
+    val = foo("xxx")
+    text "val is: \#{val}"
+  end
+end
+EOS
+
+  it "should allow helpers defined on the context object to be invoked via automatic helper support" do
+    co = context_object do
+      def foo(x)
+        "foo#{x}foo"
+      end
+    end
+
+    result = render_text_with_tilt("widget_calling_foo.rb", WIDGET_CALLING_FOO, co, { })
+    expect(result).to eq("val is: fooxxxfoo")
+  end
+
+  WIDGET_CALLING_FOO_AHA_OFF = <<-EOS
+class WidgetCallingFooAhaOff < Fortitude::Widgets::Html5
+  automatic_helper_access false
+
+  def content
+    val = invoke_helper(:foo, "yyy")
+    text "val is: \#{val}"
+  end
+end
+EOS
+
+  it "should allow helpers defined on the context object to be invoked via explicit helper support" do
+    co = context_object do
+      def foo(x)
+        "foo#{x}foo"
+      end
+    end
+
+    result = render_text_with_tilt("widget_calling_foo_aha_off.rb", WIDGET_CALLING_FOO_AHA_OFF, co, { })
+    expect(result).to eq("val is: fooyyyfoo")
+  end
+
+  it "should not require the class name to match the filename of the widget at all" do
+    result = render_text_with_tilt("foo_bar.rb", SIMPLE_TEMPLATE_WITH_VARIABLES, context_object, { :foo => 'the_foo', :bar => 'the_bar' })
+    expect(result).to eq("foo: the_foo, bar: the_bar")
+  end
+
+  it "should still render a widget that's directly in a module (class Foo::Bar::Baz < Fortitude::Widget)" do
+    eval("module Spec1; module Bar; end; end")
+
+    text = <<-EOS
+class Spec1::Bar::Baz < Fortitude::Widgets::Html5
+  def content
+    text "hello from spec1"
+  end
+end
+EOS
+
+    expect(render_text_with_tilt("random_#{rand(1_000_000)}.rb", text, context_object, { })).to eq("hello from spec1")
+  end
+
+  it "should still render a widget that's directly in a module, of a subclass of Widget (class Foo::Bar::Baz < MyWidget)" do
+    eval("module Spec2; module Bar; end; end")
+    eval("class Spec2::Spec2Superclass < Fortitude::Widgets::Html5; end")
+
+    text = <<-EOS
+class Spec2::Bar::Baz < Spec2::Spec2Superclass
+  def content
+    text "hello from spec2"
+  end
+end
+EOS
+
+    expect(render_text_with_tilt("random_#{rand(1_000_000)}.rb", text, context_object, { })).to eq("hello from spec2")
+  end
+
+  it "should still render a widget that's in a module via namespace nesting (module Foo; module Bar; Baz < Fortitude::Widget)" do
+    text = <<-EOS
+module Spec3
+  module Bar
+    class Baz < Fortitude::Widgets::Html5
+      def content
+        text "hello from spec3"
+      end
+    end
+  end
+end
+EOS
+
+    expect(render_text_with_tilt("random_#{rand(1_000_000)}.rb", text, context_object, { })).to eq("hello from spec3")
+  end
+
+  it "should still render a widget that's in a module via namespace nesting, of a subclass of Widget (module Foo; module Bar; Baz < MyWidget)" do
+    eval("module Spec4; class Spec4Superclass < Fortitude::Widgets::Html5; end; end")
+
+    text = <<-EOS
+module Spec4
+  module Bar
+    class Baz < Fortitude::Widgets::Html5
+      def content
+        text "hello from spec4"
+      end
+    end
+  end
+end
+EOS
+
+    expect(render_text_with_tilt("random_#{rand(1_000_000)}.rb", text, context_object, { })).to eq("hello from spec4")
+  end
+
+  def impossible_to_find_class_name_text(num, insert="")
+    text = <<-EOS
+klass_name = "Spec#{num}" + "TheClass"
+c = Class.new(Fortitude::Widgets::Html5) do
+#{insert}
+  def content
+    text "hello from spec#{num}"
+  end
+end
+::Object.const_set(klass_name, c)
+EOS
+  end
+
+  it "should fail with a nice message if it can't figure out which class to render" do
+    e = capture_exception(Fortitude::Tilt::CannotDetermineTemplateClassError) do
+      render_text_with_tilt("random_#{rand(1_000_000)}.rb", impossible_to_find_class_name_text(5), context_object, { })
+    end
+
+    expect(e).to be
+    expect(e.tried_class_names).to eq([ ])
+    expect(e.message).to match(/\#\!fortitude_tilt_class/)
+    expect(e.message).to match(/:fortitude_class/)
+  end
+
+  it "should allow overriding the class that's defined in the module explicitly with an option" do
+    result = render_text_with_tilt("random_#{rand(1_000_000)}.rb", impossible_to_find_class_name_text(6), context_object, { },
+      { :fortitude_class => "Spec6TheClass" })
+    expect(result).to eq("hello from spec6")
+  end
+
+  it "should fail with a nice message if you tell it to use something that doesn't exist, using an option" do
+    e = capture_exception(Fortitude::Tilt::NotATemplateClassError) do
+      render_text_with_tilt("random_#{rand(1_000_000)}.rb", impossible_to_find_class_name_text(7), context_object, { },
+        { :fortitude_class => "NonExistent" })
+    end
+    expect(e.class_name).to eq("NonExistent")
+    expect(e.actual_object).to be_nil
+    expect(e.message).to match(/NonExistent/)
+  end
+
+  it "should fail with a nice message if you tell it to use something that isn't a class, using an option" do
+    e = capture_exception(Fortitude::Tilt::NotATemplateClassError) do
+      render_text_with_tilt("random_#{rand(1_000_000)}.rb", impossible_to_find_class_name_text(8), context_object, { },
+        { :fortitude_class => 12345 })
+    end
+    expect(e.class_name).to eq(12345)
+    expect(e.actual_object).to eq(12345)
+    expect(e.message).to match(/12345/)
+  end
+
+  it "should fail with a nice message if you tell it to use something that isn't a widget class, using an option" do
+    e = capture_exception(Fortitude::Tilt::NotATemplateClassError) do
+      render_text_with_tilt("random_#{rand(1_000_000)}.rb", impossible_to_find_class_name_text(9), context_object, { },
+        { :fortitude_class => "String" })
+    end
+    expect(e.class_name).to eq("String")
+    expect(e.actual_object).to eq(String)
+    expect(e.message).to match(/String/)
+  end
+
+  it "should allow overriding the class that's defined in the module explicitly with a comment in the template" do
+    result = render_text_with_tilt("random_#{rand(1_000_000)}.rb",
+      impossible_to_find_class_name_text(10, "#!fortitude_tilt_class: Spec10TheClass"), context_object, { })
+    expect(result).to eq("hello from spec10")
+  end
+
+  it "should fail with a nice message if you tell it to use something that isn't a class, using a comment in the template" do
+    e = capture_exception(Fortitude::Tilt::NotATemplateClassError) do
+      render_text_with_tilt("random_#{rand(1_000_000)}.rb",
+        impossible_to_find_class_name_text(11, "#!fortitude_tilt_class: 12345"), context_object, { })
+    end
+    expect(e.class_name).to eq("12345")
+    expect(e.actual_object).to be_nil
+    expect(e.message).to match(/12345/)
+  end
+
+  it "should fail with a nice message if you tell it to use something that isn't a widget class, using a comment in the template" do
+    e = capture_exception(Fortitude::Tilt::NotATemplateClassError) do
+      render_text_with_tilt("random_#{rand(1_000_000)}.rb",
+        impossible_to_find_class_name_text(12, "#!fortitude_tilt_class: String"), context_object, { })
+    end
+    expect(e.class_name).to eq("String")
+    expect(e.actual_object).to eq(String)
+    expect(e.message).to match(/String/)
+  end
+end