spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/test/functional/test_user_manager.rb

@@ -5,22 +5,19 @@ require File.expand_path('../../test_helper', __FILE__)
 # set :environment, :test
 
 
-class UserAdminTest < MiniTest::Spec
-  include ::Rack::Test::Methods
+describe "UserAdmin" do
+  include RackTestMethods
 
-  def self.site_root
-    @site_root
-  end
-
-  def self.startup
+  start do
     S::Permissions::User.delete
-    @site_root = Dir.mktmpdir
+    site_root = Dir.mktmpdir
     app_root = File.expand_path('../../fixtures/user_manager', __FILE__)
-    FileUtils.cp_r(app_root + "/", @site_root)
-    @site_root += "/user_manager"
+    FileUtils.cp_r(app_root + "/", site_root)
+    site_root += "/user_manager"
+    let(:site_root) { site_root }
   end
 
-  def self.shutdown
+  finish do
     teardown_site(true)
   end
 
@@ -28,8 +25,12 @@ class UserAdminTest < MiniTest::Spec
     Spontaneous::Rack::Back.application
   end
 
-  def setup
-    @site = setup_site(self.class.site_root)
+  def api_key
+    @key
+  end
+
+  before do
+    @site = setup_site(site_root)
     Spot::Permissions::UserLevel.reset!
     Spot::Permissions::UserLevel.init!
     @editor_user = create_user("editor", S::Permissions[:editor])
@@ -41,7 +42,7 @@ class UserAdminTest < MiniTest::Spec
     assert @root_user.level   == S::Permissions[:root]
   end
 
-  def teardown
+  after do
     teardown_site(false)
     S::Permissions::User.delete
   end
@@ -57,222 +58,196 @@ class UserAdminTest < MiniTest::Spec
     user
   end
 
-  def login_user(user, params={})
-    post "/@spontaneous/login", {"user[login]" => user.login, "user[password]" => user.password}.merge(params)
-    @user = user
-  end
-
-  def auth_post(path, params={})
-    key = @user.access_keys.first
-    post(path, params.merge("__key" => key.key_id))
-  end
-
-  def auth_put(path, params={})
-    key = @user.access_keys.first
-    put(path, params.merge("__key" => key.key_id))
-  end
-
-  def auth_get(path, params={})
-    key = @user.access_keys.first
-    get(path, params.merge("__key" => key.key_id))
-  end
-
-  def auth_del(path, params = {})
-    key = @user.access_keys.first
-    delete(path, params.merge("__key" => key.key_id))
-  end
-
-
-  context "Access to User admin" do
-    should "be denied to unauthorised requests" do
+  describe "Access to User admin" do
+    it "be denied to unauthorised requests" do
       get "/@spontaneous/users"
       assert last_response.status == 401, "Expected 401 but got #{ last_response.status }"
     end
 
-    should "be denied to users without the admin flag" do
+    it "be denied to users without the admin flag" do
       login_user(@editor_user)
       auth_get "/@spontaneous/users"
       assert last_response.status == 403, "Expected 403 but got #{ last_response.status }"
     end
 
-    should "be granted to users with the admin flag" do
+    it "be granted to users with the admin flag" do
       login_user(@admin_user)
       auth_get "/@spontaneous/users"
       assert last_response.status == 200, "Expected 200 but got #{ last_response.status }"
     end
 
-    should "be granted to root users" do
+    it "be granted to root users" do
       login_user(@root_user)
       auth_get "/@spontaneous/users"
       assert last_response.status == 200, "Expected 200 but got #{ last_response.status }"
     end
   end
 
-  context "User application" do
-    setup do
+  describe "User application" do
+    before do
       login_user(@admin_user)
     end
 
-    should "return serialised list of current users" do
+    it "return serialised list of current users" do
       auth_get "/@spontaneous/users"
       result = S::JSON.parse last_response.body
-      result.should == S::Permissions::User.export(@user)
+      result.must_equal S::Permissions::User.export(@user)
     end
 
-    should "allow user details to be updated" do
+    it "allow user details to be updated" do
       auth_put "/@spontaneous/users/#{@editor_user.id}", {  "user[name]" => "Robert Something", "user[login]" => "robert", "user[email]" => "robert@example.org" }
       assert last_response.ok?, "Recieved a #{ last_response.status } instead of a 200"
-      @editor_user.reload.login.should == "robert"
+      @editor_user.reload.login.must_equal "robert"
     end
 
