riot-rails 0.1.0 → 0.2.0.pre

data/test/action_controller/restful_post_request_test.rb

@@ -0,0 +1,25 @@
+require 'teststrap'
+
+context "RESTful POST request on resource" do
+
+  context GremlinsController do
+    setup { post("/gremlins", :id => 2) }
+
+    asserts("request method") { request.request_method }.equals("POST")
+    asserts("controller name") { controller.controller_name }.equals("gremlins")
+    asserts("action name") { controller.action_name }.equals("create")
+    asserts("id param") { controller.params["id"] }.equals("2")
+    asserts("response body") { response.body }.equals("makin' money")
+  end # on a top level resource
+
+  context PartiesController do
+    setup { post("/gremlins/2/parties", "id" => 3) }
+
+    asserts("request method") { request.request_method }.equals("POST")
+    asserts("controller name") { controller.controller_name }.equals("parties")
+    asserts("action name") { controller.action_name }.equals("create")
+    asserts("gremlin_id param") { controller.params["gremlin_id"] }.equals("2")
+    asserts("id param") { controller.params["id"] }.equals("3")
+    asserts("response body") { response.body }.equals("give this monkey what he wants")
+  end # on a nested resource
+end # RESTful POST request

data/test/action_controller/restful_put_request_test.rb

@@ -0,0 +1,28 @@
+require 'teststrap'
+
+context "RESTful PUT request on resource" do
+
+  context GremlinsController do
+    setup { put("/gremlins/2") }
+
+    asserts("request method") { request.request_method }.equals("PUT")
+    asserts("controller name") { controller.controller_name }.equals("gremlins")
+    asserts("action name") { controller.action_name }.equals("update")
+    asserts("id param") { controller.params["id"] }.equals("2")
+    asserts("response body") { response.body }.equals("savin' money")
+  end # on a top level resource
+
+  context PartiesController do
+    setup { put("/gremlins/2/parties/3", "foo" => "bar") }
+
+    asserts("request method") { request.request_method }.equals("PUT")
+    asserts("controller name") { controller.controller_name }.equals("parties")
+    asserts("action name") { controller.action_name }.equals("update")
+
+    asserts("gremlin_id param") { controller.params["gremlin_id"] }.equals("2")
+    asserts("id param") { controller.params["id"] }.equals("3")
+    asserts("foo param") { controller.params["foo"] }.equals("bar")
+
+    asserts("response body") { response.body }.equals("i'll put that over here")
+  end # on a nested resource
+end # RESTful PUT request

data/test/active_record/allowing_values_test.rb

@@ -0,0 +1,64 @@
+require 'teststrap'
+
+context "The allow_values_for assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when attribute allows a value") do
+    topic.allows_values_for(:email, "a@b.cd").run(Riot::Situation.new)
+  end.equals([:pass, ""])
+
+  should("pass when attribute allows multiple values") do
+    topic.allows_values_for(:email, "a@b.cd", "e@f.gh").run(Riot::Situation.new)
+  end.equals([:pass, ""])
+
+  should("fail when attribute is provided a valid and an invalid value") do
+    topic.allows_values_for(:email, "a", "e@f.gh").run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected :email to allow values ["a"]}, blah, blah])
+end # The allow_values_for assertion macro
+
+context "The does_not_allow_values_for assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when attribute does not allow a value") do
+    topic.does_not_allow_values_for(:email, "a").run(Riot::Situation.new)
+  end.equals([:pass, ""])
+
+  should("pass when attribute does not allow multiple values") do
+    topic.does_not_allow_values_for(:email, "a", "e").run(Riot::Situation.new)
+  end.equals([:pass, ""])
+
+  should("fail when attribute is provided a valid and an invalid value") do
+    topic.does_not_allow_values_for(:email, "a", "e@f.gh").run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected :email not to allow values ["e@f.gh"]}, blah, blah])
+end # The does_not_allow_values_for assertion macro
+
+context "The is_invalid_when assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when attribute is invalid") do
+    topic.is_invalid_when(:email, "fake").run(Riot::Situation.new)
+  end.equals([:pass, %Q{attribute :email is invalid}])
+
+  should("pass when error message equals one in its list of errors") do
+    topic.is_invalid_when(:email, "fake", "is invalid").run(Riot::Situation.new)
+  end.equals([:pass, %Q{attribute :email is invalid}])
+
+  should("pass when error message matches one in its list of errors") do
+    topic.is_invalid_when(:email, "fake", /invalid/).run(Riot::Situation.new)
+  end.equals([:pass, %Q{attribute :email is invalid}])
+
+  should("fail when attribute is valid") do
+    topic.is_invalid_when(:email, "a@b.cd", "is invalid").run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected :email to be invalid when value is "a@b.cd"}, blah, blah])
+
+  should("fail when exact error message not found") do
+    topic.is_invalid_when(:email, "fake", "can't be blank").run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected :email to be invalid with error message "can't be blank"}, blah, blah])
+
+  should("fail when error message not matched to returned errors") do
+    topic.is_invalid_when(:email, "fake", /blank/).run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected :email to be invalid with error message /blank/}, blah, blah])
+end # The is_invalid_when assertion macro

