gusto 1.0.0.beta2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e33005d29c816fd1b04d2272759ed17e03d13931
+  data.tar.gz: 2142ceb53d542831d3044edece5c5d106db6d469
+SHA512:
+  metadata.gz: 880e94182f4961bf38608dc257b44e0483622eb877469222575bd179a4476e24d7c7679862ab09a1485b4883ecb048e5b27b16a399e9ed30fb2ed91ae6786a17
+  data.tar.gz: ad17587ff01547549a8c6a983c3331745703300857334c79169a6ffde81b93ba3c5eb0033a03259c238990c0bc92b4cc260934c23cba62d821bcc31003fda325

data/bin/gusto

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require 'optparse'
+
+options = {}
+parser = OptionParser.new do |o|
+  o.banner = "Usage: #{$0} [options] mode\nPossible modes: server, cli, auto"
+
+  options[:port] = nil
+  o.on '-p', '--port PORT', 'Override server port' do |port|
+    options[:port] = port
+  end
+
+  options[:version] = false
+  o.on '-v', '--version', 'Show version' do
+    options[:version] = true
+  end
+
+  o.on_tail '-h', '--help', 'Display this screen' do
+    puts o
+    exit
+  end
+end
+parser.parse!
+
+require "#{File.dirname(__FILE__)}/../lib/gusto/runner.rb"
+Gusto::Runner.new ARGV.first, options, parser

data/lib/HtmlReport.coffee

@@ -0,0 +1,63 @@
+class window.HtmlReport
+  constructor: (element) ->
+    @element = element
+
+  run: ->
+    root = new Spec.Suite()
+    for suite in Spec.suites
+      root.add suite
+
+    @report = root.run([])
+    @element.innerHTML = @html()
+
+  html: ->
+    @resultSummary(@report) + @testResults(@report)
+
+  resultSummary: (report) ->
+    "
+      <div class=\"result-summary\">
+        #{@resultSummaryCount 'total',    report.counts[0] + report.counts[1] + report.counts[2]}
+        #{@resultSummaryCount 'passed',   report.counts[0]}
+        #{@resultSummaryCount 'pending',  report.counts[1]}
+        #{@resultSummaryCount 'failed',   report.counts[2]}
+      </div>
+    "
+
+  resultSummaryCount: (name, count) ->
+    "
+      <div class=\"result-summary--count result-summary--#{name}\">
+        <span class=\"result-summary--label\">#{name.toUpperCase()}</span>
+        <span class=\"result-summary--number\">#{count}</span>
+      </div>
+    "
+
+  testResults: (report) ->
+    "
+      <div class=\"test-results\">
+        #{@testResultsReports report.subreports}
+      </div>
+    "
+
+  testResultsReports: (reports) ->
+    html = '<ul class=\"test-results--list\">'
+    for report in reports
+      html += @testResultsReport report
+    html + '</ul>'
+
+  testResultsReport: (report) ->
+    "
+      <li class=\"test-results--test test-results--test--#{@testResultsStatusClass report.status}\">
+        <div class=\"test-results--title\">#{report.title}</div>
+        #{if report.error then @testResultsErrorReport(report) else ''}
+        #{if report.subreports.length then @testResultsReports(report.subreports) else ''}
+      </li>
+    "
+
+  testResultsErrorReport: (report) ->
+    "<div class=\"test-results--error-message\">#{report.error}</div>"
+
+  testResultsStatusClass: (status) ->
+    switch status
+      when Spec.Report.Passed then 'passed'
+      when Spec.Report.Pending then 'pending'
+      when Spec.Report.Failed then 'failed'

data/lib/Spec/DSL.coffee