-    should "allow a users level to be changed" do
+    it "allow a users level to be changed" do
       auth_put "/@spontaneous/users/#{@editor_user.id}", {  "user[name]" => "Robert Something", "user[login]" => "robert", "user[email]" => "robert@example.org", "user[level]" => "admin" }
       assert last_response.ok?, "Recieved a #{ last_response.status } instead of a 200"
-      @editor_user.reload.level.should == @admin_user.level
+      @editor_user.reload.level.must_equal @admin_user.level
     end
 
-    should "reject updates that change the level above the current user's" do
+    it "reject updates that change the level above the current user's" do
       level = @editor_user.level
       auth_put "/@spontaneous/users/#{@editor_user.id}", {  "user[name]" => "Robert Something", "user[login]" => "robert", "user[email]" => "robert@example.org", "user[level]" => "root" }
       assert last_response.status == 403, "Recieved a #{ last_response.status } instead of a 403"
-      @editor_user.reload.level.should == level
+      @editor_user.reload.level.must_equal level
     end
 
-    should "reject an update with a conflicting login" do
+    it "reject an update with a conflicting login" do
       auth_put "/@spontaneous/users/#{@editor_user.id}", {  "user[name]" => "Robert Something", "user[login]" => "admin", "user[email]" => "robert@example.org" }
       assert last_response.status == 422, "Recieved a #{ last_response.status } instead of a 422"
-      @editor_user.reload.login.should == "editor"
+      @editor_user.reload.login.must_equal "editor"
       result = S::JSON.parse last_response.body
       result.must_be_instance_of Hash
-      result[:login].should_not be_nil
+      result[:login].wont_be_nil
     end
 
-    should "reject an update with an invalid email" do
+    it "reject an update with an invalid email" do
       email = @editor_user.email
       auth_put "/@spontaneous/users/#{@editor_user.id}", {  "user[name]" => "Robert Something", "user[login]" => "editor", "user[email]" => "robert" }
       assert last_response.status == 422, "Recieved a #{ last_response.status } instead of a 422"
-      @editor_user.reload.email.should == email
+      @editor_user.reload.email.must_equal email
       result = S::JSON.parse last_response.body
       result.must_be_instance_of Hash
-      result[:email].should_not be_nil
+      result[:email].wont_be_nil
     end
 
-    should "allow updating of the user's password" do
+    it "allow updating of the user's password" do
       new_pass = "123467890"
       auth_put "/@spontaneous/users/password/#{@editor_user.id}", {  "password" => new_pass }
       assert last_response.ok?, "Recieved status #{ last_response.status} instead of 200"
       key = Spontaneous::Permissions::User.authenticate(@editor_user.login, new_pass, "127.0.0.1")
-      key.should_not be_nil
+      key.wont_be_nil
     end
 
-    should "reject & return error for invalid passwords" do
+    it "reject & return error for invalid passwords" do
       new_pass = "1234"
       auth_put "/@spontaneous/users/password/#{@editor_user.id}", {  "password" => new_pass }
       assert last_response.status == 422, "Recieved a #{ last_response.status } instead of a 422"
       key = Spontaneous::Permissions::User.authenticate(@editor_user.login, new_pass, "127.0.0.1")
-      key.should be_nil
+      key.must_be_nil
       result = S::JSON.parse last_response.body
       result.must_be_instance_of Hash
-      result[:password].should_not be_nil
+      result[:password].wont_be_nil
     end
 
-    should "not allow changing details of users with higher level" do
+    it "not allow changing details of users with higher level" do
       auth_put "/@spontaneous/users/#{@root_user.id}", {  "user[name]" => "Robert Something", "user[login]" => "robert", "user[email]" => "robert@example.org" }
       assert last_response.status == 403, "Recieved a #{ last_response.status } instead of a 403"
-      @root_user.reload.login.should == "root"
+      @root_user.reload.login.must_equal "root"
     end
 
-    # should "allow admins to reset their password"
-    should "enable a force-logout of a user by deleting their keys" do
+    # it "allow admins to reset their password"
+    it "enable a force-logout of a user by deleting their keys" do
       3.times do |n|
         @editor_user.generate_access_key("203.99.33.#{n}")
       end
-      @editor_user.access_keys.length.should == 3
+      @editor_user.access_keys.length.must_equal 3
       auth_del "/@spontaneous/users/keys/#{@editor_user.id}"
       assert last_response.ok?, "Recieved status #{ last_response.status} instead of 200"