data/test/active_record/attribute_is_invalid_test.rb

@@ -0,0 +1,20 @@
+require 'teststrap'
+
+context "The attribute_is_invalid macro" do
+  setup_test_context
+
+  should("fail when attribute is not invalid") do
+    assertion = topic.asserts("room") { Room.new(:location => "barn burner") }
+    assertion.attribute_is_invalid(:location, "not yet").run(Riot::Situation.new)
+  end.equals([:fail, ":location expected to be invalid", blah, blah])
+
+  should("fail when attribute is invalid, but the message could not be found") do
+    assertion = topic.asserts("room") { Room.new }
+    assertion.attribute_is_invalid(:location, "child please").run(Riot::Situation.new)
+  end.equals([:fail, %Q{:location is invalid, but "child please" is not a valid error message}, blah, blah])
+
+  should("pass when attribute is invalid and error message is found") do
+    assertion = topic.asserts("room") { Room.new }
+    assertion.attribute_is_invalid(:location, "can't be blank").run(Riot::Situation.new)
+  end.equals([:pass, %Q{:location is invalid}])
+end # The attribute_is_invalid macro

data/test/active_record/belongs_to_test.rb

@@ -0,0 +1,22 @@
+require 'teststrap'
+
+context "The belongs_to assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when record has a belongs_to association defined for attribute") do
+    topic.belongs_to(:house).run(Riot::Situation.new)
+  end.equals([:pass, ":house is a belongs_to association"])
+
+  should("fail when record does not have a belongs_to association defined for attribute") do
+    topic.belongs_to(:someone_else).run(Riot::Situation.new)
+  end.equals([:fail, ":someone_else is not a belongs_to association", blah, blah])
+
+  should("fail when attribute is not a belongs_to, but is a has_one association") do
+    topic.belongs_to(:floor).run(Riot::Situation.new)
+  end.equals([:fail, ":floor is not a belongs_to association", blah, blah])
+
+  should("fail when association options are specified, but they do not match the record") do
+    topic.belongs_to(:owner, :class_name => "Person").run(Riot::Situation.new)
+  end.equals([:fail, %q[expected belongs_to :owner with {:class_name=>"Person"}], blah, blah])
+end # The has_many assertion macro

data/test/active_record/context_middleware_test.rb

@@ -0,0 +1,18 @@
+require 'teststrap'
+
+context "ActiveRecord middleware" do
+  setup_test_context
+
+  setup do
+    situation = Riot::Situation.new
+    topic.context(Room) do
+      hookup { topic.email = "i.am@chee.se" }
+    end.local_run(Riot::SilentReporter.new, situation)
+    situation.topic
+  end
+
+  asserts_topic.kind_of(Room)
+  asserts(:new_record?)
+  asserts(:email).equals("i.am@chee.se")
+
+end # ActiveRecord middleware

data/test/active_record/has_and_belongs_to_many_test.rb

