riot-rails 0.0.10.pre.3 → 0.1.0

data/test/action_controller/restful_get_request_test.rb

@@ -1,25 +0,0 @@
-require 'teststrap'
-
-context "RESTful GET request on resource" do
-
-  context GremlinsController do
-    setup { get("/gremlins/1") }
-
-    asserts("request method") { request.request_method }.equals("GET")
-    asserts("controller name") { controller.controller_name }.equals("gremlins")
-    asserts("action name") { controller.action_name }.equals("show")
-    asserts("id param") { controller.params["id"] }.equals("1")
-    asserts("response body") { response.body }.equals("show me the money")
-  end # on a top level resource
-
-  context PartiesController do
-    setup { get("/gremlins/1/parties/2") }
-
-    asserts("request method") { request.request_method }.equals("GET")
-    asserts("controller name") { controller.controller_name }.equals("parties")
-    asserts("action name") { controller.action_name }.equals("show")
-    asserts("gremlin_id param") { controller.params["gremlin_id"] }.equals("1")
-    asserts("id param") { controller.params["id"] }.equals("2")
-    asserts("response body") { response.body }.equals("woot")
-  end # on a nested resource
-end # RESTful GET request

data/test/action_controller/restful_post_request_test.rb

@@ -1,25 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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