@@ -0,0 +1,119 @@
+window.Spec ||= {}
+
+window.Spec.DSL = DSL =
+  # Prepares a sub-test of the current test case
+  describe: (title, definition) ->
+    @__spec_definingSuite.add new Spec.Suite(title, definition)
+
+  # Adds a setup step to the current test case
+  before: (action) ->
+    @__spec_definingSuite.filter null, action
+
+  # Allows an assertion on a non-object value
+  expect: (object) ->
+    to: (matcher) ->
+      result = matcher(object)
+      throw new Spec.ExpectationError("expected #{result[1]}") unless result[0]
+    notTo: (matcher) ->
+      result = matcher(object)
+      throw new Spec.ExpectationError("expected not #{result[1]}") if result[0]
+
+  # Syntactic sugar to create a before method that prepares a variable
+  #
+  # Example:
+  #     given 'dog', -> new Dog()
+  given: (name, definition) ->
+    @__spec_definingSuite.filter name, -> @[name] = definition.call this
+
+  # Creates a specificaition
+  it: (args...) ->
+    test = switch args.length
+      when 1
+        if typeof args[0] == 'function'
+          # Test with automatically generated title
+          new Spec.Test(Spec.Util.descriptionize(args[0]), args[0])
+        else
+          # Pending test
+          new Spec.Test(args[0], -> pending() )
+      when 2
+        # Test with manual title
+        new Spec.Test(args...)
+    @__spec_definingSuite.add test if test
+
+  pending: (message=null) ->
+    throw new Spec.PendingError(message)
+
+  # Creates a specification that tests an attribute of subject
+  #
+  # Example:
+  #     subject -> new Employee('Fred')
+  #     its 'name', -> should equal('Fred')
+  its: (attribute, definition) ->
+    root = this
+    it "#{attribute} #{Spec.Util.descriptionize definition}", ->
+      root.__spec_subject = @subject = Spec.Util.dereference @subject[attribute]
+      definition.call this
+
+  # Runs a test against @subject
+  #
+  # Example
+  #     subject -> new Employee()
+  #     it -> should beAnInstanceOf(Employee)
+  should: (matcher) ->
+    expect(@__spec_subject).to matcher
+
+  # Runs a negative test against @subject
+  #
+  # Example
+  #     subject -> new Employee()
+  #     it -> shouldNot be(null)
+  shouldNot: (matcher) ->
+    expect(@__spec_subject).notTo matcher
+
+  # Creates a new mock object
+  #
+  # Pass in a hash of method stubs to add to your mock.
+  #
+  # `mock(boots: 'cats')` gives an object that has the method:
+  # `boots: -> 'cats'`
+  #
+  # Optionally, you can pass a name to identify this mock as the
+  # first parameter.
+  #
+  mock: (args...) ->
+    name = args.shift() if typeof args[0] is 'string'
+    stubs = args.pop() || {}
+    new Spec.MockObject(name, stubs)
+
+  # Defines the subject of your test.
+  #
+  # Pass in a definition method which returns an object to be your
+  # test subject. This will be assigined to the instance variable
+  # @subject before your test runs. This subject will be used for
+  # any `should` or `shouldNot` tests you specify using the global
+  # `should` and `shouldNot` methods.
+  #
+  #     subject -> new Client()
+  #
+  #     it { should beA Client }
+  #
+  # Optionally, you can specify a name for your subject as the
+  # first parameter. This lets you call the subject by its name,
+  # making your tests more readable.
+  #
+  #     subject 'foo', -> ...
+  #
+  #     it 'gets prepared' ->
+  #       @foo.prepare
+  #       should 'bePrepared'
+  #
+  subject: (args...) ->
+    root = this
+    definition = args.pop()
+    name = args.pop()
+    before ->
+      root.__spec_subject = @subject = definition.call this
+      @[name] = @subject if name
+
+DSL.context = DSL.describe
+DSL.specify = DSL.it

data/lib/Spec/DelayedExpectation.coffee

@@ -0,0 +1,61 @@
+window.Spec ||= {}
+
+# A delayed expectation keeps track of an event that is expected to
+# occur during the course of a test.
+#
+# To set a delayed expectation use window.expectation
+class window.Spec.DelayedExpectation
+  @expectations: []
+
+  @add: (message) ->
+    exp = new Spec.DelayedExpectation(message)
+    @expectations.push exp
+    exp
+
+  @assert: ->
+    asserting = @expectations
+    @expectations = []
+    for expectation in asserting
+      expectation.assert()
+
+  @reset: ->
+    @expectations = []
+
+  constructor: (@message) ->
+    @met      = 0
+    @desired  = 1
+
+  # Specifies that this expectation must be met twice to count
+  # as a success.
+  twice: ->
+    @desired  = 2
+    this
+
+  # Specifies how many times this expectation should be run to
+  # count as a success.
+  #
+  # Always use this with the format `.exactly(x).times` for better
+  # readability.
+  exactly: (count) ->
+    @desired = count
+    {times: this}
+
+  # Call when this expectation has been met.
+  meet: ->
+    @met += 1
+
+  # Raises an error unless this expecation has been met the right number of times.
+  assert: ->
+    unless @met is @desired
+      throw new Spec.ExpectationError("expected to #{@message} #{@_timesString @desired}, actually happened #{@_timesString @met}")
+
+  _timesString: (times) ->
+    switch times
+      when 0
+        'not at all'
+      when 1
+        'once'
+      when 2
+        'twice'
+      else
+        "#{times} times"