@@ -0,0 +1,22 @@
+require 'teststrap'
+
+context "The has_and_belongs_to_many assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when record has a has_and_belongs_to_many association defined for attribute") do
+    topic.has_and_belongs_to_many(:walls).run(Riot::Situation.new)
+  end.equals([:pass, ":walls is a has_and_belongs_to_many association"])
+
+  should("fail when record does not have a has_and_belongs_to_many association defined for attribute") do
+    topic.has_and_belongs_to_many(:windows).run(Riot::Situation.new)
+  end.equals([:fail, ":windows is not a has_and_belongs_to_many association", blah, blah])
+
+  should("fail when attribute is not a has_and_belongs_to_many, but is a has_many association") do
+    topic.has_and_belongs_to_many(:doors).run(Riot::Situation.new)
+  end.equals([:fail, ":doors is not a has_and_belongs_to_many association", blah, blah])
+
+  should("fail when association options are specified, but they do not match the record") do
+    topic.has_and_belongs_to_many(:walls, :join_table => "blueprints").run(Riot::Situation.new)
+  end.equals([:fail, %q[expected has_and_belongs_to_many :walls with {:join_table=>"blueprints"}], blah, blah])
+end # The has_and_belongs_to_many assertion macro

data/test/active_record/has_database_index_on_test.rb

@@ -0,0 +1,73 @@
+require 'teststrap'
+require 'ostruct'
+
+context "The has_database_index_on macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  hookup do
+    MockConnection = Class.new do
+      def initialize(index_lookup) @index_lookup = index_lookup; end
+      def indexes(table) @index_lookup[table]; end
+    end
+
+    def build_assertion(table, columns, unique=false)
+      database_connection = MockConnection.new({table => [ define_index(table, columns, unique) ]})
+      # I'll inject your dependency! ;)
+      RiotRails::ActiveRecord::HasDatabaseIndexOnMacro.new(database_connection)
+    end
+
+    def define_index(table, columns, unique)
+      ActiveRecord::ConnectionAdapters::IndexDefinition.new(table, columns.join(','), unique, columns)
+    end
+  end
+
+  should("fail when no index for column") do
+    topic.has_database_index_on(:foo).run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected index on [:foo]}, blah, blah])
+
+  should("fail when no index for column set") do
+    topic.has_database_index_on(:foo, :bar).run(Riot::Situation.new)
+  end.equals([:fail, %Q{expected index on [:foo, :bar]}, blah, blah])
+
+  should("fail when index found for column, but it's not unique") do
+    build_assertion("rooms", ["foo"], false).
+      evaluate(Room.new, :foo, :unique => true)
+  end.equals([:fail, %Q{expected unique index on [:foo]}, blah, blah])
+
+  should("fail when index found for column, but it's unique and should not be") do
+    build_assertion("rooms", ["foo"], true).
+      evaluate(Room.new, :foo, :unique => false)
+  end.equals([:fail, %Q{expected index on [:foo]}, blah, blah])
+
+  should("pass when index found for column") do
+    build_assertion("rooms", ["foo"], false).
+      evaluate(Room.new, :foo)
+  end.equals([:pass, %Q{has index on [:foo]}])
+
+  should("pass when index found for column set") do
+    build_assertion("rooms", ["foo", "bar"], false).
+      evaluate(Room.new, :foo, :bar)
+  end.equals([:pass, %Q{has index on [:foo, :bar]}])
+
+  should("pass when unique index found for column") do
+    build_assertion("rooms", ["foo"], true).
+      evaluate(Room.new, :foo, :unique => true)
+  end.equals([:pass, %Q{has unique index on [:foo]}])
+
+  should("pass when unique index found for column set") do
+    build_assertion("rooms", ["foo", "bar"], true).
+      evaluate(Room.new, :foo, :bar, :unique => true)
+  end.equals([:pass, %Q{has unique index on [:foo, :bar]}])
+
+  should("pass when non-unique index found for column") do
+    build_assertion("rooms", ["foo"], false).
+      evaluate(Room.new, :foo, :unique => false)
+  end.equals([:pass, %Q{has index on [:foo]}])
+
+  should("pass when non-unique index found for column set") do
+    build_assertion("rooms", ["foo", "bar"], false).
+      evaluate(Room.new, :foo, :bar, :unique => false)
+  end.equals([:pass, %Q{has index on [:foo, :bar]}])
+
+end # The attribute_is_invalid macro