-      @editor_user.reload.access_keys.length.should == 0
+      @editor_user.reload.access_keys.length.must_equal 0
     end
 
-    should "not allow logging out of user with higher level" do
+    it "not allow logging out of user with higher level" do
       3.times do |n|
         @root_user.generate_access_key("203.99.33.#{n}")
       end
-      @root_user.access_keys.length.should == 3
+      @root_user.access_keys.length.must_equal 3
       auth_del "/@spontaneous/users/keys/#{@root_user.id}"
       assert last_response.status == 403, "Recieved a #{ last_response.status } instead of a 403"
-      @root_user.reload.access_keys.length.should == 3
+      @root_user.reload.access_keys.length.must_equal 3
     end
 
-    should "allow you to disable a user" do
-      @editor_user.disabled?.should be_false
+    it "allow you to disable a user" do
+      refute @editor_user.disabled?
       auth_put "/@spontaneous/users/disable/#{@editor_user.id}"
       assert last_response.ok?
-      @editor_user.reload.disabled?.should be_true
+      assert @editor_user.reload.disabled?
     end
 
-    should "allow you to re-enable a user" do
-      @editor_user.disabled?.should be_false
+    it "allow you to re-enable a user" do
+      refute @editor_user.disabled?
       @editor_user.disable!
       auth_put "/@spontaneous/users/enable/#{@editor_user.id}"
       assert last_response.ok?
-      @editor_user.reload.disabled?.should be_false
+      refute @editor_user.reload.disabled?
     end
 
-    should "not allow you to disable a user with a higher user level" do
-      @root_user.disabled?.should be_false
+    it "not allow you to disable a user with a higher user level" do
+      refute @root_user.disabled?
       auth_put "/@spontaneous/users/disable/#{@root_user.id}"
       assert last_response.status == 403, "Recieved a #{ last_response.status } instead of a 403"
-      @root_user.reload.disabled?.should be_false
+      refute @root_user.reload.disabled?
     end
 
-    should "allow for the creation of new users" do
+    it "allow for the creation of new users" do
       auth_post "/@spontaneous/users", {  "user[name]" => "Robert Something", "user[login]" => "robert", "user[email]" => "robert@example.org", "user[password]" => "robertpass", "user[level]" => "admin" }
       assert last_response.ok?, "Recieved status #{ last_response.status} instead of 200"
       user = S::Permissions::User[:login => "robert"]
       user.must_be_instance_of S::Permissions::User
-      user.name.should == "Robert Something"
-      user.email.should == "robert@example.org"
-      user.level.should == Spontaneous::Permissions[:admin]
+      user.name.must_equal "Robert Something"
+      user.email.must_equal "robert@example.org"
+      user.level.must_equal Spontaneous::Permissions[:admin]
       key = Spontaneous::Permissions::User.authenticate("robert", "robertpass", "127.0.0.1")
       key.must_be_instance_of S::Permissions::AccessKey
-      key.user.id.should == user.id
+      key.user.id.must_equal user.id
     end
 
-    should "return user info on account creation" do
+    it "return user info on account creation" do
       auth_post "/@spontaneous/users", {  "user[name]" => "Robert Something", "user[login]" => "robert", "user[email]" => "robert@example.org", "user[password]" => "robertpass", "user[level]" => "admin" }
       assert last_response.ok?, "Recieved status #{ last_response.status} instead of 200"
       result = S::JSON.parse last_response.body
-      result[:id].should_not be_nil
+      result[:id].wont_be_nil
       user = S::Permissions::User[result[:id]]
-      result.should == S::Permissions::User.export_user(user)
+      result.must_equal S::Permissions::User.export_user(user)
     end
 
-    should "not allow creation of users with higher level" do
+    it "not allow creation of users with higher level" do
       users = S::Permissions::User.count
       auth_post "/@spontaneous/users", {  "user[name]" => "Robert Something", "user[login]" => "robert", "user[email]" => "robert@example.org", "user[password]" => "robertpass", "user[level]" => "root" }
       assert last_response.status == 403, "Recieved a #{ last_response.status } instead of a 403"
-      S::Permissions::User.count.should == users
+      S::Permissions::User.count.must_equal users
     end
 