data/lib/Spec/Matchers.coffee

@@ -0,0 +1,69 @@
+window.Spec ||= {}
+
+window.Spec.Matchers =
+  # Tests if matched value === expected value
+  be: (expected) ->
+    (value) ->
+      [value is expected, "to be #{Spec.Util.inspect expected}, actual #{Spec.Util.inspect value}"]
+
+  # Tests that value type matches specified class
+  beA: (klass) ->
+    switch klass
+      when Boolean  then _haveType 'boolean'
+      when Function then _haveType 'function'
+      when Number   then _haveType 'number'
+      when String   then _haveType 'string'
+      when Object   then _haveType 'object'
+      else _beAnInstanceOf klass
+
+  # Tests if matched value == expected value
+  equal: (expected) ->
+    (value) ->
+      [String(value) == String(expected), "“#{String value}” to equal “#{String expected}” – #{$.trim diffString(String(value), String(expected))}"]
+  
+  # All-purpose inclusion matcher
+  include: (expected) ->
+    if expected instanceof Array
+      (value) ->
+        match = true
+        for test in expected
+          match = false unless (value.indexOf && value.indexOf(test) >= 0) || value[test]?
+        [match, "to include #{Spec.Util.inspect expected}, actual #{Spec.Util.inspect value}"]
+    else if typeof expected == 'object'
+      (value) ->
+        missing = {}
+        match = true
+        for test of expected
+          if expected.hasOwnProperty test
+            unless value[test] isnt undefined && String(value[test]) == String(expected[test])
+              match = false
+              missing[test] = expected[test]
+        [match, "to include #{Spec.Util.inspect expected}, actual #{Spec.Util.inspect value}, missing #{Spec.Util.inspect missing}"]
+    else
+      include([expected])
+  
+  # Tests if a function causes an error to be thrown when called
+  throwError: (message) ->
+    (fn) ->
+      thrown = false
+      try
+        fn()
+      catch e
+        thrown = e.message
+      finally
+        if thrown
+          return [thrown == message, "to throw an error with message “#{String thrown}”, actual message “#{String message}” – #{$.trim diffString(String(thrown), String(message))}"]
+        else
+          return [false, "to throw an error with message “#{message}”, no error thrown"]
+
+  # Tests a value type using typeof
+  _haveType: (type) ->
+    (value) ->
+      [typeof value is type, "to have type “#{type}”, actual “#{typeof value}”"]
+
+  # Tests if matched value is an instance of class
+  _beAnInstanceOf: (klass) ->
+    (value) ->
+      [value instanceof klass, "to be an instance of “#{klass}”"]
+
+window.Spec.Matchers.beAn = window.Spec.Matchers.beA

data/lib/Spec/MethodStub/PossibleCall.coffee

@@ -0,0 +1,81 @@
+# Represents a possible call path for a MethodStub - that is a combination
+# of expected arguments and return values.
+class window.Spec.MethodStub.PossibleCall
+  constructor: (@original) ->
+
+  # Defines the expected arguments for this PossibleCall. By default a
+  # PossibleCall will accept any or no arguments. When you specify arguments
+  # here, the PossibleCall will respond only to those arguments, and a test
+  # failure will be recorded if it is called with incorrect arguments.
+  with: (args...) ->
+    @arguments = args
+    this
+
+  # Provides a return value for this PossibleCall
+  andReturn: (value) ->
+    @return = Spec.Util.reference(value)
+    this
+
+  # Causes this PossibleCall to pass through to the original method on the
+  # object before it was stubbed out.
+  andPassthrough: ->
+    @return = @original
+
+  # Sets an expectation that this PossibleCall be called as part of the test.
+  #
+  # This is used by window#shouldReceive, and doesn't need to be called
+  # directly.
+  expect: ->
+    # TODO: Make this description better, possibly with name of
+    # the method that should have been called
+    @expectation ||= Spec.DelayedExpectation.add('get called')
+    this
+
+  # Delegates to expectation
+  twice: ->
+    @expectation.twice()
+    this
+
+  # Delegates to expectation
+  exactly: (times) ->
+    @expectation.exactly times
+    {times: this}
+
+  # Checks if this PossibleCall matches the given array of arguments.
+  #
+  # A match is defined as having the same number of arguments, and each
+  # argument having an equal string representation to its counterpart.
+  matchesArguments: (args) ->
+    if !@arguments
+      true
+    else if @arguments.length isnt args.length
+      false
+    else
+      @_arraysMatch @arguments, args
+
+  # Causes this PossibleCall to fulfil a call on the stubbed method. Fails
+  # the test if the called arguments don't match expected arguments.
+  call: (object, method, args) ->
+    if @matchesArguments(args)
+      @expectation.meet() if @expectation
+      @return.apply object, args if @return
+    else
+      @_failOnInvalidArguments method, args
+      null
+
+  _arraysMatch: (a, b) ->
+    for i in [0..a.length]
+      return false if String(a[i]) isnt String(b[i])
+    true
+
+  _failOnInvalidArguments: (method, args) ->
+    throw new Spec.ExpectationError(
+      "expected ##{method} to be called#{@_argumentsString()}, " +
+      "actual arguments: “#{args.join ', '}”"
+    )
+
+  _argumentsString: ->
+    if @arguments
+      " with arguments “#{@arguments.join ', '}”"
+    else
+      ''