data/test/active_record/has_many_test.rb

@@ -0,0 +1,22 @@
+require 'teststrap'
+
+context "The has_many assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when record has a has_many association defined for attribute") do
+    topic.has_many(:doors).run(Riot::Situation.new)
+  end.equals([:pass, ":doors is a has_many association"])
+
+  should("fail when record does not have a has_many association defined for attribute") do
+    topic.has_many(:windows).run(Riot::Situation.new)
+  end.equals([:fail, ":windows is not a has_many association", blah, blah])
+
+  should("fail when attribute is not a has_many, but is a has_one association") do
+    topic.has_many(:floor).run(Riot::Situation.new)
+  end.equals([:fail, ":floor is not a has_many association", blah, blah])
+
+  should("fail when association options are specified, but they do not match the record") do
+    topic.has_many(:doors, :class_name => "Portal").run(Riot::Situation.new)
+  end.equals([:fail, %q[expected has_many :doors with {:class_name=>"Portal"}], blah, blah])
+end # The has_many assertion macro

data/test/active_record/has_one_test.rb

@@ -0,0 +1,22 @@
+require 'teststrap'
+
+context "The has_one assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when record has a has_one association defined for attribute") do
+    topic.has_one(:floor).run(Riot::Situation.new)
+  end.equals([:pass, ":floor is a has_one association"])
+
+  should("fail when record does not have a has_one association defined for attribute") do
+    topic.has_one(:windows).run(Riot::Situation.new)
+  end.equals([:fail, ":windows is not a has_one association", blah, blah])
+
+  should("fail when attribute is not a has_one, but is a has_many association") do
+    topic.has_one(:doors).run(Riot::Situation.new)
+  end.equals([:fail, ":doors is not a has_one association", blah, blah])
+
+  should("fail when association options are specified, but they do not match the record") do
+    topic.has_one(:floor, :class_name => "Surface").run(Riot::Situation.new)
+  end.equals([:fail, %q[expected has_one :floor with {:class_name=>"Surface"}], blah, blah])
+end # The has_one assertion macro

data/test/active_record/validates_length_of_test.rb

@@ -0,0 +1,31 @@
+require 'teststrap'
+
+context "The validates_length_of assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("fail when minimum length causes an error") do
+    topic.validates_length_of(:name, (4..15)).run(Riot::Situation.new)
+  end.equals([:fail, ":name should be able to be 4 characters", blah, blah])
+
+  should("fail when value less than minimum value does not cause an error") do
+    topic.validates_length_of(:name, (6..15)).run(Riot::Situation.new)
+  end.equals([:fail, ":name expected to be more than 5 characters", blah, blah])
+
+  should("fail when maximum length causes an error") do
+    topic.validates_length_of(:name, (5..21)).run(Riot::Situation.new)
+  end.equals([:fail, ":name should be able to be 21 characters", blah, blah])
+
+  should("fail when value greater than maximum value does not cause an error") do
+    topic.validates_length_of(:name, (5..19)).run(Riot::Situation.new)
+  end.equals([:fail, ":name expected to be less than 20 characters", blah, blah])
+
+  should("pass when only a value can only be within the specific range") do
+    topic.validates_length_of(:name, (5..20)).run(Riot::Situation.new)
+  end.equals([:pass, "validates length of :name is within 5..20"])
+
+  should("pass even when minimum value is zero") do
+    topic.validates_length_of(:contents, (0..100)).run(Riot::Situation.new)
+  end.equals([:pass, "validates length of :contents is within 0..100"])
+
+end # The validates_length_of assertion macro

data/test/active_record/validates_presence_of_test.rb

@@ -0,0 +1,14 @@
+require 'teststrap'
+
+context "The validates_presence_of assertion macro" do
+  setup_test_context
+  setup { topic.asserts("room") { Room.new } }
+
+  should("pass when attribute requires presence") do
+    topic.validates_presence_of(:location).run(Riot::Situation.new)
+  end.equals([:pass, "validates presence of :location"])
+
+  should("fail when attribute does not require presence") do
+    topic.validates_presence_of(:contents).run(Riot::Situation.new)
+  end.equals([:fail, "expected to validate presence of :contents", blah, blah])
+end # The validates_presence_of assertion macro