-    should "return an error if passed invalid user attributes" do
+    it "return an error if passed invalid user attributes" do
       users = S::Permissions::User.count
       auth_post "/@spontaneous/users", {  "user[name]" => "Robert Something", "user[login]" => "admin", "user[email]" => "robert", "user[password]" => "pass", "user[level]" => "editor" }
       assert last_response.status == 422, "Recieved a #{ last_response.status } instead of a 422"
-      S::Permissions::User.count.should == users
+      S::Permissions::User.count.must_equal users
     end
 
-    should "allow us to delete a user" do
+    it "allow us to delete a user" do
       auth_del "/@spontaneous/users/#{@editor_user.id}"
       assert last_response.status == 200, "Recieved a #{ last_response.status } instead of a 200"
       user = Spontaneous::Permissions::User[:login => @editor_user.login]
-      user.should be_nil
+      user.must_be_nil
     end
 
-    should "not allow us to delete a user with a higher user level" do
+    it "not allow us to delete a user with a higher user level" do
       auth_del "/@spontaneous/users/#{@root_user.id}"
       assert last_response.status == 403, "Recieved a #{ last_response.status } instead of a 403"
       user = Spontaneous::Permissions::User[:login => @root_user.login]
-      user.should_not be_nil
+      user.wont_be_nil
     end
   end
 end

data/test/integration/test_installation.rb

@@ -72,7 +72,7 @@ class SpontaneousInstallationTest < OrderedTestCase
   end
 
   def test_step_001__gem_installation
-    assert_raises "Precondition failed, spontaneous gem is already installed", Gem::LoadError do
+    assert_raises Gem::LoadError, "Precondition failed, spontaneous gem is already installed" do
       Gem::Specification.find_by_name("spontaneous")
     end
     system "gem install #{$_gem} --no-rdoc --no-ri"

data/test/support/matchers.rb

@@ -0,0 +1,12 @@
+require 'set'
+
+module MiniTest
+  module Assertions
+    def assert_has_elements(exp, act, msg = nil)
+      msg = message(msg) { "Expected #{act} to have same elements as #{exp}" }
+      assert Set.new(exp) == Set.new(act)
+    end
+  end
+end
+
+Object.infect_an_assertion :assert_has_elements, :must_have_elements

data/test/support/minitest.rb

@@ -0,0 +1,121 @@
+
+module TransactionalTest
+  # Wraps each test in a transaction that is always rolled back. The `result`
+  # dance is needed because Sequel's transaction method isn't good at returning
+  # the result of the block.
+  def run(runner)
+    result = nil
+    DB.transaction(:rollback => :always) { result = super }
+    result
+  end
+end
+
+class MiniTest::Spec
+  include TransactionalTest
+  class << self
+    # Finds the top-most test, that is a test that directly inherits from
+    # MiniTest::Spec.
+    # Used by the runner to group tests in to logical blocks.
+    def parent_suite
+      a = ancestors.take_while { |a| a != MiniTest::Spec }.select { |a| Class === a }
+      a.last
+    end
+
+    def start(&block)
+      @start_hook = block
+    end
+
+    def finish(&block)
+      @finish_hook = block
+    end
+
+    def _hooks_run
+      @_hooks_run ||= []
+    end
+
+    def _run_start_hook
+      _run_start_finish_hook(@start_hook, :start)
+    end
+
+    def _run_finish_hook
+      if _hooks_run.include?(:start)
+        _run_start_finish_hook(@finish_hook, :finish)
+      end
+    end
+
+    def _run_start_finish_hook(hook, label)
+      _hooks_run << label
+      hook.call if hook
+    end
+  end
+end
+
+# This relies on the test cases supporting the ::start & ::finish hooks
+# as well as the ::parent_suite method.
+class StartFinishRunner < MiniTest::Unit
+  def _run_suites(suites, type)
+    linebreak = ""
+    results = []
+    grouped = suites.group_by { |suite| suite.parent_suite }
+    grouped.delete(nil)
+
+    names = grouped.keys.map(&:to_s)
+    max_name_length = names.map(&:length).max
+
+    grouped.each do |master, tests|
+      output.print(output.bold("#{linebreak}#{master.to_s.ljust(max_name_length, " ")}  "))
+      DB.synchronize do
+        begin
+          master._run_start_hook
+          results.concat super(tests, type)
+        ensure
+          master._run_finish_hook
+        end
+      end
+      linebreak = "\n"
+    end
+    results
+  end
+end
+
+# I find the stream of green dots & yellow "S"s a little too strident.
+# Just give me red for errors.
+module Minitest
+  class PlainColorize < Minitest::Colorize
+    def print(string = nil)
+      return stream.print if string.nil?
+
+      case string
+      when 'E', 'F'
+        stream.print error(string)
+      when 'S'
+        stream.print grey(string)
+      else
+        stream.print string
+      end
+    end
+
+    def error(string)
+      tint([1, 31], string)
+    end
+
+    def bold(string)
+      tint(1, string)
+    end
+
+    def grey(string)
+      tint([30, 1], string)
+    end
+
+    def tint(color, string)
+      return string unless color_enabled?
+      effects = Array(color).map { |c| "\e[#{c}m"}.join
+      "#{effects}#{string}\e[0m"
+    end
+
+    # I want to be able to use these
+    [:red, :green, :yellow].each { |m| public m }
+  end
+end
+
+MiniTest::Unit.output = MiniTest::PlainColorize.new