data/lib/Spec/MethodStub.coffee

@@ -0,0 +1,55 @@
+window.Spec ||= {}
+
+# Replaces a method on an object with a stub method, a fake method which can
+# be configured to return predetermined responses, as well as set
+# expectations on how it is called.
+#
+# These are created using window#stub, window#shouldReceive and
+# window#shouldNotReceive. You shouldn't need to create one manually.
+class window.Spec.MethodStub
+  @stubs: []
+
+  @reset: ->
+    while stub = @stubs.pop()
+      stub.remove()
+
+  constructor: (@object, @method) ->
+    @possibleCalls = []
+    @_replaceMethodOnObject()
+    Spec.MethodStub.stubs.push this
+
+  # Makes a new PossibleCall and adds it to the list
+  possibleCall: ->
+    call = new Spec.MethodStub.PossibleCall(@original)
+    @possibleCalls.unshift call
+    call
+
+  remove: ->
+    @object[@method] = @original
+
+  # Generates a new stub method to inject into the object, and sets the
+  # _stub property on it to point back to this MethodStub.
+  #
+  # _stub is used by window#stub to find an existing MethodStub for a method
+  # and add more possible calls to it, instead of writing over it with
+  # a new MethodStub.
+  #
+  # The code inside the stub method is the same for each MethodStub, but
+  # we create a fresh copy of it so we can assign a unique _stub property.
+  _stubMethod: ->
+    method = @method
+    stubMethod = (args...) ->
+      if call = arguments.callee._stub._findPossibleCall(args)
+        call.call this, method, args
+
+    stubMethod._stub = this
+    stubMethod
+
+  _findPossibleCall: (args) ->
+    for call in @possibleCalls
+      break if call.matchesArguments(arguments)
+    call
+
+  _replaceMethodOnObject: ->
+    @original = @object[@method]
+    @object[@method] = @_stubMethod()

data/lib/Spec/MockObject.coffee

@@ -0,0 +1,6 @@
+window.Spec ||= {}
+
+class window.Spec.MockObject
+  constructor: (@name, stubs) ->
+    for name, value of stubs
+      @stub(name).andReturn(value)

data/lib/Spec/ObjectDSL.coffee

@@ -0,0 +1,26 @@
+window.Spec ||= {}
+
+window.Spec.ObjectDSL =
+  # Stubs a method on object
+  stub: (method) ->
+    stub = if @[method] && @[method]._stub
+      @[method]._stub
+    else
+      new Spec.MethodStub(this, method)
+    stub.possibleCall()
+
+  # Tests for a positive match
+  should: (matcher) ->
+    expect(this).to matcher
+
+  # Tests for a negative match
+  shouldNot: (matcher) ->
+    expect(this).notTo matcher
+
+  # Creates a stub method with an expectation
+  shouldReceive: (method) ->
+    @stub(method).expect()
+
+  # Creates a stub method, with an expectation of no calls
+  shouldNotReceive: (name) ->
+    @shouldReceive(name).exactly(0).times

data/lib/Spec/Report.coffee