data/test/active_record/validates_uniqueness_of_test.rb

@@ -0,0 +1,23 @@
+require 'teststrap'
+
+context "The validates_uniqueness_of assertion macro" do
+  setup_test_context
+
+  should("fail without a persisted record") do
+    topic.asserts("room") do
+      Room.new(:email => "foo@bar.baz")
+    end.validates_uniqueness_of(:email).run(Riot::Situation.new)
+  end.equals([:fail, "must use a persisted record when testing uniqueness of :email", blah, blah])
+
+  should("pass with a persisted record") do
+    topic.asserts("room") do
+      Room.create_with_good_data(:email => "foo@bar.baz")
+    end.validates_uniqueness_of(:email).run(Riot::Situation.new)
+  end.equals([:pass, ":email is unique"])
+
+  should("fail with a persisted record but not validating uniqueness") do
+    topic.asserts("room") do
+      Room.create_with_good_data(:email => "goo@car.caz")
+    end.validates_uniqueness_of(:foo).run(Riot::Situation.new)
+  end.equals([:fail, "expected to fail because :foo is not unique", blah, blah])
+end # The validates_uniqueness_of assertion macro

data/test/rails_root/app/controllers/gremlins_controller.rb

@@ -0,0 +1,21 @@
+class GremlinsController < ActionController::Base
+  def index
+    render :text => "bar"
+  end
+
+  def show
+    render :text => "show me the money"
+  end
+
+  def create
+    render :text => "makin' money"
+  end
+
+  def update
+    render :text => "savin' money"
+  end
+
+  def destroy
+    render :text => "spendin' money"
+  end
+end

data/test/rails_root/app/controllers/parties_controller.rb

@@ -0,0 +1,17 @@
+class PartiesController < ActionController::Base
+  def show
+    render :text => "woot"
+  end
+
+  def create
+    render :text => "give this monkey what he wants"
+  end
+
+  def update
+    render :text => "i'll put that over here"
+  end
+
+  def destroy
+    render :text => "all gone"
+  end
+end

data/test/rails_root/app/controllers/rooms_controller.rb

@@ -0,0 +1,22 @@
+class RoomsController < ActionController::Base
+  def index
+    render :text => "foo"
+  end
+
+  def create
+    render :text => "created #{params.inspect}"
+  end
+
+  def update
+    render :text => "updated #{params.inspect}"
+  end
+
+  def destroy
+    render :text => "destroyed #{params.inspect}"
+  end
+
+  def echo_params
+    serialized_params = (params.keys - ["action"]).sort.map {|k| "#{k}=#{params[k]}" }.join(",")
+    render :text => serialized_params
+  end
+end

data/test/rails_root/config/database.yml

@@ -0,0 +1,4 @@
+test:
+  adapter: "sqlite3"
+  database: <%= Rails.root + "db" + "test.db" %>
+

data/test/rails_root/config/environment.rb

@@ -0,0 +1,46 @@
+ENV['RAILS_ENV'] = 'test'
+
+require 'sqlite3'
+require "active_record/railtie"
+require "action_controller/railtie"
+# require "action_mailer/railtie"
+# require "active_resource/railtie"
+
+module RiotRails
+  class Application < Rails::Application
+    config.root = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+
+    config.session_store :cookie_store, {:key => "_riotrails_session"}
+    config.secret_token = "i own you." * 3
+  end
+end
+
+RiotRails::Application.initialize!
+
+require File.join(Rails.root, "config", "routes.rb")
+
+# Logging stuff
+
+class NilIO
+  def write(*args); end
+  def close(*args); end
+  def puts(*args); end
+  def path; nil; end
+  def fsync; 0; end
+  def to_s; "hello"; end
+  def sync; true; end
+  def sync=(arg); arg; end
+end
+
+def shhh(&block)
+  orig_out = $stdout
+  $stdout = NilIO.new
+  yield
+  $stdout = orig_out
+end
+
+shhh do
+  load(File.join(Rails.root, "db", "schema.rb"))
+end
+
+ActiveRecord::Base.logger = Logger.new(NilIO.new)