data/test/support/rack.rb

@@ -0,0 +1,45 @@
+require 'rack/test'
+
+module RackTestMethods
+  include ::Rack::Test::Methods
+  include Spontaneous::Rack::Constants
+
+  def auth_post(path, params={}, env={})
+    post(path, params, csrf_header(env))
+  end
+
+  def auth_get(path, params={}, env={})
+    get(path, params, csrf_header(env))
+  end
+
+  def auth_put(path, params={}, env={})
+    put(path, params, csrf_header(env))
+  end
+
+  def auth_delete(path, params={}, env={})
+    delete(path, params, csrf_header(env))
+  end
+
+  alias_method :auth_del, :auth_delete
+
+  def auth_patch(path, params={}, env={})
+    patch(path, params, csrf_header(env))
+  end
+
+  def csrf_header(env)
+    token = api_key.generate_csrf_token
+    env.merge(Spontaneous::Rack::CSRF_ENV => token)
+  end
+
+  def api_key
+    # Override in test suites
+  end
+
+  def login_user(user, params={})
+    post "/@spontaneous/login", {"user[login]" => user.login, "user[password]" => user.password}.merge(params)
+    key_id  = rack_mock_session.cookie_jar[Spontaneous::Rack::AUTH_COOKIE]
+    @user   = user
+    @key    = Spontaneous::Permissions::AccessKey.authenticate(key_id)
+    [@user, @key]
+  end
+end

data/test/support/test_start_finish.rb

@@ -0,0 +1,103 @@
+# encoding: UTF-8
+
+require File.expand_path('../../test_helper', __FILE__)
+
+$suite1_start = $suite2_start = $suite3_start = nil
+
+describe "Suite1" do
+  start do
+    $suite1_start = true
+  end
+
+  finish do
+    $suite1_start = false
+  end
+
+  it "1" do
+    assert $suite1_start
+  end
+
+  describe "a" do
+    it "1" do
+      assert $suite1_start
+    end
+
+    it "2" do
+      assert true
+    end
+
+    describe "a" do
+      it "1" do
+        assert true
+      end
+
+      it "2" do
+        assert $suite1_start
+        $suite2_start.must_be_nil
+      end
+    end
+  end
+end
+
+describe "Suite2a" do
+  it "a" do
+    assert $suite1_start == false
+  end
+end
+
+describe "Suite2b" do
+  start do
+    $suite2_start = true
+  end
+
+  finish do
+    $suite2_start = false
+  end
+
+  it "a" do
+    assert $suite1_start == false
+    assert $suite2_start
+    $suite3_start.must_be_nil
+  end
+end
+
+describe "Suite3" do
+  start do
+    $suite3_start = true
+  end
+
+  finish do
+    $suite3_start = false
+  end
+
+  it "1" do
+    assert $suite1_start == false
+    assert $suite2_start == false
+    assert $suite3_start
+  end
+
+  describe "a" do
+    it "1" do
+      assert $suite1_start == false
+      assert $suite2_start == false
+      assert $suite3_start
+    end
+
+    describe "a" do
+      it "2" do
+        assert $suite3_start
+      end
+    end
+  end
+  describe "a" do
+    it "2" do
+      assert $suite3_start
+    end
+  end
+end
+
+MiniTest::Unit.after_tests do
+  if $suite3_start
+    raise "$suite3_start should be false but is #{$suite3_start.inspect}"
+  end
+end