@@ -0,0 +1,23 @@
+class window.Spec.Report
+  @Passed:  0
+  @Pending: 1
+  @Failed:  2
+
+  constructor: (@title) ->
+    @status     = Spec.Report.Passed
+    @error      = null
+    @subreports = []
+    @counts     = [0, 0, 0]
+
+  result: (result, error=null) ->
+    @status = result
+    @error  = error
+    @counts[result]++
+
+  addSubreport: (subreport) ->
+    @subreports.push subreport
+    @counts[i] += subreport.counts[i] for i in [0..2]
+    @_updateStatus(subreport.status)
+
+  _updateStatus: (value) ->
+    @status = Math.max(@status, value)

data/lib/Spec/Suite.coffee

@@ -0,0 +1,30 @@
+class window.Spec.Suite
+  constructor: (@title, @definition) ->
+    @filters      = []
+    @components   = []
+    @loaded       = false
+
+  load: ->
+    if @definition
+      window.__spec_definingSuite = this
+      @definition()
+
+      delete window.__spec_definingSuite
+    @loaded = true
+
+  add: (component) ->
+    @components.push component
+
+  filter: (name, definition) ->
+    @filters.push definition
+
+  run: (filters)->
+    @load() unless @loaded
+    allFilters = filters.concat(@filters)
+    report = new Spec.Report(@title)
+    report.status = Spec.Report.Pending unless @components.length
+
+    for component in @components
+      report.addSubreport component.run(allFilters)
+
+    report

data/lib/Spec/Test.coffee

@@ -0,0 +1,21 @@
+class window.Spec.Test
+  constructor: (@title, @definition) ->
+
+  run: (filters) ->
+    report = new Spec.Report(@title)
+    try
+      env = {}
+      filter.call(env) for filter in filters
+      @definition.call(env)
+      Spec.DelayedExpectation.assert()
+      report.result Spec.Report.Passed
+    catch error
+      report.result(
+        error.status || Spec.Report.Failed,
+        error.message
+      )
+      report.location = error.fileName + ':' + error.lineNumber
+    finally
+      Spec.DelayedExpectation.reset()
+      Spec.MethodStub.reset()
+    report

data/lib/Spec/Util.coffee

@@ -0,0 +1,86 @@
+window.Spec ||= {}
+
+window.Spec.Util =
+  extend: (object, extensions...) ->
+    for extension in extensions
+      for key, value of extension
+        object[key] = value
+
+  unextend: (object, extensions...) ->
+    for extension in extensions
+      for key, value of extension
+        delete object[key]
+
+  reference: (value) ->
+    if typeof value is 'function'
+      value
+    else
+      -> value
+
+  dereference: (value, context) ->
+    if typeof value is 'function'
+      value.call context
+    else
+      value
+
+  # Tries to format definition source code as readable test description
+  descriptionize: (definition) ->
+    # Get function source code
+    definition = String definition
+
+    # Remove function boilerplate from beginning
+    definition = definition.replace(/^\s*function\s*\([^\)]*\)\s*\{\s*(return\s*)?/, '')
+
+    # Remove function boilerplate from end
+    definition = definition.replace(/\s*;\s*\}\s*$/, '')
+
+    # Replace symbols with whitespace
+    definition = definition.replace(/[\s\(\)\{\}_\-\.'";]+/g, ' ')
+
+    # Split camelCased terms into seperate words
+    definition = definition.replace(/([a-z])([A-Z])/g, (s, a, b) -> "#{a} #{b.toLowerCase()}")
+
+    # Replace the word return with "it" (only for functions that are more complex than a simple return)
+    definition = definition.replace ' return ', ' it '
+
+    $.trim definition
+
+  # Returns an HTML representation of any kind of object
+  inspect: (object) ->
+    if object instanceof Array
+      s = '['
+      first = true
+      for item in object
+        if first
+          first = false
+        else
+          first += ', '
+        s += "“#{@escape(String(item))}”"
+      s + ']'
+    else if object is null
+      'null'
+    else if object is undefined
+      'undefined'
+    else if object is true
+      'true'
+    else if object is false
+      'false'
+    else if typeof object == 'object'
+      s = "{"
+      first = true
+      for key of object
+        # Access hasOwnProperty through Object.prototype to work around bug
+        # in IE6/7/8 when calling hasOwnProperty on a DOM element
+        if Object.prototype.hasOwnProperty.call(object, key)
+          if first
+            first = false
+          else
+            s += ", "
+          s += @escape(key) + ': “' + @escape(String(object[key])) + '”'
+      s + "}"
+    else
+      "“#{@escape(object)}”"
+
+  # Escapes text for HTML
+  escape: (string) ->
+    $('<div/>').text(String(string)).html()