data/test/rails_root/config/routes.rb

@@ -0,0 +1,7 @@
+RiotRails::Application.routes.draw do |map|
+  resources :gremlins do
+    resources :parties
+  end
+
+  match ':controller(/:action(/:id(.:format)))'
+end

data/test/rails_root/db/schema.rb

@@ -0,0 +1,8 @@
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :rooms, :force => true do |t|
+    t.string :location
+    t.string :email
+    t.string :contents
+    t.string :name
+  end
+end

data/test/teststrap.rb

@@ -0,0 +1,84 @@
+require 'rubygems'
+require 'pathname'
+require 'ostruct'
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+#
+# Setup faux Rails environment
+
+require(Pathname(__FILE__).dirname + 'rails_root' + 'config' + 'environment')
+
+#
+# Model definition
+
+class Room < ActiveRecord::Base
+  validates_presence_of :location
+  validates_format_of :email, :with => /^\w+@\w+\.\w+$/
+  validates_uniqueness_of :email
+  validates_length_of :name, :within => 5..20
+  validates_length_of :contents, :within => 0..100, :allow_blank => true
+
+  has_many :doors, :class_name => 'Porthole'
+  has_one :floor, :class_name => "Substrate"
+  has_and_belongs_to_many :walls, :join_table => "floorplans"
+  belongs_to :house
+  belongs_to :owner, :class_name => 'SomethingElse'
+
+  def self.create_with_good_data(attributes={})
+    create!({:location => "a", :email => "a@b.c", :name => "Junior"}.merge(attributes))
+  end
+end
+
+#
+# Blah == anything, whatever. Always passes an equality test
+
+class Blah
+  def ==(o) true; end
+  def inspect; "<blah>"; end
+  alias :to_s :inspect
+end
+
+class Object
+  def blah; Blah.new; end
+end
+
+#
+# Riot setup
+
+require 'riot/rails'
+require 'riot/active_record'
+require 'riot/action_controller'
+
+Riot.dots if ENV["TM_MODE"]
+
+module RiotRails
+  module Context
+    def setup_test_context(context_description="test context")
+      setup { Riot::Context.new(context_description) {} }
+    end
+
+    def setup_for_assertion_test(&block)
+      hookup { topic.setup(&block).run(@situation) }
+    end
+
+    def hookup_for_assertion_test(&block)
+      hookup { topic.hookup(&block).run(@situation) }
+    end
+
+    def assertion_test_passes(description, success_message="", &block)
+      should("pass #{description}") do
+        instance_eval(&block).run(@situation)
+      end.equals([:pass, success_message])
+    end
+
+    def assertion_test_fails(description, failure_message, &block)
+      should("fail #{description}") do
+        instance_eval(&block).run(@situation)
+      end.equals([:fail, failure_message, blah, blah])
+    end
+
+  end # Context
+end # RiotRails
+
+Riot::Context.instance_eval { include RiotRails::Context }

data/test/transactional_middleware_test.rb

@@ -0,0 +1,27 @@
+require 'teststrap'
+
+context "Transactional middleware" do
+  hookup do
+    ActiveRecord::Base.instance_eval do
+      # Hijacking transaction and just letting stuff fall through
+      def transaction(&block) yield; end
+    end
+  end
+
+  context "when :transactional is set to true" do
+    setup { Riot::Context.new("Room") { set(:transactional, true) } }
+  
+    asserts("executing context") do
+      topic.local_run(Riot::SilentReporter.new, Riot::Situation.new)
+    end.raises(ActiveRecord::Rollback)
+  end # when :transactional is set to true
+
+  context "when :transactional is not set to true" do
+    setup { Riot::Context.new("Room") {} }
+  
+    asserts("executing context does not raise errors") do
+      topic.local_run(Riot::SilentReporter.new, Riot::Situation.new)
+    end.exists
+  end # when :transactional is not set
+  
+end # Transactional middleware