├── spec
    ├── screw_unit
    │   ├── resources
    │   │   ├── file_system_fixtures
    │   │   │   ├── foo.css
    │   │   │   ├── foo.gif
    │   │   │   ├── foo.jpeg
    │   │   │   ├── foo.jpg
    │   │   │   ├── foo.png
    │   │   │   ├── foo.js
    │   │   │   ├── specs
    │   │   │   │   ├── foo_spec.js
    │   │   │   │   └── subsuite
    │   │   │   │   │   └── bar_spec.js
    │   │   │   └── code_under_test
    │   │   │   │   └── code_under_test.js
    │   │   ├── root_spec.rb
    │   │   ├── spec_runner_spec.rb
    │   │   ├── spec_suite_spec.rb
    │   │   ├── spec_dir_spec.rb
    │   │   ├── suite_completion_spec.rb
    │   │   ├── dir_spec.rb
    │   │   └── file_spec.rb
    │   ├── file_system_fixtures_for_asset_manager_specs
    │   │   ├── dir
    │   │   │   └── 6.js
    │   │   ├── dir_1
    │   │   │   ├── 7.js
    │   │   │   ├── subdir_1
    │   │   │   │   └── 4.js
    │   │   │   └── 1.js
    │   │   ├── dir_2
    │   │   │   └── 2.js
    │   │   ├── dir_4
    │   │   │   └── 1.css
    │   │   └── dir_3
    │   │   │   ├── subdir_3
    │   │   │       └── 5.js
    │   │   │   └── 3.js
    │   ├── server_spec.rb
    │   ├── array_extension_spec.rb
    │   ├── js_file_spec.rb
    │   ├── asset_location_spec.rb
    │   ├── configuration_spec.rb
    │   ├── dispatcher_spec.rb
    │   └── asset_manager_spec.rb
    ├── screw_unit_spec_suite.rb
    └── screw_unit_spec_helper.rb
├── .gitignore
├── example
    ├── lib
    │   ├── example.js
    │   └── models
    │   │   ├── cat.js
    │   │   └── man.js
    ├── .screwrc
    └── spec
    │   ├── spec_helper.js
    │   ├── matchers
    │       └── have.js
    │   ├── suite.html
    │   └── models
    │       ├── cat_spec.js
    │       └── man_spec.js
├── client
    ├── vendor
    │   ├── screw.monarch_view.js
    │   ├── jquery.print.js
    │   └── jquery.cookie.js
    ├── lib
    │   ├── screw
    │   │   ├── context.js
    │   │   ├── runnable_methods.js
    │   │   ├── interface.js
    │   │   ├── interface
    │   │   │   ├── example.js
    │   │   │   ├── progress_bar.js
    │   │   │   ├── description.js
    │   │   │   ├── streaming_runner.js
    │   │   │   └── runner.js
    │   │   ├── require.js
    │   │   ├── screw.js
    │   │   ├── example.js
    │   │   ├── keywords.js
    │   │   ├── description.js
    │   │   └── matchers.js
    │   └── screw.js
    ├── stylesheets
    │   └── screw.css
    └── spec
    │   ├── interface
    │       ├── progress_bar_spec.js
    │       ├── example_spec.js
    │       ├── description_spec.js
    │       └── runner_spec.js
    │   ├── print_spec.js
    │   ├── example_spec.js
    │   ├── mock_spec.js
    │   ├── integration_spec.js
    │   ├── description_spec.js
    │   └── matchers_spec.js
├── .screwrc
├── lib
    ├── screw_unit
    │   ├── string_extension.rb
    │   ├── array_extension.rb
    │   ├── resources.rb
    │   ├── resources
    │   │   ├── file_not_found.rb
    │   │   ├── root.rb
    │   │   ├── suite_completion.rb
    │   │   ├── dir.rb
    │   │   ├── streaming_spec_runner.rb
    │   │   ├── file.rb
    │   │   ├── spec_dir.rb
    │   │   └── spec_runner.rb
    │   ├── dispatcher.rb
    │   ├── server.rb
    │   ├── js_file.rb
    │   ├── asset_manager.rb
    │   ├── asset_location.rb
    │   └── configuration.rb
    └── screw_unit.rb
├── todo
├── Rakefile
├── bin
    └── screw
├── README.txt
└── README.markdown


/spec/screw_unit/resources/file_system_fixtures/foo.css:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/file_system_fixtures/foo.gif:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/file_system_fixtures/foo.jpeg:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/file_system_fixtures/foo.jpg:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/file_system_fixtures/foo.png:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/file_system_fixtures/foo.js:
--------------------------------------------------------------------------------
1 | var foo = {};


--------------------------------------------------------------------------------
/spec/screw_unit/resources/file_system_fixtures/specs/foo_spec.js:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/spec/screw_unit/file_system_fixtures_for_asset_manager_specs/dir/6.js:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/spec/screw_unit/file_system_fixtures_for_asset_manager_specs/dir_1/7.js:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/spec/screw_unit/file_system_fixtures_for_asset_manager_specs/dir_2/2.js:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/spec/screw_unit/file_system_fixtures_for_asset_manager_specs/dir_4/1.css:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/file_system_fixtures/specs/subsuite/bar_spec.js:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.iml
2 | *.ipr
3 | *.iws
4 | .DS_Store
5 | pkg
6 | .rakeTasks
7 | .idea


--------------------------------------------------------------------------------
/example/lib/example.js:
--------------------------------------------------------------------------------
1 | //= require "models/cat"
2 | //= require "models/man"
3 | 


--------------------------------------------------------------------------------
/spec/screw_unit/file_system_fixtures_for_asset_manager_specs/dir_3/subdir_3/5.js:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/file_system_fixtures/code_under_test/code_under_test.js:
--------------------------------------------------------------------------------
1 | //


--------------------------------------------------------------------------------
/spec/screw_unit/file_system_fixtures_for_asset_manager_specs/dir_1/subdir_1/4.js:
--------------------------------------------------------------------------------
1 | //= require "../7"
2 | 


--------------------------------------------------------------------------------
/spec/screw_unit/file_system_fixtures_for_asset_manager_specs/dir_3/3.js:
--------------------------------------------------------------------------------
1 | //= require "subdir_3/5"
2 | 


--------------------------------------------------------------------------------
/client/vendor/screw.monarch_view.js:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nathansobo/screw-unit/HEAD/client/vendor/screw.monarch_view.js


--------------------------------------------------------------------------------
/spec/screw_unit_spec_suite.rb:
--------------------------------------------------------------------------------
1 | dir = File.dirname(__FILE__)
2 | Dir.glob("#{dir}/**/*_spec.rb").each do |spec_file|
3 |   require spec_file
4 | end


--------------------------------------------------------------------------------
/.screwrc:
--------------------------------------------------------------------------------
1 | ScrewUnit.configure do
2 |   port 8181
3 |   add_js_location "/under_test", "client/lib"
4 |   add_js_location "/specs", "client/spec"
5 | end
6 | 


--------------------------------------------------------------------------------
/spec/screw_unit/file_system_fixtures_for_asset_manager_specs/dir_1/1.js:
--------------------------------------------------------------------------------
1 | //= require "subdir_1/4"
2 | //= require "7"
3 | //= require <3>
4 | var x = 1;
5 | 


--------------------------------------------------------------------------------
/example/.screwrc:
--------------------------------------------------------------------------------
1 |   ScrewUnit.configure do
2 |     port 8082
3 |     add_js_location "/under_test", "lib"
4 |     add_js_location "/specs", "spec"
5 |   end
6 | 


--------------------------------------------------------------------------------
/example/lib/models/cat.js:
--------------------------------------------------------------------------------
1 | function Cat(options) {
2 |   this.cross_path = function(man) {
3 |     if (options.color == 'black') man.decrement_luck(5);
4 |   };
5 | }


--------------------------------------------------------------------------------
/client/lib/screw/context.js:
--------------------------------------------------------------------------------
1 | (function(Screw, Monarch, jQuery) {
2 | 
3 | Monarch.constructor("Screw.Context", Screw.Matchers, Screw.Keywords);
4 | 
5 | })(Screw, Monarch);
6 | 


--------------------------------------------------------------------------------
/lib/screw_unit/string_extension.rb:
--------------------------------------------------------------------------------
 1 | class String
 2 |   def starts_with?(prefix)
 3 |     index(prefix) == 0
 4 |   end
 5 | 
 6 |   def path_starts_with?(prefix)
 7 |     split('/').starts_with?(prefix.split('/'))
 8 |   end
 9 | end
10 | 


--------------------------------------------------------------------------------
/todo:
--------------------------------------------------------------------------------
1 | [ ] - change mock_function to take an optional function_name as its first argument (it should be able to take both a name and a function to call)
2 | [ ] - add specs for jquery_mapper
3 | [ ] - add specs for match_html
4 | [ ] - screw specs no longer run... wtf


--------------------------------------------------------------------------------
/example/spec/spec_helper.js:
--------------------------------------------------------------------------------
1 | //= require <example>;
2 | 
3 | Screw.Unit(function(c) { with(c) {
4 |   before(function() {
5 |     Screw.$('dom_test').empty(); // Screw comes with its own version of jQuery, located Screw.$ to keep out of your version's way if you have one
6 |   });
7 | }});
8 | 


--------------------------------------------------------------------------------
/spec/screw_unit_spec_helper.rb:
--------------------------------------------------------------------------------
 1 | require "rubygems"
 2 | require "spec"
 3 | 
 4 | dir = File.dirname(__FILE__)
 5 | require File.expand_path("#{dir}/../lib/screw_unit")
 6 | 
 7 | Spec::Runner.configure do |config|
 8 |   config.mock_with :rr
 9 | end
10 | 
11 | at_exit do
12 |   Spec::Runner.run
13 | end
14 | 


--------------------------------------------------------------------------------
/lib/screw_unit/array_extension.rb:
--------------------------------------------------------------------------------
 1 | class Array
 2 |   def starts_with?(prefix)
 3 |     return true if prefix.empty?
 4 |     return false if prefix.size > size
 5 |     prefix.each_with_index do |element, index|
 6 |       return false unless self[index] == element
 7 |     end
 8 |     true
 9 |   end
10 | end
11 | 


--------------------------------------------------------------------------------
/example/spec/matchers/have.js:
--------------------------------------------------------------------------------
1 | Screw.Matchers["have"] = {
2 |   match: function(expected, actual) {
3 |     return actual.find(expected).length > 0;
4 |   },
5 |   failure_message: function(expected, actual, not) {
6 |     return 'expected ' + $.print(actual) + (not ? ' to not have ' : ' to have ') + $.print(expected);
7 |   }
8 | }


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
 1 | # -*- ruby -*-
 2 | 
 3 | require 'rubygems'
 4 | require 'hoe'
 5 | require './lib/screw_unit.rb'
 6 | 
 7 | Hoe.new('screw_unit', ScrewUnit::VERSION) do |p|
 8 |   # p.rubyforge_name = 'screw_unitx' # if different than lowercase project name
 9 |   p.developer('Nathan Sobo', 'nathansobo@gmail.com')
10 | end
11 | 
12 | # vim: syntax=Ruby
13 | 


--------------------------------------------------------------------------------
/lib/screw_unit/resources.rb:
--------------------------------------------------------------------------------
 1 | dir = File.dirname(__FILE__)
 2 | require "#{dir}/resources/file"
 3 | require "#{dir}/resources/dir"
 4 | require "#{dir}/resources/root"
 5 | require "#{dir}/resources/spec_dir"
 6 | require "#{dir}/resources/spec_runner"
 7 | require "#{dir}/resources/streaming_spec_runner"
 8 | require "#{dir}/resources/file_not_found"
 9 | require "#{dir}/resources/suite_completion"
10 | 


--------------------------------------------------------------------------------
/bin/screw:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby
 2 | 
 3 | dir = File.dirname(__FILE__)
 4 | $LOAD_PATH.push("#{dir}/../lib/")
 5 | require "screw_unit"
 6 | 
 7 | configuration = ScrewUnit::Configuration.instance 
 8 | configuration.load_screwrc(Dir.pwd)
 9 | configuration.selenium_mode if ARGV.include?("--selenium")
10 | 
11 | $exit_status = 0
12 | 
13 | ScrewUnit::Server.start(configuration)
14 | 
15 | exit $exit_status
16 | 


--------------------------------------------------------------------------------
/client/lib/screw/runnable_methods.js:
--------------------------------------------------------------------------------
 1 | (function(Screw, Monarch) {
 2 | 
 3 | Monarch.module("Screw.RunnableMethods", {
 4 |   path: function() {
 5 |     if (!this.parentDescription) {
 6 |       return [];
 7 |     }
 8 |     return this.parentDescription.path().concat([this.index]);
 9 |   },
10 | 
11 |   onExampleCompleted: function(callback) {
12 |     return this.exampleCompletedSubscriptionNode.subscribe(callback);
13 |   }
14 | });
15 | 
16 | })(Screw, Monarch);
17 | 
18 | 


--------------------------------------------------------------------------------
/example/lib/models/man.js:
--------------------------------------------------------------------------------
 1 | function Man(options) {
 2 |   var luck = options.luck;
 3 |   
 4 |   this.decrement_luck = function(delta) {
 5 |     luck = Math.max(0, luck - delta);
 6 |   };
 7 |   this.luck = function() {
 8 |     return luck;
 9 |   };
10 |   this.render = function() {
11 |     return Screw.$('<ul class="man">')
12 |       .append('<li class="hair">')
13 |       .click(function() {
14 |         Screw.$(this).children('.hair').remove();
15 |       });
16 |   };
17 | }
18 | 


--------------------------------------------------------------------------------
/spec/screw_unit/server_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   describe Server do
 5 |     describe ".start" do
 6 |       it "creates a new instance of Server and calls #start on it" do
 7 |         options = { :foo => "bar" }
 8 |         mock_server = Object.new
 9 |         mock(mock_server).start(options)
10 |         stub(Server).new {  mock_server }
11 |         Server.start(options)
12 |       end
13 |     end
14 |   end
15 | end
16 | 


--------------------------------------------------------------------------------
/lib/screw_unit/resources/file_not_found.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   module Resources
 3 |     class FileNotFound
 4 |       attr_reader :virtual_path
 5 | 
 6 |       def initialize(virtual_path)
 7 |         @virtual_path = virtual_path
 8 |       end
 9 | 
10 |       def locate(name)
11 |         self
12 |       end
13 |       
14 |       def get
15 |         puts "Couldn't find #{virtual_path}"
16 |         [404, {}, "No file found at relative path '#{virtual_path}'"]
17 |       end
18 | 
19 |       def error
20 |         raise 
21 |       end
22 |     end
23 |   end
24 | end
25 | 


--------------------------------------------------------------------------------
/lib/screw_unit.rb:
--------------------------------------------------------------------------------
 1 | dir = File.dirname(__FILE__)
 2 | require "rubygems"
 3 | require "thin"
 4 | require "#{dir}/screw_unit/dispatcher"
 5 | require "#{dir}/screw_unit/server"
 6 | require "#{dir}/screw_unit/resources"
 7 | require "#{dir}/screw_unit/configuration"
 8 | require "#{dir}/screw_unit/asset_manager"
 9 | require "#{dir}/screw_unit/string_extension"
10 | require "#{dir}/screw_unit/array_extension"
11 | require "#{dir}/screw_unit/asset_location"
12 | require "#{dir}/screw_unit/js_file"
13 | 
14 | module ScrewUnit
15 |   VERSION = "1.9.0"
16 | 
17 |   dir = File.dirname(__FILE__)
18 |   SCREW_UNIT_ROOT = File.expand_path("#{dir}/..")
19 | end
20 | 


--------------------------------------------------------------------------------
/client/lib/screw.js:
--------------------------------------------------------------------------------
 1 | //= require <screw.monarch_view>
 2 | //= require <jquery.print>
 3 | //= require <jquery.cookie>
 4 | 
 5 | //= require "screw/screw"
 6 | //= require "screw/keywords"
 7 | //= require "screw/matchers"
 8 | //= require "screw/context"
 9 | //= require "screw/runnable_methods"
10 | //= require "screw/description"
11 | //= require "screw/example"
12 | //= require "screw/require"
13 | //= require "screw/interface"
14 | 
15 | Screw.$ = jQuery;
16 | Screw.jQuery = jQuery;
17 | Screw.Monarch = window.Monarch;
18 | Screw.Disco = window.Disco;
19 | 
20 | jQuery.noConflict(true);
21 | delete window.$;
22 | delete window.jQuery;
23 | delete window.Monarch;
24 | 


--------------------------------------------------------------------------------
/spec/screw_unit/array_extension_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../screw_unit_spec_helper"
 2 | 
 3 | describe Array do
 4 |   describe "#starts_with?" do
 5 |     it "returns true only for arrays that share a common prefix with the receiver" do
 6 |       a = ["foo", "bar", "baz"]
 7 |       a.starts_with?(["foo"]).should be_true
 8 |       a.starts_with?(["foo", "bar"]).should be_true
 9 |       a.starts_with?(["foo", "bar", "baz"]).should be_true
10 |       a.starts_with?(["foo", "bar", "baz", "quux"]).should_not be_true
11 |       a.starts_with?(["quux"]).should_not be_true
12 |       a.starts_with?([]).should be_true
13 |     end
14 |   end
15 | end
16 | 


--------------------------------------------------------------------------------
/lib/screw_unit/resources/root.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   module Resources
 3 |     class Root < Resources::Dir
 4 |       attr_accessor :configuration, :options
 5 | 
 6 |       def initialize(configuration)
 7 |         @configuration = configuration
 8 |         super("/", asset_manager)
 9 |       end
10 | 
11 |       def asset_manager
12 |         configuration.asset_manager
13 |       end
14 | 
15 |       def locate(path_fragment)
16 |         case path_fragment
17 |         when "specs"
18 |           SpecDir.new("/specs", configuration.asset_manager)
19 |         when "complete"
20 |           SuiteCompletion.new(configuration.selenium_mode?)
21 |         else
22 |           super
23 |         end
24 |       end
25 |     end
26 |   end
27 | end
28 | 


--------------------------------------------------------------------------------
/client/lib/screw/interface.js:
--------------------------------------------------------------------------------
 1 | //= require "interface/description"
 2 | //= require "interface/example"
 3 | //= require "interface/progress_bar"
 4 | //= require "interface/runner"
 5 | //= require "interface/streaming_runner"
 6 | 
 7 | (function(Screw, Monarch, jQuery) {
 8 | 
 9 | Monarch.module("Screw.Interface", {
10 |   refresh: function() {
11 |     this.setLocation(this.getLocation());
12 |   },
13 | 
14 |   setLocation: function(location) {
15 |     window.location = location;
16 |   },
17 | 
18 |   getLocation: function() {
19 |     return window.location;
20 |   },
21 | 
22 |   baseLocation: function() {
23 |     return this.getLocation().href.split('?')[0];
24 |   },
25 | 
26 |   examplesToRun: function() {
27 |     return [Screw.rootDescription()];
28 |   }
29 | });
30 | 
31 | })(Screw, Monarch, jQuery);
32 | 


--------------------------------------------------------------------------------
/lib/screw_unit/resources/suite_completion.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   module Resources
 3 |     class SuiteCompletion
 4 |       def initialize(kill_server_on_completion)
 5 |         @kill_server_on_completion = kill_server_on_completion
 6 |       end
 7 | 
 8 |       def kill_server_on_completion?
 9 |         @kill_server_on_completion
10 |       end
11 | 
12 |       def post(request)
13 |         puts request.body.string unless request.body.string == "success"
14 |         if kill_server_on_completion?
15 |           $exit_status = (request.body.string == "success") ? 0 : 1
16 |           Thread.new do
17 |             sleep 1 # give the server thread a moment to send the response before we kill it
18 |             $thin_server.stop!
19 |           end
20 |         end
21 |         [200, {}, "OK"]
22 |       end
23 |     end
24 |   end
25 | end
26 | 


--------------------------------------------------------------------------------
/lib/screw_unit/resources/dir.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   module Resources
 3 |     class Dir < File
 4 |       def locate(name)
 5 |         virtual_child_path = ::File.join(virtual_path, name)
 6 |         physical_child_path = asset_manager.physicalize_path(virtual_child_path)
 7 | 
 8 |         if physical_child_path && ::File.exists?(physical_child_path)
 9 |           if ::File.directory?(physical_child_path)
10 |             Dir.new(virtual_child_path, asset_manager)
11 |           else
12 |             File.new(virtual_child_path, asset_manager)
13 |           end
14 |         else
15 |           FileNotFound.new(virtual_child_path)
16 |         end
17 |       end
18 | 
19 |       def glob(glob_pattern)
20 |         asset_manager.glob_virtual_paths(::File.join(virtual_path, glob_pattern)).map {|virtual_path| File.new(virtual_path, asset_manager)}
21 |       end
22 |     end
23 |   end
24 | end
25 | 


--------------------------------------------------------------------------------
/example/spec/suite.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |   <head>
 3 |     <script src="../../lib/javascript/jquery-1.2.6.js"></script>
 4 |     <script src="../../lib/jquery.fn.js"></script>
 5 |     <script src="../../lib/javascript/jquery.print.js"></script>
 6 |     <script src="../../lib/screw.builder.js"></script>
 7 |     <script src="../../lib/javascript/screw.matchers.js"></script>
 8 |     <script src="../../lib/screw.events.js"></script>
 9 |     <script src="../../lib/screw.behaviors.js"></script>
10 |     
11 |     <script src="spec_helper.js"></script>
12 |     <script src="matchers/have.js"></script>
13 |     
14 |     <script src="../lib/models/cat.js"></script>
15 |     <script src="../lib/models/man.js"></script>
16 |     
17 |     <script src="models/cat_spec.js"></script>
18 |     <script src="models/man_spec.js"></script>
19 |     
20 |     <link rel="stylesheet" href="../../lib/javascript/screw.css">
21 |   </head>
22 |   <body>
23 |     <div id="dom_test" style="position: absolute; left: -9999"></div>
24 |   </body>
25 | </html>
26 | 


--------------------------------------------------------------------------------
/lib/screw_unit/resources/streaming_spec_runner.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   module Resources
 3 |     class StreamingSpecRunner < SpecRunner
 4 |       def content
 5 |         "<html>\n<head>\n" +
 6 |           screw_unit_css_file_link_tag +
 7 |           "\n\n" +
 8 |           "<!-- ScrewUnit core scripts -->\n" +
 9 |           core_file_script_tags +
10 |           "\n\n" +
11 |           "<!-- scripts required by the specs -->\n" +
12 |           required_script_tags +
13 |           "\n" +
14 |           run_specs_on_page_load +
15 |           "\n</head>\n<body>\n</body>\n</html>\n"
16 |       end
17 | 
18 |       def required_virtual_paths
19 |         asset_manager.virtual_dependency_paths_from_physical_paths(spec_file_physical_paths) - spec_file_virtual_paths
20 |       end
21 | 
22 |       def run_specs_on_page_load
23 |         %{<script type="text/javascript">Screw.Interface.StreamingRunner.run_specs_on_page_load({spec_paths: #{spec_file_virtual_paths.inspect}});</script>}
24 |       end
25 |     end
26 |   end
27 | end
28 | 


--------------------------------------------------------------------------------
/example/spec/models/cat_spec.js:
--------------------------------------------------------------------------------
 1 | //= require "../spec_helper"
 2 | 
 3 | Screw.Unit(function(c) { with(c) {
 4 |   describe('Cat', function() {
 5 |     var cat;
 6 |     
 7 |     describe('#cross_path', function() {
 8 |       describe('when the cat has black fur', function() {
 9 |         before(function() {
10 |           cat = new Cat({color: 'black'});
11 |         });
12 |         
13 |         it("decrements the man's luck by 5", function() {
14 |           var man = new Man({luck: 5});
15 |           cat.cross_path(man);
16 |           expect(man.luck()).to(equal, 0);
17 |         });
18 |       });
19 |       
20 |       describe('when the cat has non-black fur', function() {
21 |         before(function() {
22 |           cat = new Cat({color: 'white'});
23 |         });
24 |         
25 |         it("does not change the man's luck", function() {
26 |           var man = new Man({luck: 5});          
27 |           cat.cross_path(man);
28 |           expect(man.luck()).to(equal, 5);
29 |         });
30 |       });
31 |     });
32 |   });
33 | }});
34 | 


--------------------------------------------------------------------------------
/lib/screw_unit/resources/file.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   module Resources
 3 |     class File
 4 |       attr_reader :virtual_path, :asset_manager
 5 |       def initialize(virtual_path, asset_manager)
 6 |         @virtual_path, @asset_manager = virtual_path, asset_manager
 7 |       end
 8 | 
 9 |       def physical_path
10 |         asset_manager.physicalize_path(virtual_path)
11 |       end
12 | 
13 |       def get
14 |         [200, headers, ::File.read(physical_path)]
15 |       end
16 | 
17 |       MIME_TYPES = {
18 |         ".css" => "text/css",
19 |         ".gif" => "image/gif",
20 |         ".js" => "application/javascript",
21 |         ".jpg" => "image/jpeg",
22 |         ".jpeg" => "image/jpeg",
23 |         ".png" => "image/png",
24 |         }
25 | 
26 |       def headers
27 |         {
28 |           "Content-Type" => mime_type(physical_path),
29 |           "Last-Modified" => ::File.mtime(physical_path).httpdate
30 |         }
31 |       end
32 | 
33 |       protected
34 | 
35 |       def mime_type(physical_path)
36 |         MIME_TYPES[::File.extname(physical_path)]
37 |       end
38 |     end
39 |   end
40 | end
41 | 


--------------------------------------------------------------------------------
/lib/screw_unit/resources/spec_dir.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   module Resources
 3 |     class SpecDir < Dir
 4 |       def locate(name)
 5 |         if name == 'streaming'
 6 |           return StreamingSpecRunner.new(glob("/**/*_spec.js"), asset_manager)
 7 |         end
 8 | 
 9 |         virtual_child_path = ::File.join(virtual_path, name)
10 |         physical_child_path = asset_manager.physicalize_path(virtual_child_path)
11 | 
12 |         if physical_child_path && ::File.exists?(physical_child_path)
13 |           if ::File.directory?(physical_child_path)
14 |             SpecDir.new(virtual_child_path, asset_manager)
15 |           else
16 |             File.new(virtual_child_path, asset_manager)
17 |           end
18 |         elsif physical_child_path && ::File.exists?(physical_child_path + ".js")
19 |           SpecRunner.new([File.new(virtual_child_path + ".js", asset_manager)], asset_manager)
20 |         else
21 |           FileNotFound.new(virtual_child_path)
22 |         end
23 |       end
24 | 
25 |       def get
26 |         SpecRunner.new(glob("/**/*_spec.js"), asset_manager).get
27 |       end
28 |     end
29 |   end
30 | end
31 | 


--------------------------------------------------------------------------------
/example/spec/models/man_spec.js:
--------------------------------------------------------------------------------
 1 | //= require "../spec_helper"
 2 | 
 3 | Screw.Unit(function(c) { with(c) {
 4 |   describe('Man', function() {
 5 |     var man;
 6 |     before(function() {
 7 |       man = new Man({luck: 5});
 8 |     });
 9 |     
10 |     describe('#decrement_luck', function() {
11 |       it("decrements the luck field by the given amount", function() {
12 |         man.decrement_luck(3);
13 |         expect(man.luck()).to(equal, 2)
14 |       });
15 |       
16 |       describe('when the decrement exceeds the luck balance', function() {
17 |         it("decrements the luck field to zero", function() {
18 |           man.decrement_luck(10000000000);
19 |           expect(man.luck()).to(equal, 0);
20 |         });
21 |       });
22 |     });
23 |     
24 |     describe('@click', function() {
25 |       before(function() {
26 |         Screw.$('#test_content').append(man.render());
27 |       });
28 |       
29 |       it("removes the man's hair", function() {
30 |         expect(Screw.$('.man .hair')).to_not(be_empty);
31 |         Screw.$('.man').click();
32 |         expect(Screw.$('.man .hair')).to(be_empty);
33 |       });
34 |     });
35 |   });
36 | }});
37 | 


--------------------------------------------------------------------------------
/lib/screw_unit/dispatcher.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   class Dispatcher
 3 |     attr_reader :root, :resource_locators
 4 | 
 5 |     def initialize(configuration)
 6 |       @resource_locators = configuration.resource_locators
 7 |       @root = Resources::Root.new(configuration)
 8 |     end
 9 | 
10 |     def call(env)
11 |       request = Rack::Request.new(env)
12 |       resource = locate_resource(request.path_info)
13 |       case(request.request_method)
14 |       when "GET"
15 |         resource.get
16 |       when "POST"
17 |         resource.post(request)
18 |       else
19 |         raise "unrecognized HTTP method #{request.request_method}"
20 |       end
21 |     rescue Exception => e
22 |       puts e.message
23 |       puts e.backtrace
24 |     end
25 | 
26 |     def locate_resource(path)
27 |       resource_locators.each do |locator|
28 |         resource = locator.locate_resource(path)
29 |         return resource if resource
30 |       end
31 | 
32 |       path_parts(path).inject(root) do |resource, child_resource_name|
33 |         resource.locate(child_resource_name)
34 |       end
35 |     end
36 | 
37 |     def path_parts(path)
38 |       path.split('/').reject { |part| part == "" }
39 |     end
40 |   end
41 | end
42 | 


--------------------------------------------------------------------------------
/spec/screw_unit/js_file_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   describe JsFile do
 5 |     attr_reader :js_file, :dir
 6 | 
 7 |     before do
 8 |       @dir = File.expand_path(File.dirname(__FILE__))
 9 |       asset_manager = Configuration.new.asset_manager
10 |       asset_manager.add_js_location("/implementations", "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_3")
11 |       @js_file = JsFile.new("#{dir}/file_system_fixtures_for_asset_manager_specs/dir_1/1.js", asset_manager)
12 |     end
13 | 
14 |     describe "#require_declarations" do
15 |       it "returns a relative or global RequireDeclaration for every Sprockets-style require declaration in the file" do
16 |         require_declarations = js_file.require_declarations
17 |         require_declarations.size.should == 3
18 |         require_declarations[0].js_file.physical_path.should == "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_1/subdir_1/4.js"
19 |         require_declarations[1].js_file.physical_path.should == "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_1/7.js"
20 |         require_declarations[2].js_file.physical_path.should == "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_3/3.js"
21 |       end
22 |     end
23 |   end
24 | end
25 | 


--------------------------------------------------------------------------------
/lib/screw_unit/server.rb:
--------------------------------------------------------------------------------
 1 | require "selenium"
 2 | 
 3 | module ScrewUnit
 4 |   class Server
 5 |     attr_reader :thin_thread
 6 | 
 7 |     def self.start(options)
 8 |       new.start(options)
 9 |     end
10 | 
11 |     def start(configuration)
12 |       start_thin_server_in_new_thread(configuration)
13 |       open_suite_with_selenium(configuration) if configuration.selenium_mode?
14 |       thin_thread.join
15 |     end
16 | 
17 |     def start_thin_server_in_new_thread(configuration)
18 |       @thin_thread = Thread.new do
19 |         $thin_server = Thin::Server.new(configuration.port) do
20 |           run Dispatcher.new(configuration)
21 |         end
22 |         $thin_server.start
23 |       end
24 |     end
25 | 
26 |     def open_suite_with_selenium(port)
27 |       selenium_driver = Selenium::SeleniumDriver.new(
28 |         Configuration.selenium_host,
29 |         Configuration.selenium_port,
30 |         Configuration.selenium_browser_string,
31 |         "#{Configuration.selenium_screw_server_url}:#{Configuration.selenium_screw_server_port}"
32 |       )
33 | 
34 |       at_exit do
35 |         selenium_driver.stop
36 |       end
37 | 
38 |       selenium_driver.start
39 |       selenium_driver.set_timeout(300000)
40 |       selenium_driver.open(Configuration.selenium_specs_path)
41 |     end
42 |   end
43 | end
44 | 


--------------------------------------------------------------------------------
/client/lib/screw/interface/example.js:
--------------------------------------------------------------------------------
 1 | (function(Screw, Monarch) {
 2 | 
 3 | Monarch.constructor("Screw.Interface.Example", Monarch.View.Template, {
 4 |   content: function(initialAttributes) { with(this.builder) {
 5 |     li({'class': 'example'}, function() {
 6 |       span(initialAttributes.example.name, {'class': 'name'}).click(function(view) {
 7 |         view.focus();
 8 |       });
 9 |     });
10 |   }},
11 | 
12 |   viewProperties: {
13 |     initialize: function() {
14 |       var self = this;
15 |       this.example.onPass(function() {
16 |         self.addClass("passed");
17 |       })
18 |       this.example.onFail(function(e) {
19 |         self.addClass("failed");
20 | 
21 |         var message = Screw.$("<div class='failureMessage'/>");
22 |         message.text(e.message);
23 | 
24 |         var trace = Screw.$("<pre class='failureTrace'/>");
25 |         if (e.stack) {
26 |           var enhancedStack = e.stack.replace(/http:\/\/(.*_spec)\.js/g, '<a href="http://$1" target="Blank">http://$1.js</a>')
27 |           trace.html(enhancedStack);
28 |         }
29 | 
30 |         self.append(message);
31 |         self.append(trace);
32 |       });
33 |     },
34 | 
35 |     focus: function() {
36 |       Screw.Interface.setLocation(Screw.Interface.baseLocation() + "?" + JSON.stringify([this.example.path()]));
37 |     }
38 |   }
39 | });
40 | 
41 | })(Screw, Monarch);
42 | 


--------------------------------------------------------------------------------
/spec/screw_unit/asset_location_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   describe AssetLocation do
 5 |     attr_reader :dir
 6 | 
 7 |     before do
 8 |       @dir = File.dirname(__FILE__)
 9 |     end
10 | 
11 |     describe "#subsumes_virtual_glob_pattern?" do
12 |       it "returns true only if the glob pattern is within the #virtual_prefix" do
13 |         location = AssetLocation.new("/foo/bar", "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_1")
14 |         location.subsumes_virtual_glob_pattern?("/foo/bar/**/*.js").should be_true
15 |         location.subsumes_virtual_glob_pattern?("/foo/bar/quux/**/*.js").should be_true
16 |         location.subsumes_virtual_glob_pattern?("/quux/bar/**/*.js").should be_false
17 |         location.subsumes_virtual_glob_pattern?("/foo/bar_x/**/*.js").should be_false
18 |       end
19 |     end
20 | 
21 |     describe "#is_subsumed_by_virtual_glob_pattern?" do
22 |       it "returns true only if the glob pattern contains the #virtual_prefix" do
23 |         location = AssetLocation.new("/foo/bar", "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_1")
24 |         location.is_subsumed_by_virtual_glob_pattern?("/foo/**/*.js").should be_true
25 |         location.is_subsumed_by_virtual_glob_pattern?("/foo/bar/**/*.js").should be_true
26 |         location.is_subsumed_by_virtual_glob_pattern?("/foo/ba/**/*.js").should be_false
27 |         location.is_subsumed_by_virtual_glob_pattern?("/foo/bar/quux/**/*.js").should be_false
28 |       end
29 |     end
30 |   end
31 | end
32 | 


--------------------------------------------------------------------------------
/README.txt:
--------------------------------------------------------------------------------
 1 | = screw_unit
 2 | 
 3 | * http://screw_unit.rubyforge.org
 4 | 
 5 | == DESCRIPTION:
 6 | 
 7 | * A reimplementation of Screw.Unit, with a featureful runner and a simple, baked-in http server.
 8 | 
 9 | == FEATURES/PROBLEMS:
10 | 
11 | * FIX (list of features or problems)
12 | 
13 | == SYNOPSIS:
14 | 
15 |   FIX (code sample of usage)
16 | 
17 | == REQUIREMENTS:
18 | 
19 | * FIX (list of requirements)
20 | 
21 | == INSTALL:
22 | 
23 | * FIX (sudo gem install, anything else)
24 | 
25 | == LICENSE:
26 | 
27 | (The MIT License)
28 | 
29 | Copyright (c) 2009 FIX
30 | 
31 | Permission is hereby granted, free of charge, to any person obtaining
32 | a copy of this software and associated documentation files (the
33 | 'Software'), to deal in the Software without restriction, including
34 | without limitation the rights to use, copy, modify, merge, publish,
35 | distribute, sublicense, and/or sell copies of the Software, and to
36 | permit persons to whom the Software is furnished to do so, subject to
37 | the following conditions:
38 | 
39 | The above copyright notice and this permission notice shall be
40 | included in all copies or substantial portions of the Software.
41 | 
42 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
43 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
44 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
45 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
46 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
47 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
48 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
49 | 


--------------------------------------------------------------------------------
/client/lib/screw/interface/progress_bar.js:
--------------------------------------------------------------------------------
 1 | (function(Screw, Monarch) {
 2 | 
 3 | Monarch.constructor("Screw.Interface.ProgressBar", Monarch.View.Template, {
 4 |   content: function(initialAttributes) { with(this.builder) {
 5 |     div({'id': 'screwUnitProgressBar'}, function() {
 6 |       div({'id': 'screwUnitProgress'});
 7 |       div({'id': 'screwUnitProgressText'});
 8 |     });
 9 |   }},
10 | 
11 |   viewProperties: {
12 |     initialize: function() {
13 |       var self = this;
14 |       this.totalExamples = this.root.totalExamples();
15 |       this.root.onExampleCompleted(function(example) {
16 |         self.updateProgress(example);
17 |       });
18 | 
19 | 
20 |       this.completedExamples = 0;
21 |       this.failedExamples = 0;
22 | 
23 |       this.progressDiv = this.find('div#screwUnitProgress');
24 |       this.progressTextDiv = this.find('div#screwUnitProgressText');
25 | 
26 |       this.resizeProgressDiv();
27 |       this.refreshProgressText();
28 |     },
29 | 
30 |     updateProgress: function(example) {
31 |       this.completedExamples++;
32 |       if (example.failed) {
33 |         this.failedExamples++;
34 |         this.addClass('failed');
35 |       }
36 | 
37 |       this.resizeProgressDiv();
38 |       this.refreshProgressText();
39 |     },
40 | 
41 |     resizeProgressDiv: function() {
42 |       var percentComplete = (this.totalExamples == 0) ? 0 : (this.completedExamples / this.totalExamples * 100);
43 |       this.progressDiv.css("width", percentComplete + "%");
44 |     },
45 | 
46 |     refreshProgressText: function() {
47 |       this.progressTextDiv.html(this.completedExamples + " of " + this.totalExamples + " completed. " + this.failedExamples + " failed.");
48 |     }
49 |   }
50 | });
51 | 
52 | })(Screw, Monarch);
53 | 


--------------------------------------------------------------------------------
/client/lib/screw/require.js:
--------------------------------------------------------------------------------
 1 | (function(Screw, Monarch, jQuery) {
 2 | 
 3 | 
 4 | Monarch.module("Screw.Require", {
 5 |   requiredPaths: [],
 6 |   includedStylesheets: {},
 7 |   cacheBuster:  parseInt(new Date().getTime()/(1*1000)),
 8 |   useCacheBuster: true,
 9 | 
10 |   require: function(javascriptPath, onload) {
11 |     if (Screw.Require.requiredPaths[javascriptPath]) return;
12 |     var fullPath = javascriptPath + ".js";
13 | 
14 |     if (Screw.Require.useCacheBuster) {
15 |       fullPath += '?' + Screw.Require.cacheBuster;
16 |     }
17 | 
18 |     var scriptTag = document.createElement('script');
19 |     scriptTag.type = 'text/javascript';
20 |     scriptTag.src = fullPath;
21 |     scriptTag.onload = function() {
22 |       if (onload) onload();
23 |     };
24 |     jQuery('head')[0].appendChild(scriptTag);
25 | 
26 |     Screw.Require.requiredPaths[javascriptPath] = true;
27 |   },
28 | 
29 | 
30 |   stylesheet: function(stylesheetPath) {
31 |     if(Screw.Require.includedStylesheets[stylesheetPath]) return;
32 |     var fullPath = stylesheetPath + ".css";
33 |     if(Screw.Require.useCacheBuster) {
34 |       fullPath += '?' + Screw.Require.cacheBuster;
35 |     }
36 |     jQuery('head').append(Screw.Require.tag("link", {rel: 'stylesheet', type: 'text/css', href: fullPath}));
37 |     Screw.Require.includedStylesheets[stylesheetPath] = true;
38 |   },
39 | 
40 |   tag: function(name, attributes) {
41 |     var html = "<" + name;
42 |     for(var attribute in attributes) {
43 |       html += (" " + attribute + "='" + attributes[attribute]) + "'";
44 |     };
45 | 
46 |     if (name == "script") {
47 |       html += "></";
48 |       html += name;
49 |       html += ">";
50 |     } else {
51 |       html += "/>";
52 |     }
53 | 
54 |     return html;
55 |   }
56 | });
57 | 
58 | })(Screw, Monarch, jQuery);
59 | 
60 | window.require = Screw.Require.require;
61 | window.stylesheet = Screw.Require.stylesheet;
62 | 


--------------------------------------------------------------------------------
/client/stylesheets/screw.css:
--------------------------------------------------------------------------------
  1 | html {
  2 |   padding: 0.1em;
  3 |   font-family: sans-serif;
  4 | }
  5 | 
  6 | .description, .example {
  7 |   display: none;
  8 | }
  9 | 
 10 | div#screwUnitRunner.showAll .description, div#screwUnitRunner.showAll .example {
 11 |   display: block;
 12 | }
 13 | 
 14 | div#screwUnitRunner.showFailed .failed {
 15 |   display: block;
 16 | }
 17 | 
 18 | 
 19 | table#screwUnitHeader {
 20 |   width: 100%;
 21 | }
 22 | 
 23 | td#screwUnitControls {
 24 |   padding: 10px;
 25 |   width: 20%;
 26 |   text-align: center;
 27 | }
 28 | 
 29 | div#screwUnitProgressBar {
 30 |   border: 1px solid #cccccc;
 31 |   width: 100%;
 32 |   height: 25px;
 33 |   background: #252525;
 34 | }
 35 | 
 36 | div#screwUnitProgressText {
 37 |   position: relative;
 38 |   top: -20px;
 39 |   padding-left: 5px;
 40 |   color: white;
 41 | }
 42 | 
 43 | div#screwUnitProgressBar.failed div#screwUnitProgress {
 44 |   background: red;
 45 | }
 46 | 
 47 | div#screwUnitProgressBar div#screwUnitProgress {
 48 |   background: green;
 49 |   height: 25px;
 50 | }
 51 | 
 52 | ul.descriptions.failed {
 53 |   background-color: #F62B2B;
 54 | }
 55 | 
 56 | ul.descriptions.passed {
 57 |   background-color: #1E7C0E;
 58 | }
 59 | 
 60 | li {
 61 |   list-style-type: none;
 62 | }
 63 | 
 64 | ul {
 65 |   padding: .3em;
 66 | }
 67 | 
 68 | ul.descriptions {
 69 |   background: #e2e1e1;
 70 | }
 71 | 
 72 | li.description {
 73 |   border: 1px solid #a4a4a4;
 74 | }
 75 | 
 76 | li.description span.name {
 77 |   cursor: pointer;
 78 | }
 79 | 
 80 | ul.childDescriptions {
 81 |   margin-left: .6em;
 82 |   background: #e2e1e1;
 83 | }
 84 | 
 85 | li.example {
 86 |   margin: 0;
 87 |   padding: .3em;
 88 |   background: white;
 89 | }
 90 | 
 91 | li.example span.name {
 92 |   cursor: pointer;
 93 | }
 94 | 
 95 | 
 96 | li.example.passed {
 97 |   background: #95ff95;
 98 | }
 99 | 
100 | li.example.failed {
101 |   background: #ff9696;
102 | }


--------------------------------------------------------------------------------
/spec/screw_unit/resources/root_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   module Resources
 5 |     describe Root do
 6 |       attr_reader :root, :options, :configuration
 7 |       before do
 8 |         dir = ::File.dirname(__FILE__)
 9 |         @configuration = Configuration.new
10 |         @root = Root.new(configuration)
11 |       end
12 | 
13 |       describe "#locate" do
14 |         context "when called with 'specs'" do
15 |           it "returns a SpecDir resource with a #virtual_path of '/specs' and the same AssetManager" do
16 |             specs_dir = root.locate('specs')
17 |             specs_dir.class.should == Resources::SpecDir
18 |             specs_dir.virtual_path.should == "/specs"
19 |             specs_dir.asset_manager.should == configuration.asset_manager
20 |           end
21 |         end
22 | 
23 |         context "when called with 'complete'" do
24 | 
25 |           context "when #selenium_mode? is true on the given configuration" do
26 |             before do
27 |               configuration.selenium_mode
28 |             end
29 | 
30 |             it "returns a SuiteCompletion with #kill_server_on_completion? set to true" do
31 |               suite_completion = root.locate('complete')
32 |               suite_completion.class.should == Resources::SuiteCompletion
33 |               suite_completion.kill_server_on_completion?.should be_true
34 |             end
35 |           end
36 | 
37 |           context "when #selenium_mode? is false on the given configuration" do
38 |             it "returns a SuiteCompletion with #kill_server_on_completion? set to false" do
39 |               suite_completion = root.locate('complete')
40 |               suite_completion.class.should == Resources::SuiteCompletion
41 |               suite_completion.kill_server_on_completion?.should be_false
42 |             end
43 |           end
44 |         end
45 |       end
46 |     end
47 |   end
48 | end
49 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/spec_runner_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   module Resources
 5 |     describe SpecRunner do
 6 |       attr_reader :dir, :spec_file_resources, :spec_suite, :asset_manager
 7 | 
 8 |       before do
 9 |         @dir = ::File.expand_path(::File.dirname(__FILE__))
10 |         @asset_manager = Configuration.new.asset_manager
11 |         asset_manager.add_location("/specs", "#{dir}/file_system_fixtures/specs")
12 |         @spec_file_resources = Dir.new("/specs", asset_manager).glob("**/*.js")
13 |         @spec_suite = SpecRunner.new(spec_file_resources, asset_manager)
14 |       end
15 | 
16 |       describe "#get" do
17 |         attr_reader :response_code, :headers, :content
18 |         before do
19 |           @response_code, @headers, @content = spec_suite.get
20 |         end
21 | 
22 |         it "returns a response code of 200" do
23 |           response_code.should == 200
24 |         end
25 | 
26 |         it "returns a Content-Type header of 'text/html'" do
27 |           headers['Content-Type'].should == "text/html"
28 |         end
29 | 
30 |         it "includes the relative paths of all the screw unit core files" do
31 |           Dir.new("/screw_unit_core", asset_manager).glob("/**/*.js").each do |core_file_resource|
32 |             expected_include_tag = %{<script type="text/javascript" src="#{core_file_resource.virtual_path}"></script>}
33 |             content.should match(/#{expected_include_tag}/)
34 |           end
35 |         end
36 | 
37 |         it "includes the relative paths of all the scripts files with which it was initialized" do
38 |           spec_file_resources.each do |spec_file_resource|
39 |             expected_include_tag = %{<script type="text/javascript" src="#{spec_file_resource.virtual_path}"></script>}
40 |             content.should match(/#{expected_include_tag}/)
41 |           end
42 |         end
43 |       end
44 |     end
45 |   end
46 | end
47 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/spec_suite_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   module Resources
 5 |     describe SpecRunner do
 6 |       attr_reader :dir, :spec_file_resources, :spec_suite, :asset_manager
 7 | 
 8 |       before do
 9 |         @dir = ::File.expand_path(::File.dirname(__FILE__))
10 |         @asset_manager = Configuration.new.asset_manager
11 |         asset_manager.add_location("/specs", "#{dir}/file_system_fixtures/specs")
12 |         @spec_file_resources = Dir.new("/specs", asset_manager).glob("**/*.js")
13 |         @spec_suite = SpecRunner.new(spec_file_resources, asset_manager)
14 |       end
15 | 
16 |       describe "#get" do
17 |         attr_reader :response_code, :headers, :content
18 |         before do
19 |           @response_code, @headers, @content = spec_suite.get
20 |         end
21 | 
22 |         it "returns a response code of 200" do
23 |           response_code.should == 200
24 |         end
25 | 
26 |         it "returns a Content-Type header of 'text/html'" do
27 |           headers['Content-Type'].should == "text/html"
28 |         end
29 | 
30 |         it "includes the relative paths of all the screw unit core files" do
31 |           Dir.new("/screw_unit_core", asset_manager).glob("/**/*.js").each do |core_file_resource|
32 |             expected_include_tag = %{<script type="text/javascript" src="#{core_file_resource.virtual_path}"></script>}
33 |             content.should match(/#{expected_include_tag}/)
34 |           end
35 |         end
36 | 
37 |         it "includes the relative paths of all the scripts files with which it was initialized" do
38 |           spec_file_resources.each do |spec_file_resource|
39 |             expected_include_tag = %{<script type="text/javascript" src="#{spec_file_resource.virtual_path}"></script>}
40 |             content.should match(/#{expected_include_tag}/)
41 |           end
42 |         end
43 |       end
44 |     end
45 |   end
46 | end
47 | 


--------------------------------------------------------------------------------
/spec/screw_unit/configuration_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 | 
 5 |   describe ".configure" do
 6 |     it "instance evals the given block in an instance of Configuration" do
 7 |       block = lambda {}
 8 |       mock(Configuration.instance.instance_eval(&block))
 9 |       ScrewUnit.configure(&block)
10 |     end
11 |   end
12 | 
13 |   describe Configuration do
14 |     attr_reader :configuration
15 |     before do
16 |       @configuration = Configuration.new
17 |     end
18 | 
19 |     describe ".instance" do
20 |       it "always returns the same instance of Configuration" do
21 |         instance = Configuration.instance
22 |         instance.class.should == Configuration
23 |         instance.should == Configuration.instance
24 |       end
25 |     end
26 | 
27 |     describe "#load_screwrc" do
28 |       it "loads .screwrc from the given base_path and assigns #path_containing_screwrc" do
29 |         mock(configuration).load("/base/path/.screwrc")
30 |         configuration.load_screwrc("/base/path")
31 |         configuration.path_containing_screwrc.should == "/base/path"
32 |       end
33 |     end
34 | 
35 |     describe "#add_js_location" do
36 |       it "proxies to #asset_manager after absolutizing the relative physical path from the path containing the .screwrc file" do
37 |         stub(configuration).path_containing_screwrc { '/path_containing_screwrc' }
38 |         mock(configuration.asset_manager).add_js_location('/foo', '/path_containing_screwrc/bar')
39 |         configuration.add_js_location('/foo', 'bar')
40 |       end
41 |     end
42 | 
43 |     describe "#add_location" do
44 |       it "proxies to #asset_manager after absolutizing the relative physical path from the path containing the .screwrc file" do
45 |         stub(configuration).path_containing_screwrc { '/path_containing_screwrc' }
46 |         mock(configuration.asset_manager).add_location('/foo', '/path_containing_screwrc/bar')
47 |         configuration.add_location('/foo', 'bar')
48 |       end
49 |     end
50 |   end
51 | end
52 | 


--------------------------------------------------------------------------------
/client/lib/screw/screw.js:
--------------------------------------------------------------------------------
 1 | Screw = {};
 2 | (function(Screw, Monarch) {
 3 | 
 4 | Monarch.module("Screw", {
 5 |   Unit: function(specification) {
 6 |     if (!this.sharedContext) this.sharedContext = new Screw.Context();
 7 |     specification(this.sharedContext);
 8 |   },
 9 | 
10 |   clear: function() {
11 |     this.RootDescription.clearChildren();
12 |   },
13 | 
14 |   rootDescription: function() {
15 |     return this.RootDescription = this.RootDescription || new Screw.Description("All specs");
16 |   },
17 | 
18 |   mocks: [],
19 | 
20 |   resetMocks: function() {
21 |     Screw.each(Screw.mocks, function() {
22 |       this.mockedObject[this.functionName] = this.originalFunction;
23 |     })
24 |     Screw.mocks = [];
25 |   },
26 | 
27 |   currentDescription: function() {
28 |     return this.descriptionStack()[this.descriptionStack().length - 1];
29 |   },
30 | 
31 |   pushDescription: function(description) {
32 |     this.descriptionStack().push(description);
33 |   },
34 | 
35 |   popDescription: function() {
36 |     var description = this.descriptionStack().pop();
37 |     this.currentDescription().addDescription(description)
38 |   },
39 | 
40 |   pushScenario: function(scenarioDescription) {
41 |     this.descriptionStack().push(scenarioDescription);
42 |   },
43 | 
44 |   popScenario: function() {
45 |     var scenarioDescription = this.descriptionStack().pop();
46 |     this.currentDescription().addScenario(scenarioDescription);
47 |   },
48 | 
49 |   descriptionStack: function() {
50 |     if (!this.DescriptionStack) {
51 |       this.DescriptionStack = [this.rootDescription()];
52 |     }
53 |     return this.DescriptionStack;
54 |   },
55 | 
56 |   map: function(array, fn) {
57 |     var results = [];
58 |     Screw.each(array, function() {
59 |       results.push(fn.call(this));
60 |     });
61 |     return results;
62 |   },
63 | 
64 |   each: function(array, fn) {
65 |     for (var i = 0; i < array.length; i++) {
66 |       fn.call(array[i]);
67 |     }
68 |   },
69 | 
70 |   reverseEach: function(array, fn) {
71 |     for (var i = array.length - 1; i >= 0; i--) {
72 |       fn.call(array[i]);
73 |     }
74 |   }
75 | });
76 | 
77 | })(Screw, Monarch);
78 | 


--------------------------------------------------------------------------------
/client/lib/screw/example.js:
--------------------------------------------------------------------------------
 1 | (function(Screw, Monarch) {
 2 | 
 3 | Monarch.constructor("Screw.Example", Screw.RunnableMethods, {
 4 |   initialize: function(name, fn) {
 5 |     this.name = name;
 6 |     this.fn = fn;
 7 |     this.failSubscriptionNode = new Monarch.SubscriptionNode();
 8 |     this.passSubscriptionNode = new Monarch.SubscriptionNode();
 9 |     this.exampleCompletedSubscriptionNode = new Monarch.SubscriptionNode();
10 |     this.passed = false;
11 |     this.failed = false;
12 |     this.failureMessage = null;
13 |   },
14 | 
15 |   clone: function() {
16 |     var clone = Screw.$.extend(new Screw.Example(), this);
17 |     clone.initialize(this.name, this.fn);
18 |     return clone;
19 |   },
20 |   
21 |   addToQueue: function(queue) {
22 |     var self = this;
23 |     queue.add(function() {
24 |       self.run();
25 |     });
26 |   },
27 | 
28 |   run: function() {
29 |     try {
30 |       try {
31 |         var exampleContext = {};
32 |         this.parentDescription.runInits(exampleContext);
33 |         this.parentDescription.runBefores(exampleContext);
34 |         this.fn.call(exampleContext);
35 |       } finally {
36 |         this.parentDescription.runAfters(exampleContext);
37 |         Screw.resetMocks();
38 |       }
39 |       this.passed = true;
40 |       this.passSubscriptionNode.publish();
41 |       this.exampleCompletedSubscriptionNode.publish(this);
42 |     } catch(e) {
43 |       this.failed = true;
44 | 
45 |       if (!e.stack) {
46 |         e.stack = e.message + " (" + e.sourceURL + ":" + e.line + ")";
47 |       }
48 | 
49 |       this.failureMessage = e.message;
50 |       this.stack = e.stack;
51 |       this.failSubscriptionNode.publish(e);
52 |       this.exampleCompletedSubscriptionNode.publish(this);
53 |     }
54 |   },
55 | 
56 |   onFail: function(callback) {
57 |     this.failSubscriptionNode.subscribe(callback);
58 |   },
59 | 
60 |   onPass: function(callback) {
61 |     this.passSubscriptionNode.subscribe(callback);
62 |   },
63 | 
64 |   totalExamples: function() {
65 |     return 1;
66 |   },
67 | 
68 |   fullName: function() {
69 |     return this.parentDescription.fullName() + this.name;
70 |   }
71 | });
72 | 
73 | })(Screw, Monarch);
74 | 


--------------------------------------------------------------------------------
/spec/screw_unit/dispatcher_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   describe Dispatcher do
 5 |     attr_reader :dispatcher, :locator_1, :locator_2
 6 |     before do
 7 |       @locator_1 = Object.new
 8 |       @locator_2 = Object.new
 9 |       @dispatcher = Dispatcher.new(configuration)
10 |     end
11 | 
12 |     describe "#locate_resource(path)" do
13 |       context "when there are #resource_locators" do
14 |         def configuration
15 |           return @configuration if @configuration
16 |           @configuration = Configuration.new
17 |           @configuration.add_resource_locator(locator_1)
18 |           @configuration.add_resource_locator(locator_2)
19 |           @configuration
20 |         end
21 | 
22 |         context "when one of the custom locators returns a resource" do
23 |           attr_reader :resource
24 |           before do
25 |             @resource = Object.new
26 |             mock(locator_2).locate_resource("/foo").ordered { nil }
27 |             mock(locator_1).locate_resource("/foo").ordered { resource }
28 |           end
29 | 
30 |           it "returns that resource" do
31 |             dispatcher.locate_resource("/foo").should == resource
32 |           end
33 |         end
34 | 
35 |         context "when no custom locators return a resource" do
36 |           before do
37 |             mock(locator_2).locate_resource("/foo").ordered { nil }
38 |             mock(locator_1).locate_resource("/foo").ordered { nil }
39 |           end
40 | 
41 |           it "performs the normal dispatch starting at Resources::Root" do
42 |             mock.instance_of(Resources::Root).locate("foo")
43 |             dispatcher.locate_resource("/foo")
44 |           end
45 |         end
46 |       end
47 | 
48 |       context "when there are no #resource_locators" do
49 |         def configuration
50 |           @configuration ||= Configuration.new
51 |         end
52 | 
53 |         it "performs the normal dispatch starting at Resources::Root" do
54 |           mock.instance_of(Resources::Root).locate("foo")
55 |           dispatcher.locate_resource("/foo")
56 |         end
57 |       end
58 |     end
59 |   end
60 | end
61 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/spec_dir_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   module Resources
 5 |     describe SpecDir do
 6 |       attr_reader :spec_dir, :asset_manager
 7 | 
 8 |       before do
 9 |         dir = ::File.expand_path(::File.dirname(__FILE__))
10 |         @asset_manager = Configuration.new.asset_manager
11 |         asset_manager.add_js_location("/specs", "#{dir}/file_system_fixtures/specs")
12 |         @spec_dir = SpecDir.new("/specs", asset_manager)
13 |       end
14 | 
15 |       describe "#locate" do
16 |         describe "when called with the name of a directory" do
17 |           it "returns a SpecDir for that directory" do
18 |             spec_subdir = spec_dir.locate("subsuite")
19 |             spec_subdir.class.should == SpecDir
20 |             spec_subdir.virtual_path.should == "/specs/subsuite"
21 |           end
22 |         end
23 | 
24 |         describe "when called with the name of a .js file excluding the extension" do
25 |           it "returns a SpecRunner with the .js file as its only spec_file_resource" do
26 |             spec_suite = spec_dir.locate("foo_spec")
27 |             spec_suite.class.should == SpecRunner
28 |             spec_file_resources = spec_suite.spec_file_resources
29 |             spec_file_resources.length.should == 1
30 |             spec_file_resources.first.virtual_path.should == "/specs/foo_spec.js"
31 |           end
32 |         end
33 | 
34 |         describe "when called with the name of a .js file including the extension" do
35 |           it "returns a normal File resource for the File" do
36 |             spec_file = spec_dir.locate("foo_spec.js")
37 |             spec_file.class.should == File
38 |             spec_file.virtual_path.should == "/specs/foo_spec.js"
39 |           end
40 |         end
41 |       end
42 | 
43 |       describe "#get" do
44 |         it "returns the results of #get called on a SpecRunner instantiated with all /**/*.js files in the directory" do
45 |           spec_files = spec_dir.glob("/**/*.js")
46 |           spec_files.should_not be_empty
47 |           spec_dir.get.should == SpecRunner.new(spec_files, asset_manager).get
48 |         end
49 |       end
50 |     end
51 |   end
52 | end
53 | 


--------------------------------------------------------------------------------
/client/lib/screw/interface/description.js:
--------------------------------------------------------------------------------
 1 | (function(Screw, Monarch) {
 2 | 
 3 | Monarch.constructor("Screw.Interface.Description", Monarch.View.Template, {
 4 |   content: function(initialAttributes) { with (this.builder) {
 5 |     var description = initialAttributes.description;
 6 |     li({'class': 'description'}, function() {
 7 |       span({'class': 'name'}, description.name).click(function(view) {
 8 |         view.focus();
 9 |       });
10 | 
11 |       if (description.examples.length > 0) {
12 |         ul({'class': 'examples'});
13 |       }
14 | 
15 |       if (description.childDescriptions.length > 0) {
16 |         ul({'class': 'childDescriptions'});
17 |       }
18 |     });
19 |   }},
20 | 
21 |   viewProperties: {
22 |     initialize: function() {
23 |       this.buildExamples();
24 |       this.buildChildDescriptions();
25 |       
26 |       var self = this;
27 |       this.description.onExampleCompleted(function(example) {
28 |         if (example.failed) {
29 |           self.addClass('failed')
30 |         } else {
31 |           self.addClass('passed');
32 |         }
33 |       })
34 |     },
35 | 
36 |     buildExamples: function() {
37 |       var self = this;
38 |       var examplesContainer = this.find("ul.examples").eq(0);
39 |       Screw.each(this.description.examples, function() {
40 |         var subview = Screw.Interface.Example.toView({example: this});
41 |         self.buildSubview(examplesContainer, subview);
42 |       });
43 |     },
44 | 
45 |     buildChildDescriptions: function() {
46 |       var self = this;
47 |       var childDescriptionsContainer = this.find("ul.childDescriptions").eq(0);
48 |       Screw.each(this.description.childDescriptions, function() {
49 |         var subview = Screw.Interface.Description.toView({description: this, buildImmediately: self.buildImmediately});
50 |         self.buildSubview(childDescriptionsContainer, subview);
51 |       });
52 |     },
53 | 
54 |     buildSubview: function(container, subview) {
55 |       if (this.buildImmediately) {
56 |         container.append(subview);
57 |       } else {
58 |         setTimeout(function() { container.append(subview); }, 0);
59 |       }
60 |     },
61 | 
62 |     focus: function() {
63 |       Screw.Interface.setLocation(Screw.Interface.baseLocation() + "?" + JSON.stringify([this.description.path()]));
64 |     }
65 |   }
66 | });
67 | 
68 | })(Screw, Monarch);
69 | 


--------------------------------------------------------------------------------
/lib/screw_unit/js_file.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   class JsFile
 3 |     RELATIVE_REQUIRE_REGEX = /^\/\/= require\s+['"]([^'"]+)['"].*/
 4 |     GLOBAL_REQUIRE_REGEX = /^\/\/= require\s+<([^>]+)>.*/
 5 | 
 6 |     attr_reader :physical_path, :containing_dir, :asset_manager
 7 |     
 8 |     def initialize(physical_path, asset_manager)
 9 |       raise "JsFile created with nil physical_path" if physical_path.nil? 
10 | 
11 |       @physical_path, @asset_manager = physical_path, asset_manager
12 |       @containing_dir = File.dirname(physical_path)
13 |     end
14 | 
15 |     def add_dependencies_to_required_virtual_paths(required_virtual_paths)
16 |       require_declarations.each do |require_declaration|
17 |         require_declaration.js_file.add_dependencies_to_required_virtual_paths(required_virtual_paths)
18 |       end
19 |       required_virtual_paths.push(virtual_path) if !required_virtual_paths.include?(virtual_path)
20 |     end
21 | 
22 |     def require_declarations
23 |       declarations = []
24 |       File.open(physical_path, 'r') do |f|
25 |         f.readlines.each do |line|
26 |           if match = RELATIVE_REQUIRE_REGEX.match(line)
27 |             require_path = match[0]
28 |             declarations.push(RelativeRequireDeclaration.new(containing_dir, match[1], asset_manager))
29 |           end
30 |           if match = GLOBAL_REQUIRE_REGEX.match(line)
31 |             require_path = match[0]
32 |             declarations.push(GlobalRequireDeclaration.new(match[1], asset_manager))
33 |           end
34 |         end
35 |       end
36 |       declarations
37 |     end
38 | 
39 |     def virtual_path
40 |       @virtual_path ||= asset_manager.virtualize_path(physical_path)
41 |     end
42 | 
43 |     class RelativeRequireDeclaration
44 |       attr_reader :js_file
45 | 
46 |       def initialize(parent_dir, relative_path, asset_manager)
47 |         @js_file = JsFile.new(File.expand_path(File.join(parent_dir, relative_path + ".js")), asset_manager)
48 |       end
49 |     end
50 | 
51 |     class GlobalRequireDeclaration
52 |       attr_reader :js_file
53 |       def initialize(global_path, asset_manager)
54 |         physical_path = asset_manager.physicalize_path_from_js_load_path(global_path + ".js")
55 |         raise "No file '#{global_path}.js' found on load path" unless physical_path
56 |         @js_file = JsFile.new(physical_path, asset_manager)
57 |       end
58 |     end
59 |   end
60 | end
61 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/suite_completion_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   module Resources
 5 |     describe SuiteCompletion do
 6 |       attr_reader :suite_completion, :mock_request
 7 | 
 8 |       describe "#post" do
 9 |         before do
10 |           $exit_status = nil
11 |           $thin_server = Object.new
12 |           @mock_request = Object.new
13 |         end
14 | 
15 |         context "when #kill_server_on_completion? is true" do
16 |           before do
17 |             @suite_completion = SuiteCompletion.new(true)
18 |           end
19 | 
20 |           context "when the request body is 'success'" do
21 |             before do
22 |               stub(mock_request).body { StringIO.new("success") }
23 |             end
24 | 
25 |             it "sends a success response and sets the $exit_status to 0" do
26 |               status, headers, body = suite_completion.post(mock_request)
27 |               status.should == 200
28 |               headers.should == {}
29 |               body.should == "OK"
30 |               $exit_status.should == 0
31 |             end
32 |           end
33 | 
34 |           context "when the request body is anything else" do
35 |             before do
36 |               stub(suite_completion).puts
37 |               stub(mock_request).body { StringIO.new("failure") }
38 |             end
39 | 
40 |             it "sends a success response and sets the $exit_status to 1" do
41 |               status, headers, body = suite_completion.post(mock_request)
42 |               status.should == 200
43 |               headers.should == {}
44 |               body.should == "OK"
45 |               $exit_status.should == 1
46 |             end
47 |           end
48 |         end
49 | 
50 |         context "when #kill_server_on_completion? is not true" do
51 |           before do
52 |             @suite_completion = SuiteCompletion.new(false)
53 |             stub(suite_completion).puts
54 |             stub(mock_request).body { StringIO.new("anything") }
55 |           end
56 | 
57 |           it "sends a success response and does not change $exit_status" do
58 |             status, headers, body = suite_completion.post(mock_request)
59 |             status.should == 200
60 |             headers.should == {}
61 |             body.should == "OK"
62 |             $exit_status.should be_nil
63 |           end
64 |         end
65 |       end
66 |     end
67 |   end
68 | end
69 | 


--------------------------------------------------------------------------------
/lib/screw_unit/asset_manager.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   class AssetManager
 3 |     attr_reader :locations, :js_locations
 4 |     def initialize
 5 |       @locations = []
 6 |       @js_locations = []
 7 |     end
 8 | 
 9 |     def add_location(virtual_path, physical_path)
10 |       raise "Virtual and physical path must start with a '/'" unless virtual_path.starts_with?('/') && physical_path.starts_with?('/')
11 |       location = AssetLocation.new(virtual_path, physical_path)
12 |       locations.unshift(location)
13 |       location
14 |     end
15 | 
16 |     def add_js_location(virtual_path, physical_path)
17 |       location = add_location(virtual_path, physical_path)
18 |       js_locations.unshift(location)
19 |       location
20 |     end
21 | 
22 |     def virtualize_path(physical_path)
23 |       locations.each do |location|
24 |         if virtual_path = location.virtualize_path(physical_path)
25 |           return virtual_path
26 |         end
27 |       end
28 |       nil
29 |     end
30 | 
31 |     def physicalize_path(virtual_path)
32 |       locations.each do |location|
33 |         if physical_path = location.physicalize_path(virtual_path)
34 |           return physical_path
35 |         end
36 |       end
37 |       nil
38 |     end
39 | 
40 |     def glob_virtual_paths(virtual_glob_pattern)
41 |       matching_locations = locations.select {|l| l.matches_virtual_glob_pattern?(virtual_glob_pattern)}
42 |       matching_locations.map {|l| l.virtual_glob(virtual_glob_pattern)}.flatten
43 |     end
44 | 
45 |     def virtual_dependency_paths_from_load_path(relative_paths, virtual_dependency_paths = [])
46 |       physical_paths = relative_paths.map { |relative_path| physicalize_path_from_js_load_path(relative_path) }
47 |       virtual_dependency_paths_from_physical_paths(physical_paths, virtual_dependency_paths)
48 |     end
49 | 
50 |     def virtual_dependency_paths_from_physical_paths(physical_paths, virtual_dependency_paths = [])
51 |       physical_paths.each do |physical_path|
52 |         js_file = JsFile.new(physical_path, self)
53 |         raise "No js file found at path #{physical_path}" unless js_file
54 |         js_file.add_dependencies_to_required_virtual_paths(virtual_dependency_paths)
55 |       end
56 |       virtual_dependency_paths
57 |     end
58 | 
59 |     def physicalize_path_from_js_load_path(relative_path)
60 |       js_locations.each do |js_location|
61 |         if physical_path = js_location.relative_find(relative_path)
62 |           return physical_path
63 |         end
64 |       end
65 |       nil
66 |     end
67 |   end
68 | end
69 | 


--------------------------------------------------------------------------------
/lib/screw_unit/asset_location.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   class AssetLocation
 3 |     attr_reader :virtual_prefix, :physical_prefix
 4 | 
 5 |     def initialize(virtual_prefix, physical_prefix)
 6 | 
 7 |       raise "No directory exists at #{physical_prefix}" unless File.exist?(physical_prefix) && File.directory?(physical_prefix)
 8 | 
 9 |       @virtual_prefix, @physical_prefix = virtual_prefix, physical_prefix
10 |     end
11 | 
12 |     def virtualize_path(physical_path)
13 |       if matches_physical_path?(physical_path)
14 |         path_relative_to_location = physical_path.gsub(/^#{physical_prefix}/, "")
15 |         File.join(virtual_prefix, path_relative_to_location)
16 |       end
17 |     end
18 | 
19 |     def physicalize_path(virtual_path)
20 |       if matches_virtual_path?(virtual_path)
21 |         path_relative_to_location = virtual_path.gsub(/^#{virtual_prefix}/, "")
22 |         File.join(physical_prefix, path_relative_to_location)
23 |       end
24 |     end
25 | 
26 |     def matches_physical_path?(physical_path)
27 |       physical_path.path_starts_with?(physical_prefix)
28 |     end
29 | 
30 |     def matches_virtual_path?(virtual_path)
31 |       virtual_path.path_starts_with?(virtual_prefix)
32 |     end
33 | 
34 |     def matches_virtual_glob_pattern?(virtual_glob_pattern)
35 |       subsumes_virtual_glob_pattern?(virtual_glob_pattern) || is_subsumed_by_virtual_glob_pattern?(virtual_glob_pattern)
36 |     end
37 | 
38 |     def is_subsumed_by_virtual_glob_pattern?(pattern)
39 |       glob_pattern_without_wildcards = pattern.gsub(/\/\*.*/, "")
40 |       virtual_prefix.path_starts_with?(glob_pattern_without_wildcards)
41 |     end
42 | 
43 |     def subsumes_virtual_glob_pattern?(pattern)
44 |       pattern.path_starts_with?(virtual_prefix)
45 |     end
46 | 
47 |     def virtual_glob(virtual_glob_pattern)
48 |       Dir[physicalize_glob_pattern(virtual_glob_pattern)].map {|physical_path| virtualize_path(physical_path)}
49 |     end
50 | 
51 |     def physicalize_glob_pattern(virtual_glob_pattern)
52 |       if subsumes_virtual_glob_pattern?(virtual_glob_pattern)
53 |         physicalize_path(virtual_glob_pattern)
54 |       elsif is_subsumed_by_virtual_glob_pattern?(virtual_glob_pattern)
55 |         wildcard = virtual_glob_pattern.scan(/\/\*.*/).first
56 |         physical_prefix + wildcard
57 |       else
58 |         raise "Does not match glob pattern"
59 |       end
60 |     end
61 | 
62 |     def relative_find(relative_path)
63 |       physical_path = File.join(physical_prefix, relative_path)
64 |       return physical_path if File.exist?(physical_path)
65 |     end
66 |   end
67 | end
68 | 


--------------------------------------------------------------------------------
/lib/screw_unit/resources/spec_runner.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   module Resources
 3 |     class SpecRunner
 4 |       attr_reader :spec_file_resources, :asset_manager
 5 | 
 6 |       def initialize(spec_file_resources, asset_manager)
 7 |         @spec_file_resources = spec_file_resources
 8 |         @asset_manager = asset_manager
 9 |       end
10 | 
11 |       def locate(path_fragment)
12 |         if path_fragment == "streaming"
13 |           StreamingSpecRunner.new(spec_file_resources, asset_manager)
14 |         end
15 |       end
16 | 
17 |       def get
18 |         [200, {'Content-Type' => 'text/html'}, content]
19 |       end
20 | 
21 |       protected
22 |       def content
23 |         "<html>\n<head>\n" +
24 |           screw_unit_css_file_link_tag +
25 |           "\n\n" +
26 |           "<!-- ScrewUnit core scripts -->\n" +
27 |           core_file_script_tags +
28 |           "\n\n" +
29 |           "<!-- scripts required by the specs -->\n" +
30 |           required_script_tags +
31 |           "\n" +
32 |           run_specs_on_page_load +
33 |           "\n</head>\n<body>\n</body>\n</html>\n"
34 |       end
35 | 
36 |       def run_specs_on_page_load
37 |         %{<script type="text/javascript">Screw.Interface.Runner.runSpecsOnPageLoad()</script>}
38 |       end
39 | 
40 |       def screw_unit_css_file_link_tag
41 |         %{<link rel="stylesheet" type="text/css" href="/screw_unit_stylesheets/screw.css"/>}
42 |       end
43 | 
44 |       def core_file_script_tags
45 |         core_file_paths.map do |core_file_path|
46 |           script_tag(core_file_path)
47 |         end.join("\n")
48 |       end
49 | 
50 |       def spec_file_script_tags
51 |         spec_file_virtual_paths.map do |virtual_path|
52 |           script_tag(virtual_path)
53 |         end.join("\n")
54 |       end
55 | 
56 |       def spec_file_virtual_paths
57 |         spec_file_resources.map do |spec_file_resource|
58 |           spec_file_resource.virtual_path
59 |         end
60 |       end
61 | 
62 |       def spec_file_physical_paths
63 |         spec_file_resources.map do |spec_file_resource|
64 |           spec_file_resource.physical_path
65 |         end
66 |       end
67 | 
68 |       def required_script_tags
69 |         required_virtual_paths.map do |virtual_path|
70 |           script_tag(virtual_path)
71 |         end.join("\n")
72 |       end
73 | 
74 |       def required_virtual_paths
75 |         asset_manager.virtual_dependency_paths_from_physical_paths(spec_file_physical_paths)
76 |       end
77 | 
78 |       def script_tag(path)
79 |         %{<script type="text/javascript" src="#{path}"></script>}
80 |       end
81 | 
82 |       def core_file_paths
83 |         asset_manager.virtual_dependency_paths_from_load_path(["screw.js"])
84 |       end
85 |     end
86 |   end
87 | end
88 | 


--------------------------------------------------------------------------------
/client/spec/interface/progress_bar_spec.js:
--------------------------------------------------------------------------------
 1 | Screw.Unit(function(c) { with(c) {
 2 |   describe("Screw.Interface.ProgressBar", function() {
 3 |     var description1, description2, example1, example2, example3, example4, view, shouldFail;
 4 |     before(function() {
 5 |       shouldFail = false;
 6 |       description1 = new Screw.Description("description");
 7 |       example1 = new Screw.Example("example 1", function() {
 8 |         if (shouldFail) throw "flunk";
 9 |       });
10 |       example2 = new Screw.Example("example 1", function() {
11 |         if (shouldFail) throw "flunk";
12 |       });
13 |       description1.addExample(example1);
14 |       description1.addExample(example2);
15 | 
16 |       description2 = new Screw.Description("description");
17 |       example3 = new Screw.Example("example 3", function() {
18 |         if (shouldFail) throw "flunk";
19 |       });
20 |       example4 = new Screw.Example("example 4", function() {
21 |         if (shouldFail) throw "flunk";
22 |       });
23 |       description2.addExample(example3);
24 |       description2.addExample(example4);
25 | 
26 |       root = new Screw.Description('root');
27 |       root.addDescription(description1);
28 |       root.addDescription(description2);
29 | 
30 |       view = Screw.Interface.ProgressBar.toView({root: root});
31 |     });
32 | 
33 |     describe("when an example within the given root is completed", function() {
34 |       it("updates the width of the progress bar to the proportion of completed examples and updates the 'n of m completed' text", function() {
35 |         expect(view.find('div#screwUnitProgress').css('width')).to(equal, '0%');
36 |         expect(view.html()).to(match, "0 of 4");
37 |         example1.run();
38 |         expect(view.find('div#screwUnitProgress').css('width')).to(equal, '25%');
39 |         expect(view.html()).to(match, "1 of 4");
40 |         example2.run();
41 |         expect(view.find('div#screwUnitProgress').css('width')).to(equal, '50%');
42 |         expect(view.html()).to(match, "2 of 4");
43 |       });
44 |     });
45 | 
46 |     describe("when an example within the given root fails", function() {
47 |       before(function() {
48 |         shouldFail = true;
49 |       });
50 | 
51 |       it("adds the 'failed' class to its content", function() {
52 |         expect(view.hasClass('failed')).to(beFalse);
53 |         example1.run();
54 |         expect(view.hasClass('failed')).to(beTrue);
55 |       });
56 | 
57 |       it("updates the 'n failed' text to the number of failing examples", function() {
58 |         expect(view.html()).to(match, "0 failed");
59 |         example1.run();
60 |         expect(view.html()).to(match, "1 failed");
61 |         example2.run();
62 |         expect(view.html()).to(match, "2 failed");
63 |       });
64 |     });
65 |   });
66 | }});
67 | 


--------------------------------------------------------------------------------
/lib/screw_unit/configuration.rb:
--------------------------------------------------------------------------------
 1 | module ScrewUnit
 2 |   def self.configure(&block)
 3 |     Configuration.instance.instance_eval(&block)
 4 |   end
 5 | 
 6 |   class Configuration
 7 |     DEFAULT_SELENIUM_HOST = "localhost"
 8 |     DEFAULT_SELENIUM_PORT = 4444
 9 |     DEFAULT_SELENIUM_BROWSER_STRING = "*firefox"
10 |     DEFAULT_SELENIUM_SCREW_SERVER_URL = "http://localhost"
11 |     DEFAULT_SELENIUM_SPECS_PATH = "/specs"
12 | 
13 |     class << self
14 |       def instance
15 |         @instance ||= new
16 |       end
17 | 
18 |       def method_missing(method, *args, &block)
19 |         instance.send(method, *args, &block)
20 |       end
21 |     end
22 | 
23 |     attr_reader :path_containing_screwrc, :asset_manager, :resource_locators
24 | 
25 |     def initialize
26 |       @asset_manager = AssetManager.new
27 |       @resource_locators = []
28 |       asset_manager.add_js_location("/screw_unit_core", "#{SCREW_UNIT_ROOT}/client/lib")
29 |       asset_manager.add_js_location("/screw_unit_vendor", "#{SCREW_UNIT_ROOT}/client/vendor")
30 |       asset_manager.add_js_location("/screw_unit_stylesheets", "#{SCREW_UNIT_ROOT}/client/stylesheets")
31 |     end
32 | 
33 |     def load_screwrc(path_containing_screwrc)
34 |       @path_containing_screwrc = path_containing_screwrc
35 |       load("#{path_containing_screwrc}/.screwrc")
36 |     end
37 |     
38 |     def port(port=nil)
39 |       @port = port if port
40 |       @port || 8080
41 |     end
42 | 
43 |     def add_js_location(virtual_path, relative_path)
44 |       asset_manager.add_js_location(virtual_path, absolutize_path(relative_path))
45 |     end
46 | 
47 |     def add_location(virtual_path, relative_path)
48 |       asset_manager.add_location(virtual_path, absolutize_path(relative_path))
49 |     end
50 | 
51 |     def add_resource_locator(locator)
52 |       resource_locators.unshift(locator)
53 |     end
54 | 
55 |     def absolutize_path(relative_path)
56 |       File.expand_path(File.join(path_containing_screwrc, relative_path))
57 |     end
58 | 
59 |     def selenium_mode
60 |       @selenium_mode = true
61 |     end
62 | 
63 |     def selenium_mode?
64 |       !@selenium_mode.nil?
65 |     end
66 | 
67 |     def selenium_host
68 |       ENV['SELENIUM_HOST'] || DEFAULT_SELENIUM_HOST
69 |     end
70 | 
71 |     def selenium_port
72 |       ENV['SELENIUM_PORT'] || DEFAULT_SELENIUM_PORT
73 |     end
74 | 
75 |     def selenium_browser_string
76 |       ENV['SELENIUM_BROWSER_STRING'] || DEFAULT_SELENIUM_BROWSER_STRING
77 |     end
78 | 
79 |     def selenium_screw_server_url
80 |       ENV['SELENIUM_SCREW_SERVER_URL'] || DEFAULT_SELENIUM_SCREW_SERVER_URL
81 |     end
82 | 
83 |     def selenium_screw_server_port
84 |       ENV['SELENIUM_SCREW_SERVER_PORT'] || port
85 |     end
86 | 
87 |     def selenium_specs_path
88 |       ENV['SELENIUM_SPECS_PATH'] || DEFAULT_SELENIUM_SPECS_PATH
89 |     end
90 |   end
91 | end
92 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/dir_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   module Resources
 5 |     describe Dir do
 6 |       attr_reader :dir, :asset_manager
 7 | 
 8 |       before do
 9 |         spec_file_dir = ::File.expand_path(::File.dirname(__FILE__))
10 |         @asset_manager = Configuration.new.asset_manager
11 |       end
12 | 
13 |       describe "#locate" do
14 |         before do
15 |           asset_manager.add_location("/x", "#{::File.expand_path(::File.dirname(__FILE__))}/file_system_fixtures")
16 |           @dir = Dir.new("/x", asset_manager)
17 |         end
18 | 
19 |         context "when the string names a file in the directory" do
20 |           it "returns a File resource with the appropriate virtual path and the same AssetManager" do
21 |             file = dir.locate("foo.js")
22 |             file.class.should == Resources::File
23 |             file.virtual_path.should == "/x/foo.js"
24 |             file.asset_manager.should == asset_manager
25 |           end
26 |         end
27 | 
28 |         context "when the string names a subdirectory in the directory" do
29 |           it "returns a Dir resource with the appropriate absolute path and the same AssetManeger" do
30 |             subdir = dir.locate("specs")
31 |             subdir.class.should == Resources::Dir
32 |             subdir.virtual_path.should == "/x/specs"
33 |             subdir.asset_manager.should == asset_manager
34 |           end
35 |         end
36 | 
37 |         context "when the string names a file that doesn't exist" do
38 |           it "returns a FileNotFound resource with the relative path" do
39 |             not_found = dir.locate("bogus")
40 |             not_found.class.should == FileNotFound
41 |             not_found.virtual_path.should == "/x/bogus"
42 | 
43 |             not_found = Dir.new("/", asset_manager).locate("bogus")
44 |             not_found.class.should == FileNotFound
45 |             not_found.virtual_path.should == "/bogus"
46 |           end
47 |         end
48 |       end
49 | 
50 |       describe "#glob" do
51 |         before do
52 |           @dir = Dir.new("/foo", asset_manager)
53 |           absolute_dir = ::File.expand_path(::File.dirname(__FILE__))
54 |           asset_manager.add_location("/foo/bar", "#{absolute_dir}/file_system_fixtures/code_under_test")
55 |           asset_manager.add_location("/foo/baz", "#{absolute_dir}/file_system_fixtures/specs")
56 |         end
57 | 
58 |         it "returns File resources with the correct relative paths for all files matching the pattern" do
59 |           globbed_file_resources = dir.glob("/**/*.js")
60 |           globbed_file_resources.map {|fr| fr.virtual_path}.should == ["/foo/baz/foo_spec.js", "/foo/baz/subsuite/bar_spec.js", "/foo/bar/code_under_test.js"]
61 |           globbed_file_resources.each do |fr|
62 |             fr.asset_manager.should == asset_manager
63 |           end
64 |         end
65 |       end
66 |     end
67 |   end
68 | end
69 | 


--------------------------------------------------------------------------------
/spec/screw_unit/resources/file_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   module Resources
 5 |     describe File do
 6 |       attr_reader :dir, :file, :asset_manager
 7 | 
 8 |       before do
 9 |         @dir = ::File.expand_path(::File.dirname(__FILE__))
10 |         @asset_manager = Configuration.new.asset_manager
11 |         asset_manager.add_js_location("/", "#{dir}/file_system_fixtures")
12 |         @file = File.new(virtual_path, asset_manager)
13 |       end
14 | 
15 |       def virtual_path
16 |         "/foo.js"
17 |       end
18 | 
19 |       def physical_path
20 |         asset_manager.physicalize_path(virtual_path)
21 |       end
22 | 
23 |       describe "#get" do
24 |         attr_reader :response_code, :headers, :body
25 | 
26 |         before do
27 |           ::File.exist?(physical_path).should be_true
28 |           @response_code, @headers, @body = file.get
29 |         end
30 | 
31 |         it "returns 200 as the response code" do
32 |           response_code.should == 200
33 |         end
34 | 
35 |         it "returs the file's mtime as the 'Last-Modified' header" do
36 |           headers['Last-Modified'].should == ::File.mtime(physical_path).httpdate
37 |         end
38 | 
39 |         it "returns the contents of the file as the response body" do
40 |           response_body = ""
41 |           body.each { |chunk| response_body.concat(chunk) }
42 |           response_body.should == ::File.read(physical_path)
43 |         end
44 | 
45 |         context "when the file has a .js extension" do
46 |           before do
47 |             virtual_path.should =~ /\.js$/
48 |           end
49 | 
50 |           it "has a Content-Type header of 'application/javascript'" do
51 |             headers['Content-Type'].should == "application/javascript"
52 |           end
53 |         end
54 | 
55 |         context "when the file has a .css extension" do
56 |           def virtual_path
57 |             "/foo.css"
58 |           end
59 | 
60 |           it "has a Content-Type header of 'text/css'" do
61 |             headers['Content-Type'].should == "text/css"
62 |           end
63 |         end
64 | 
65 |         context "when the file has a .png extension" do
66 |           def virtual_path
67 |             "/foo.png"
68 |           end
69 | 
70 |           it "has a Content-Type header of 'text/png'" do
71 |             headers['Content-Type'].should == "image/png"
72 |           end
73 |         end
74 | 
75 |         context "when the file has a .jpg extension" do
76 |           def virtual_path
77 |             "/foo.jpg"
78 |           end
79 | 
80 |           it "has a Content-Type header of 'image/jpeg'" do
81 |             headers['Content-Type'].should == "image/jpeg"
82 |           end
83 |         end
84 | 
85 |         context "when the file has a .jpeg extension" do
86 |           def virtual_path
87 |             "/foo.jpeg"
88 |           end
89 | 
90 |           it "has a Content-Type header of 'image/jpeg'" do
91 |             headers['Content-Type'].should == "image/jpeg"
92 |           end
93 |         end
94 |       end
95 |     end
96 |   end
97 | end
98 | 


--------------------------------------------------------------------------------
/client/vendor/jquery.print.js:
--------------------------------------------------------------------------------
  1 | (function($) {
  2 | 
  3 |   function printArray(obj, opts) {
  4 |     var result = [];
  5 |     for (var i = 0; i < Math.min(opts.maxArray, obj.length); i++)
  6 |       result.push($.print(obj[i], $.extend({}, opts, { maxArray: 3, maxString: 40 })));
  7 | 
  8 |     if (obj.length > opts.maxArray)
  9 |       result.push((obj.length - opts.maxArray) + ' more...');
 10 |     if (result.length == 0) return "[]"
 11 |       return "[ " + result.join(", ") + " ]";
 12 |   }
 13 | 
 14 |   function printElement(obj) {
 15 |     if (obj.nodeType == 1) {
 16 |       var result = [];
 17 |       var properties = [ 'className', 'id' ];
 18 |       var extra = {
 19 |         'input': ['type', 'name', 'value'],
 20 |         'a': ['href', 'target'],
 21 |         'form': ['method', 'action'],
 22 |         'script': ['src'],
 23 |         'link': ['href'],
 24 |         'img': ['src']
 25 |       };
 26 | 
 27 |       $.each(properties.concat(extra[obj.tagName.toLowerCase()] || []), function(){
 28 |         if (obj[this])
 29 |           result.push(' ' + this.replace('className', 'class') + "=" + $.print(obj[this]))
 30 |       });
 31 |       return "<" + obj.tagName.toLowerCase()
 32 |               + result.join('') + ">";
 33 |     }
 34 |   }
 35 | 
 36 |   function printObject(obj, opts) {
 37 |     var seen = opts.seen || [ obj ];
 38 | 
 39 |     var result = [], key, value;
 40 |     for (var k in obj) {
 41 |       if (obj.hasOwnProperty(k) && $.inArray(obj[k], seen) < 0) {
 42 |         seen.push(obj[k]);
 43 |         value = $.print(obj[k], $.extend({}, opts, { maxArray: 6, maxString: 40, seen: seen }));
 44 |       } else
 45 |         value = "...";
 46 |       result.push(k + ": " + value);
 47 |     }
 48 |     if (result.length == 0) return "{}";
 49 |     return "{ " + result.join(", ") + " }";
 50 |   }
 51 | 
 52 |   function printString(value, opts) {
 53 |     var characterSubstitutions = {
 54 |       '\b': '\\b',
 55 |       '\t': '\\t',
 56 |       '\n': '\\n',
 57 |       '\f': '\\f',
 58 |       '\r': '\\r',
 59 |       '"' : '\\"',
 60 |       '\\': '\\\\'
 61 |     };
 62 |     var r = /["\\\x00-\x1f\x7f-\x9f]/g;
 63 |     
 64 |     var str = r.test(value)
 65 |       ? '"' + value.replace(r, function (a) {
 66 |           var c = characterSubstitutions[a];
 67 |           if (c) return c;
 68 |           c = a.charCodeAt();
 69 |           return '\\u00' + Math.floor(c / 16).toString(16) + (c % 16).toString(16);
 70 |         }) + '"'
 71 |       : '"' + value + '"';
 72 |     if (str.length > opts.maxString)
 73 |       return str.slice(0, opts.maxString + 1) + '..."';
 74 |     else
 75 |       return str;
 76 |   }
 77 | 
 78 |   $.print = function(obj, options) {
 79 |     var opts = $.extend({}, { maxArray: 10, maxString: 100 }, options);
 80 | 
 81 |     if (obj && obj.inspect && typeof obj.inspect == "function") obj = obj.inspect();
 82 | 
 83 |     if (typeof obj == 'undefined')
 84 |       return "undefined";
 85 |     else if (typeof obj == 'boolean')
 86 |       return obj.toString();
 87 |     else if (typeof obj == 'number')
 88 |       return obj.toString();
 89 |     else if (!obj)
 90 |       return "null";
 91 |     else if (typeof obj == 'string')
 92 |       return printString(obj, opts);
 93 |     else if (obj instanceof RegExp)
 94 |       return obj.toString();
 95 |     else if (obj instanceof Array || obj.callee || obj.item)
 96 |       return printArray(obj, opts);
 97 |     else if (typeof obj == 'function' || obj instanceof Function)
 98 |       return obj.toString().match(/^([^)]*\))/)[1];
 99 |     else if (obj.nodeType)
100 |       return printElement(obj);
101 |     else if (obj instanceof Error)
102 |       return printObject(obj, $.extend({}, options, { maxString: 200 }));
103 |     else if (obj instanceof Object)
104 |       return printObject(obj, opts);
105 |     else
106 |       return obj.toString().replace(/\n\s*/g, '');
107 |   }
108 | 
109 | })(jQuery);


--------------------------------------------------------------------------------
/client/spec/interface/example_spec.js:
--------------------------------------------------------------------------------
  1 | Screw.Unit(function(c) { with(c) {
  2 |   describe("Screw.Interface.Example", function() {
  3 |     var example, description, view, failureMessage, shouldFail;
  4 |     before(function() {
  5 |       failureMessage = "sharon ly says die!";
  6 |       example = new Screw.Example("passes or fails", function() {
  7 |         if (shouldFail) throw(new Error(failureMessage));
  8 |       });
  9 | 
 10 |       description = new Screw.Description("parent description");
 11 |       description.addExample(example);
 12 |       view = Screw.Interface.Example.toView({example: example, buildImmediately: true});
 13 |     });
 14 | 
 15 |     describe("#content", function() {
 16 |       it("renders the associated Example's #name", function() {
 17 |         expect(view.html()).to(match, example.name);
 18 |       });
 19 |     });
 20 | 
 21 |     describe("#focus", function() {
 22 |       it("sets window.location to match the path of the view's Example", function() {
 23 |         mock(Screw.Interface, 'getLocation', function() {
 24 |           return { href: "http://localhost:8080/specs?[[0]]"};
 25 |         });
 26 | 
 27 |         mock(Screw.Interface, 'setLocation');
 28 |         view.focus();
 29 |         expect(Screw.Interface.setLocation).to(haveBeenCalled, withArgs("http://localhost:8080/specs?" + JSON.stringify([example.path()])));
 30 |       });
 31 |     });
 32 | 
 33 |     describe("when span.name is clicked", function() {
 34 |       it("calls #focus on the view", function() {
 35 |         mock(view, 'focus');
 36 |         view.find('span.name').click();
 37 |         expect(view.focus).to(haveBeenCalled);
 38 |       });
 39 |     });
 40 | 
 41 |     describe("when its associated Example fails", function() {
 42 |       before(function() {
 43 |         shouldFail = true;
 44 |       });
 45 | 
 46 |       it("applies the 'failed' class to its content", function() {
 47 |         expect(view.hasClass('failed')).to(beFalse);
 48 |         example.run();
 49 |         expect(view.hasClass('failed')).to(beTrue);
 50 |       });
 51 | 
 52 |       it("appends the failure message", function() {
 53 |         example.run();
 54 |         expect(view.html()).to(match, failureMessage);
 55 |       });
 56 | 
 57 |       it("appends the stacktrace", function() {
 58 |         var stack;
 59 |         example.onFail(function(e) {
 60 |           stack = e.stack;
 61 |         })
 62 |         example.run();
 63 |         var stackWithoutLinks = view.html().replace(/<a[^>]+>/g, "").replace(/<\/a>/g, "");
 64 |         expect(stackWithoutLinks).to(match, stack);
 65 |       });
 66 | 
 67 |       it("includes links to spec files within the stack trace", function() {
 68 |         var stack;
 69 |         example.onFail(function(e) {
 70 |           stack = e.stack;
 71 |         });
 72 |         example.run();
 73 | 
 74 |         var matches = stack.match(/(http:\/\/.*_spec).js/);
 75 | 				console.debug(matches);
 76 | 				console.debug(view.html());
 77 | 				
 78 |         expect(matches.length).to(beGt, 1);
 79 |         expect(view.find("a[href="+matches[1]+"]")).toNot(beEmpty);
 80 |       });
 81 |     });
 82 | 
 83 |     describe("when its associated Example passes", function() {
 84 |       before(function() {
 85 |         shouldFail = false;
 86 |       });
 87 | 
 88 |       it("applies the 'passed' class to its content", function() {
 89 |         expect(view.hasClass('passed')).to(beFalse);
 90 |         example.run();
 91 |         expect(view.hasClass('passed')).to(beTrue);
 92 |       });
 93 |     });
 94 | 
 95 |     describe("#focus", function() {
 96 |       var originalScrewOptions;
 97 |       before(function() {
 98 |         originalScrewOptions = Screw.Interface.options;
 99 |         Screw.Interface.options = {};
100 |       });
101 | 
102 |       after(function() {
103 |         Screw.Interface.options = originalScrewOptions;
104 |       });
105 |     });
106 |   });
107 | }});
108 | 


--------------------------------------------------------------------------------
/client/lib/screw/interface/streaming_runner.js:
--------------------------------------------------------------------------------
  1 | (function(Screw, Monarch, jQuery) {
  2 |   Monarch.constructor("Screw.Interface.StreamingRunner", Monarch.View.Template, {
  3 |     constructorProperties: {
  4 |       runSpecsOnPageLoad: function(params) {
  5 |         jQuery(function() {
  6 |           jQuery('body').html(Screw.Interface.StreamingRunner.toView(params));
  7 |         });
  8 |       }
  9 |     },
 10 | 
 11 |     content: function() { with(this.builder) {
 12 |       div(function() {
 13 |         div(function() {
 14 |           span("Total Examples: ");
 15 |           span("0").ref('numCompletedExamplesSpan');
 16 |         });
 17 |         
 18 |         div(function() {
 19 |           span("Failed Examples: ");
 20 |           span("0").ref('numFailedExamplesSpan');
 21 |         });
 22 | 
 23 |         div(function() {
 24 |           span("Files: ")
 25 |           span("0").ref('numCompletedFilesSpan');
 26 |           span(" / ");
 27 |           span().ref('totalFilesSpan');
 28 |         });
 29 | 
 30 |         div(function() {
 31 |           span("Current File Path: ");
 32 |           span().ref('currentFileSpan');
 33 |         })
 34 | 
 35 |         div(function() {
 36 |           span("Examples In Current File: ")
 37 |           span("0").ref('completedExamplesInCurrentFileSpan');
 38 |           span(" / ")
 39 |           span().ref('totalExamplesInCurrentFileSpan');
 40 |         });
 41 | 
 42 |         ul(function() {
 43 | 
 44 |         }).ref("failuresList");
 45 | 
 46 |         div({id: "testContent"});
 47 |       });
 48 |     }},
 49 | 
 50 |     viewProperties: {
 51 |       initialize: function() {
 52 |         this.numCompletedExamples = 0;
 53 |         this.numFailedExamples = 0;
 54 |         this.numCompletedFiles = 0;
 55 |         this.totalFilesSpan.html(this.specPaths.length);
 56 | 
 57 |         var self = this;
 58 |         Screw.rootDescription().onExampleCompleted(function(example) {
 59 |           self.numCompletedExamples++;
 60 |           self.numCompletedExamplesSpan.html(self.numCompletedExamples);
 61 |           self.numCompletedExamplesInCurrentFile++;
 62 |           self.completedExamplesInCurrentFileSpan.html(self.numCompletedExamplesInCurrentFile);
 63 |           if (!example.passed) self.handleFailedExample(example);
 64 |           if (self.numCompletedExamplesInCurrentFile == self.numExamplesInCurrentFile) self.examplesCompletedForCurrentSpecFile();
 65 |         });
 66 | 
 67 |         this.loadNextSpecPath();
 68 |       },
 69 | 
 70 |       loadNextSpecPath: function() {
 71 |         if (this.specPaths.length == 0) return;
 72 |         var self = this;
 73 |         var path = this.specPaths.shift();
 74 |         this.currentFileSpan.html(path);
 75 | 
 76 |         setTimeout(function() {
 77 |           var scriptTag = document.createElement('script');
 78 |           scriptTag.type = 'text/javascript';
 79 |           scriptTag.src = path;
 80 |           scriptTag.onload = function() {
 81 |             self.runExamplesForCurrentSpecFile()
 82 |           };
 83 |           jQuery('head')[0].appendChild(scriptTag);
 84 |         }, 1);
 85 |       },
 86 | 
 87 |       runExamplesForCurrentSpecFile: function() {
 88 |         this.numExamplesInCurrentFile = Screw.rootDescription().totalExamples();
 89 |         this.numCompletedExamplesInCurrentFile = 0;
 90 |         this.completedExamplesInCurrentFileSpan.html("0");
 91 |         this.totalExamplesInCurrentFileSpan.html(this.numExamplesInCurrentFile);
 92 | 
 93 |         if (this.numExamplesInCurrentFile > 0) {
 94 |           Screw.rootDescription().run()
 95 |         } else {
 96 |           this.examplesCompletedForCurrentSpecFile();
 97 |         }
 98 |       },
 99 | 
100 |       handleFailedExample: function(example) {
101 |         this.numFailedExamples++;
102 |         this.numFailedExamplesSpan.html(this.numFailedExamples);
103 |         this.failuresList.appendView(function(b) {
104 |           b.li(function() {
105 |             b.div(example.fullName());
106 |             b.div(example.failureMessage);
107 |             b.pre(example.stack);
108 |           });
109 |         });
110 |       },
111 | 
112 |       examplesCompletedForCurrentSpecFile: function() {
113 |         Screw.clear();
114 |         this.numCompletedFiles++;
115 |         this.numCompletedFilesSpan.html(this.numCompletedFiles);
116 |         this.loadNextSpecPath();
117 |       }
118 |     }
119 |   });
120 | })(Screw, Monarch, jQuery);
121 | 


--------------------------------------------------------------------------------
/client/vendor/jquery.cookie.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Cookie plugin
 3 |  *
 4 |  * Copyright (c) 2006 Klaus Hartl (stilbuero.de)
 5 |  * Dual licensed under the MIT and GPL licenses:
 6 |  * http://www.opensource.org/licenses/mit-license.php
 7 |  * http://www.gnu.org/licenses/gpl.html
 8 |  *
 9 |  */
10 | 
11 | /**
12 |  * Create a cookie with the given name and value and other optional parameters.
13 |  *
14 |  * @example $.cookie('the_cookie', 'the_value');
15 |  * @desc Set the value of a cookie.
16 |  * @example $.cookie('the_cookie', 'the_value', { expires: 7, path: '/', domain: 'jquery.com', secure: true });
17 |  * @desc Create a cookie with all available options.
18 |  * @example $.cookie('the_cookie', 'the_value');
19 |  * @desc Create a session cookie.
20 |  * @example $.cookie('the_cookie', null);
21 |  * @desc Delete a cookie by passing null as value. Keep in mind that you have to use the same path and domain
22 |  *       used when the cookie was set.
23 |  *
24 |  * @param String name The name of the cookie.
25 |  * @param String value The value of the cookie.
26 |  * @param Object options An object literal containing key/value pairs to provide optional cookie attributes.
27 |  * @option Number|Date expires Either an integer specifying the expiration date from now on in days or a Date object.
28 |  *                             If a negative value is specified (e.g. a date in the past), the cookie will be deleted.
29 |  *                             If set to null or omitted, the cookie will be a session cookie and will not be retained
30 |  *                             when the the browser exits.
31 |  * @option String path The value of the path atribute of the cookie (default: path of page that created the cookie).
32 |  * @option String domain The value of the domain attribute of the cookie (default: domain of page that created the cookie).
33 |  * @option Boolean secure If true, the secure attribute of the cookie will be set and the cookie transmission will
34 |  *                        require a secure protocol (like HTTPS).
35 |  * @type undefined
36 |  *
37 |  * @name $.cookie
38 |  * @cat Plugins/Cookie
39 |  * @author Klaus Hartl/klaus.hartl@stilbuero.de
40 |  */
41 | 
42 | /**
43 |  * Get the value of a cookie with the given name.
44 |  *
45 |  * @example $.cookie('the_cookie');
46 |  * @desc Get the value of a cookie.
47 |  *
48 |  * @param String name The name of the cookie.
49 |  * @return The value of the cookie.
50 |  * @type String
51 |  *
52 |  * @name $.cookie
53 |  * @cat Plugins/Cookie
54 |  * @author Klaus Hartl/klaus.hartl@stilbuero.de
55 |  */
56 | (function(jQuery) {
57 | jQuery.cookie = function(name, value, options) {
58 |     if (typeof value != 'undefined') { // name and value given, set cookie
59 |         options = options || {};
60 |         if (value === null) {
61 |             value = '';
62 |             options.expires = -1;
63 |         }
64 |         var expires = '';
65 |         if (options.expires && (typeof options.expires == 'number' || options.expires.toUTCString)) {
66 |             var date;
67 |             if (typeof options.expires == 'number') {
68 |                 date = new Date();
69 |                 date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000));
70 |             } else {
71 |                 date = options.expires;
72 |             }
73 |             expires = '; expires=' + date.toUTCString(); // use expires attribute, max-age is not supported by IE
74 |         }
75 |         // CAUTION: Needed to parenthesize options.path and options.domain
76 |         // in the following expressions, otherwise they evaluate to undefined
77 |         // in the packed version for some reason...
78 |         var path = options.path ? '; path=' + (options.path) : '';
79 |         var domain = options.domain ? '; domain=' + (options.domain) : '';
80 |         var secure = options.secure ? '; secure' : '';
81 |         document.cookie = [name, '=', encodeURIComponent(value), expires, path, domain, secure].join('');
82 |     } else { // only name given, get cookie
83 |         var cookieValue = null;
84 |         if (document.cookie && document.cookie != '') {
85 |             var cookies = document.cookie.split(';');
86 |             for (var i = 0; i < cookies.length; i++) {
87 |                 var cookie = jQuery.trim(cookies[i]);
88 |                 // Does this cookie string begin with the name we want?
89 |                 if (cookie.substring(0, name.length + 1) == (name + '=')) {
90 |                     cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
91 |                     break;
92 |                 }
93 |             }
94 |         }
95 |         return cookieValue;
96 |     }
97 | };
98 | })(jQuery);
99 | 


--------------------------------------------------------------------------------
/client/lib/screw/keywords.js:
--------------------------------------------------------------------------------
  1 | (function(Screw, Monarch) {
  2 | 
  3 | Monarch.module("Screw.Keywords", {
  4 |   describe: function(name, fn) {
  5 |     Screw.pushDescription(new Screw.Description(name));
  6 |     fn();
  7 |     Screw.popDescription();
  8 |   },
  9 | 
 10 |   context: function(name, fn) {
 11 |     this.describe(name, fn);
 12 |   },
 13 | 
 14 |   scenario: function(name, fn) {
 15 |     Screw.pushScenario(new Screw.Description(name));
 16 |     fn();
 17 |     Screw.popScenario();
 18 |   },
 19 | 
 20 |   it: function(name, fn) {
 21 |     Screw.currentDescription().addExample(new Screw.Example(name, fn));
 22 |   },
 23 | 
 24 |   specify: function(name, fn) {
 25 |     this.it(name, fn);
 26 |   },
 27 | 
 28 |   they: function(name, fn) {
 29 |     this.it(name, fn);
 30 |   },
 31 | 
 32 |   before: function(fn) {
 33 |     Screw.currentDescription().addBefore(fn);
 34 |   },
 35 | 
 36 |   init: function(fn) {
 37 |     Screw.currentDescription().addInit(fn);
 38 |   },
 39 | 
 40 |   after: function(fn) {
 41 |     Screw.currentDescription().addAfter(fn);
 42 |   },
 43 | 
 44 |   expect: function(actual) {
 45 |     var funcname = function(f) {
 46 |       var s = f.toString().match(/function (\w*)/)[1];
 47 |       if ((s == null) || (s.length == 0)) return "anonymous";
 48 |       return s;
 49 |     };
 50 | 
 51 |     var stacktrace = function() {
 52 |       var s = "";
 53 |       for(var a = arguments.caller; a != null; a = a.caller) {
 54 |         s += funcname(a.callee) + "\n";
 55 |         if (a.caller == a) break;
 56 |       }
 57 |       return s;
 58 |     };
 59 | 
 60 |     return {
 61 |       to: function(matcher, expected, not) {
 62 |         var matched = matcher.match(expected, actual);
 63 |         if (not ? matched : !matched) {
 64 |           if (Screw.debugOnFail) debugger;
 65 |           throw(new Error(matcher.failureMessage(expected, actual, not)));
 66 |         }
 67 |       },
 68 | 
 69 |       toNot: function(matcher, expected) {
 70 |         this.to(matcher, expected, true);
 71 |       }
 72 |     }
 73 |   },
 74 | 
 75 |   mock: function(object, methodName, standInFunctionOrProxyFlag) {
 76 |     if (!object[methodName]) {
 77 |       throw new Error("in mockFunction: " + methodName + " is not a function that can be mocked");
 78 |     }
 79 | 
 80 |     var standInFunction = null;
 81 |     if (standInFunctionOrProxyFlag === 'proxy') {
 82 |       standInFunction = function() {
 83 |         return Screw.Keywords.original(arguments);
 84 |       }
 85 |     } else {
 86 |       standInFunction = standInFunctionOrProxyFlag;
 87 |     }
 88 | 
 89 | 
 90 |     var mockFunction = this.mockFunction(standInFunction);
 91 |     mockFunction.mockedObject = object;
 92 |     mockFunction.functionName = methodName;
 93 |     mockFunction.originalFunction = object[methodName];
 94 |     mockFunction.boundOriginalFunction = function() {
 95 |       return mockFunction.originalFunction.apply(object, arguments);
 96 |     };
 97 | 
 98 |     Screw.mocks.push(mockFunction);
 99 |     object[methodName] = mockFunction;
100 | 
101 |     return object;
102 |   },
103 | 
104 |   mockProxy: function(object, methodName) {
105 |     return Screw.Keywords.mock(object, methodName, 'proxy');
106 |   },
107 | 
108 |   mockFunction: function() {
109 |     var fnToCall, functionName;
110 | 
111 |     if (arguments.length == 2) {
112 |       functionName = arguments[0];
113 |       fnToCall = arguments[1];
114 |     } else if (arguments.length == 1) {
115 |       if (typeof arguments[0] == "function") {
116 |         fnToCall = arguments[0];
117 |       } else {
118 |         functionName = arguments[0];
119 |       }
120 |     }
121 | 
122 |     functionName = functionName || "mock function";
123 | 
124 |     var mockFunction = function() {
125 |       var argsArray = Array.prototype.slice.call(arguments)
126 |       mockFunction.callCount += 1;
127 |       mockFunction.thisValues.push(this);
128 |       mockFunction.mostRecentThisValue =  this;
129 |       mockFunction.callArgs.push(argsArray);
130 |       mockFunction.mostRecentArgs = argsArray;
131 | 
132 |       if (fnToCall) {
133 |         return fnToCall.apply(this, argsArray);
134 |       }
135 |     };
136 | 
137 |     mockFunction.functionName = functionName;
138 |     mockFunction.clear = function() {
139 |       this.callCount = 0;
140 |       this.callArgs = [];
141 |       this.thisValues = [];
142 |       this.mostRecentArgs = null;
143 |       this.mostRecentThisValue = null;
144 |     }
145 |     mockFunction.clear();
146 |     return mockFunction;
147 |   },
148 | 
149 |   original: function() {
150 |     var mockFunction = arguments.callee.caller.caller; 
151 |     return mockFunction.boundOriginalFunction.apply(null, mockFunction.arguments);
152 |   }
153 | });
154 | 
155 | })(Screw, Monarch);
156 | 


--------------------------------------------------------------------------------
/spec/screw_unit/asset_manager_spec.rb:
--------------------------------------------------------------------------------
 1 | require "#{File.dirname(__FILE__)}/../screw_unit_spec_helper"
 2 | 
 3 | module ScrewUnit
 4 |   describe AssetManager do
 5 |     attr_reader :manager, :dir
 6 | 
 7 |     before do
 8 |       @dir = File.expand_path(File.dirname(__FILE__))
 9 |       @manager = AssetManager.new
10 |       manager.add_js_location("/specs/1", "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_1")
11 |       manager.add_js_location("/specs/2", "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_2")
12 |       manager.add_js_location("/implementations", "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_3")
13 |       manager.add_location("/css", "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_4")
14 |     end
15 | 
16 |     describe "#virtualize_path" do
17 |       it "converts a physical path to a virtual path based on the declared locations" do
18 |         manager.virtualize_path("#{dir}/file_system_fixtures_for_asset_manager_specs/dir_1/1.js").should == "/specs/1/1.js"
19 |         manager.virtualize_path("#{dir}/file_system_fixtures_for_asset_manager_specs/dir_2/2.js").should == "/specs/2/2.js"
20 |         manager.virtualize_path("#{dir}/file_system_fixtures_for_asset_manager_specs/dir_3/3.js").should == "/implementations/3.js"
21 |         manager.virtualize_path("/crap").should be_nil
22 |       end
23 | 
24 |       it "corrently handles handles a virtual path of '/'" do
25 |         manager.add_location('/', "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_4")
26 |         manager.virtualize_path("#{dir}/file_system_fixtures_for_asset_manager_specs/dir_4/1.css").should == "/1.css"
27 |       end
28 | 
29 |       it "is not confused by multiple physical paths with the same partial prefix" do
30 |         manager.add_location("/specs/b", "#{dir}/file_system_fixtures_for_asset_manager_specs/dir")
31 |         manager.virtualize_path("#{dir}/file_system_fixtures_for_asset_manager_specs/dir_1/1.js").should == "/specs/1/1.js"
32 |       end
33 |     end
34 | 
35 |     describe "#physicalize_path" do
36 |       it "converts a virtual path to a physical path based on the declared locations" do
37 |         manager.physicalize_path("/specs/1/1.js").should == "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_1/1.js"
38 |         manager.physicalize_path("/specs/2/2.js").should == "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_2/2.js"
39 |         manager.physicalize_path("/implementations/3.js").should == "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_3/3.js"
40 |       end
41 | 
42 |       it "corrently handles handles a virtual path of '/'" do
43 |         manager.add_location('/', "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_4")
44 |         manager.physicalize_path('/1.css').should == "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_4/1.css"
45 |       end
46 | 
47 |       it "is not confused by multiple virtual paths with the same partial prefix" do
48 |         manager.add_location("/foo_prime", "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_1")
49 |         manager.add_location("/foo", "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_2")
50 |         manager.physicalize_path("/foo_prime/1.js").should == "#{dir}/file_system_fixtures_for_asset_manager_specs/dir_1/1.js"
51 |       end
52 |     end
53 | 
54 |     describe "#glob_virtual_paths" do
55 |       it "maps the glob pattern to the declared locations, potentially spanning multiple physical locations, and returns the matching relative paths" do
56 |         manager.glob_virtual_paths("/specs/**/*.js").should == ["/specs/2/2.js", "/specs/1/1.js", "/specs/1/7.js", "/specs/1/subdir_1/4.js"]
57 |         manager.glob_virtual_paths("/specs/1/*.js").should == ["/specs/1/1.js", "/specs/1/7.js"]
58 |         manager.glob_virtual_paths("/specs/x/*.js").should == []
59 |         manager.glob_virtual_paths("/implementations/**/*.js").should == ["/implementations/3.js", "/implementations/subdir_3/5.js"]
60 |         manager.glob_virtual_paths("/implementations/*.js").should == ["/implementations/3.js"]
61 |       end
62 |     end
63 | 
64 |     describe "#virtual_dependency_paths_from_load_path" do
65 |       it "computes the virtual paths of the require graph extending out from the files on the load path corresponding to the given paths" do
66 |         expected_dependency_paths = [
67 |           "/specs/1/7.js",
68 |           "/specs/1/subdir_1/4.js",
69 |           "/implementations/subdir_3/5.js",
70 |           "/implementations/3.js",
71 |           "/specs/1/1.js"
72 |         ]
73 |         manager.virtual_dependency_paths_from_load_path(["1.js", "subdir_3/5.js"]).should == expected_dependency_paths
74 |       end
75 |     end
76 | 
77 |     describe "#virtual_dependency_paths_from_physical_paths" do
78 |       it "computes the virtual paths of the require graph extending out from thes files at the given absolute paths" do
79 |         expected_dependency_paths = [
80 |           "/specs/1/7.js",
81 |           "/specs/1/subdir_1/4.js",
82 |           "/implementations/subdir_3/5.js",
83 |           "/implementations/3.js",
84 |           "/specs/1/1.js"
85 |         ]
86 |         physical_paths = [manager.physicalize_path("/specs/1/1.js"), manager.physicalize_path("/implementations/subdir_3/5.js")]
87 |         manager.virtual_dependency_paths_from_physical_paths(physical_paths).should == expected_dependency_paths
88 |       end
89 |     end
90 | 
91 |   end
92 | end
93 | 


--------------------------------------------------------------------------------
/client/lib/screw/interface/runner.js:
--------------------------------------------------------------------------------
  1 | (function(Screw, Monarch, jQuery) {
  2 | 
  3 | Monarch.constructor("Screw.Interface.Runner", Monarch.View.Template, {
  4 |   constructorProperties: {
  5 |     runSpecsOnPageLoad: function() {
  6 |       var self = this;
  7 |       jQuery(function() {
  8 |         var rootDescription = Screw.rootDescription();
  9 |         var queue = new Monarch.Queue();
 10 |         var runner;
 11 |         queue.add(function() {
 12 |           var show = jQuery.cookie("_screwUnit_show") || "all";
 13 |           runner = Screw.Interface.Runner.toView({root: Screw.rootDescription(), show: show, postOnCompletion: true});
 14 |         });
 15 |         queue.add(function() {
 16 |           Screw.$('body').html(runner);
 17 |         });
 18 |         queue.add(function() {
 19 |           runner.run(self.runPaths());
 20 |         })
 21 |         queue.start();
 22 |       });
 23 |     },
 24 | 
 25 |     runPaths: function() {
 26 |       var afterHash = Screw.Interface.getLocation().href.split("?")[1];
 27 |       if (afterHash) {
 28 |         return JSON.parse(afterHash);
 29 |       } else {
 30 |         return null;
 31 |       }
 32 |     }
 33 |   },
 34 | 
 35 |   content: function(initialAttributes) { with (this.builder) {
 36 |     div({'id': "screwUnitRunner"}, function() {
 37 |       table({'id': "screwUnitHeader"}, function() {
 38 |         tbody(function() {
 39 |           tr(function() {
 40 |             td({'id': "screwUnitControls"}, function() {
 41 |               button({'id': "showAll"}, "Show All").click(function(view) {
 42 |                 view.showAll();
 43 |               });
 44 |               button({'id': "showFailed"}, "Show Failed").click(function(view) {
 45 |                 view.showFailed();
 46 |               });
 47 |               button({'id': "rerunAll"}, "Rerun All").click(function(view) {
 48 |                 view.rerunAll();
 49 |               });
 50 |               button({'id': "rerunFailed"}, "Rerun Failed").click(function(view) {
 51 |                 view.rerunFailed();
 52 |               });
 53 |             });
 54 |             td(function() {
 55 |               subview('progressBar', Screw.Interface.ProgressBar, {root: initialAttributes.root});
 56 |             });
 57 |           })
 58 |         })
 59 |       });
 60 | 
 61 |       div({'id': 'testContent'});
 62 | 
 63 |       ul({'class': 'descriptions'}, function() {
 64 |         subview('rootDescription', Screw.Interface.Description, {description: initialAttributes.root, buildImmediately: initialAttributes.buildImmediately});
 65 |       });
 66 |     });
 67 |   }},
 68 | 
 69 |   viewProperties: {
 70 |     initialize: function() {
 71 |       if (this.show == "all") this.addClass('showAll');
 72 |       if (this.show == "failed") this.addClass("showFailed");
 73 |     },
 74 | 
 75 |     showFailed: function() {
 76 |       jQuery.cookie("_screwUnit_show", "failed", {path: "/"});
 77 |       this.addClass('showFailed');
 78 |       this.removeClass('showAll');
 79 |     },
 80 | 
 81 |     showAll: function() {
 82 |       jQuery.cookie("_screwUnit_show", "all", {path: "/"});
 83 |       this.addClass('showAll');
 84 |       this.removeClass('showFailed');
 85 |     },
 86 | 
 87 |     rerunFailed: function() {
 88 |       var failingPaths = Monarch.Util.map(this.root.failedExamples(), function(example) { return example.path() });
 89 |       Screw.Interface.setLocation(Screw.Interface.baseLocation() + '?' + JSON.stringify(failingPaths));
 90 |     },
 91 | 
 92 |     rerunAll: function() {
 93 |       Screw.Interface.setLocation(Screw.Interface.baseLocation());
 94 |     },
 95 | 
 96 |     run: function(runPaths) {
 97 |       var self = this;
 98 |       var objectsToRun = this.determineRunnablesToRun(runPaths);
 99 |       this.completedExampleCount = 0;
100 |       this.totalExamples = Screw.rootDescription().totalExamples();
101 | 
102 |       var queue = new Monarch.Queue();
103 |       this.root.onExampleCompleted(function() { self.exampleCompleted() } );
104 |       
105 |       Monarch.Util.each(objectsToRun, function(runnable) {
106 |         runnable.addToQueue(queue);
107 |       });
108 | 
109 |       queue.start();
110 |     },
111 | 
112 |     determineRunnablesToRun: function(runPaths) {
113 |       if (!runPaths) return [this.root];
114 | 
115 |       var self = this;
116 |       var runnablesToRun = [];
117 |       Monarch.Util.each(runPaths, function(path) {
118 |         var runnable = self.root.runnableAtPath(path);
119 |         if (runnable) {
120 |           runnablesToRun.push(runnable);
121 |         } else {
122 |           throw new Error("No runnable at path " + path);
123 |         }
124 |       });
125 |       return runnablesToRun;
126 |     },
127 | 
128 |     exampleCompleted: function() {
129 |       this.completedExampleCount++;
130 |       if (this.completedExampleCount == this.totalExamples) this.allExamplesCompleted();
131 |     },
132 | 
133 |     allExamplesCompleted: function() {
134 |       var isSuccess = (Screw.rootDescription().failedExamples().length == 0);
135 |       this.find("ul.descriptions").addClass(isSuccess ? "passed" : "failed");
136 |       if (this.postOnCompletion) {
137 |         var outcome = (isSuccess) ? "success" : this.root.failureMessages().join("\n");
138 |         Screw.jQuery.ajax({ type: 'POST', url: '/complete', data: outcome });
139 |       }
140 |     }
141 |   }
142 | });
143 | 
144 | })(Screw, Monarch, jQuery);
145 | 


--------------------------------------------------------------------------------
/client/spec/print_spec.js:
--------------------------------------------------------------------------------
  1 | Screw.Unit(function(c) { with(c) {
  2 |   describe("Print", function() {
  3 |     describe('when given undefined', function() {
  4 |       it("returns 'undefined'", function() {
  5 |         expect(Screw.$.print(undefined)).to(equal, 'undefined');
  6 |       });
  7 |     });
  8 |     
  9 |     describe('when given null', function() {
 10 |       it("returns 'null'", function() {
 11 |         expect(Screw.$.print(null)).to(equal, 'null');
 12 |       });
 13 |     });
 14 |     
 15 |     describe('when given a number', function() {
 16 |       it("returns the string representation of the number", function() {
 17 |         expect(Screw.$.print(1)).to(equal, '1');
 18 |         expect(Screw.$.print(1.01)).to(equal, '1.01');
 19 |         expect(Screw.$.print(-1)).to(equal, '-1');
 20 |       });
 21 |     });
 22 |     
 23 |     describe('when given a boolean', function() {
 24 |       it("returns the string representation of the boolean", function() {
 25 |         expect(Screw.$.print(true)).to(equal, 'true');
 26 |         expect(Screw.$.print(false)).to(equal, 'false');
 27 |       });
 28 |     });
 29 |     
 30 |     describe('when given a string', function() {
 31 |       it("returns the string, quoted", function() {
 32 |         expect(Screw.$.print('asdf')).to(equal, '"asdf"');
 33 |       });
 34 |       
 35 |       describe('when the string is longer than the [maxString] option', function() {
 36 |         it("returns the string, truncated", function() {
 37 |           expect(Screw.$.print('asdf', { maxString: 3 })).to(equal, '"asd..."');
 38 |         });        
 39 |       });
 40 |       
 41 |       describe('when the strings has quotes or escaped characters', function() {
 42 |         it("returns the string, with quotes and escaped characters escaped", function() {
 43 |           expect(Screw.$.print('as"df')).to(equal, '"as\\"df"');
 44 |           expect(Screw.$.print('as\tdf')).to(equal, '"as\\tdf"');
 45 |         });        
 46 |       });
 47 |     });
 48 |     
 49 |     describe('when given a function', function() {
 50 |       it("returns the function's signature", function() {
 51 |         expect(Screw.$.print(function() {})).to(equal, 'function ()');
 52 |         expect(Screw.$.print(function foo() {})).to(equal, 'function foo()');
 53 |         expect(Screw.$.print(function foo(bar) {})).to(equal, 'function foo(bar)');
 54 |       });        
 55 |     });
 56 | 
 57 |     describe('when given a RegExp', function() {
 58 |       it('should print the regexp', function() {
 59 |         expect(Screw.$.print(/abc/i)).to(equal, '/abc/i');
 60 |       });
 61 |     });
 62 | 
 63 |     describe('when given NaN', function() {
 64 |       it('should print the string "NaN"', function() {
 65 |         expect(Screw.$.print(NaN)).to(equal, 'NaN');
 66 |       });
 67 |     });
 68 | 
 69 |     describe('when given 0', function() {
 70 |       it('should print the string "0"', function() {
 71 |         expect(Screw.$.print(0)).to(equal, '0');
 72 |       });
 73 |     });
 74 |     
 75 |     describe('when given an element', function() {
 76 |       it("returns the string representation of the element", function() {
 77 |         expect(Screw.$.print(Screw.$('<div>').get(0))).to(equal, '<div>');
 78 |         expect(Screw.$.print(Screw.$('<div foo="bar">').get(0))).to(equal, '<div>');
 79 |         expect(Screw.$.print(Screw.$('<div class="foo" id="bar">').get(0))).to(equal, '<div class="foo" id="bar">');
 80 |       });
 81 | 
 82 |       describe('when the element is an img', function() {
 83 |         it('prints out the img src attribute', function() {
 84 |           expect(Screw.$.print(Screw.$('<img src="test.png">'))).to(match, /<img src=".+?test.png">/);
 85 |         })
 86 |       });
 87 |     });
 88 | 
 89 |     describe('when given an array', function() {
 90 |       it("returns the printed elements, comma separated, encircled by square brackets", function() {
 91 |         expect(Screw.$.print([])).to(equal, '[]');
 92 |         expect(Screw.$.print([1])).to(equal, '[ 1 ]');
 93 |         expect(Screw.$.print([1, 2, 3])).to(equal, '[ 1, 2, 3 ]');
 94 |       });
 95 |       
 96 |       describe('when the array is longer than the [maxArray] option', function() {
 97 |         it("returns the printed array, truncated", function() {
 98 |           expect(Screw.$.print([1, 2, 3, 4], { maxArray: 2 })).to(equal, '[ 1, 2, 2 more... ]');
 99 |         });
100 |       });
101 |       
102 |       describe('when the array has arrays as its elements', function() {
103 |         it("returns the recursively printed array", function() {
104 |           expect(Screw.$.print([[]])).to(equal, '[ [] ]');
105 |           expect(Screw.$.print([ [1, 2, 3], 4 ])).to(equal, '[ [ 1, 2, 3 ], 4 ]');
106 |         });
107 |       });
108 | 
109 |       describe('when the array has objects as its elements', function() {
110 |         it("returns recursively printed array", function() {
111 |           expect(Screw.$.print([{}])).to(equal, '[ {} ]');
112 |           expect(Screw.$.print([ { foo: 'bar' }, 'baz' ])).to(equal, '[ { foo: "bar" }, "baz" ]');
113 |         });
114 |       });
115 |     });
116 | 
117 |     describe('when given arguments', function() {
118 |       it("returns the printed array of elements ", function() {
119 |         var args = null;
120 |         (function(){ args = arguments })(1,2,3);
121 |         expect(Screw.$.print(args)).to(equal, '[ 1, 2, 3 ]');
122 |       });
123 |     });
124 |     
125 |     describe('when given a NodeList', function() {
126 |       it("returns the printed array of elements in the list", function() {
127 |         expect(Screw.$.print(document.getElementsByTagName('body'))).to(equal, '[ <body> ]');
128 |       });
129 |     });
130 | 
131 |     describe('when given an object', function() {
132 |       it("returns the keys and values of the object, enraptured with curly braces", function() {
133 |         expect(Screw.$.print({})).to(equal, '{}');
134 |         expect(Screw.$.print({ foo: 1, bar: 2 })).to(equal, '{ foo: 1, bar: 2 }');
135 |       });
136 |       
137 |       describe('when the values of the object are non-primitive', function() {
138 |         it("recursively prints the keys and values", function() {
139 |           expect(Screw.$.print({ foo: [1, 2] })).to(equal, '{ foo: [ 1, 2 ] }');
140 |         });
141 |         
142 |         describe('when the object has circular references', function() {
143 |           it("returns elipses for circularities", function() {
144 |             var circular = {};
145 |             circular[0] = circular;
146 |             expect(Screw.$.print(circular)).to(equal, '{ 0: ... }');
147 |           });
148 |         });
149 |       });
150 |     });
151 |   });
152 | }});


--------------------------------------------------------------------------------
/client/spec/example_spec.js:
--------------------------------------------------------------------------------
  1 | Screw.Unit(function(c) { with(c) {  
  2 |   describe("Screw.Example", function() {
  3 |     var example, name, fn, shouldFail, parentDescription, events, originalResetMocks, exampleContexts;
  4 | 
  5 |     before(function() {
  6 |       events = [];
  7 |       exampleContexts = [];
  8 | 
  9 |       name = "example"
 10 |       shouldFail = false;
 11 |       fn = function() {
 12 |         events.push("example function called");
 13 |         exampleContexts.push(this);
 14 |         if (shouldFail) throw(new Error("sad times"));
 15 |       };
 16 |       example = new Screw.Example(name, fn);
 17 |       parentDescription = new Screw.Description("parent description")
 18 |       parentDescription.runBefores = function(exampleContext) {
 19 |         events.push("runBefores called");
 20 |         exampleContexts.push(exampleContext);
 21 |       }
 22 |       parentDescription.runAfters = function(exampleContext) {
 23 |         events.push("runAfters called");
 24 |         exampleContexts.push(exampleContext);
 25 |       }
 26 | 
 27 |       example.parentDescription = parentDescription;
 28 | 
 29 |       originalResetMocks = Screw.resetMocks;
 30 |       Screw.resetMocks = function() {
 31 |         events.push("resetMocks called");
 32 |       }
 33 |     });
 34 | 
 35 |     after(function() {
 36 |       Screw.resetMocks = originalResetMocks;
 37 |     });
 38 | 
 39 |     describe("#initialize", function() {
 40 |       it("assigns #name and #fn", function() {
 41 |         expect(example.name).to(equal, name);
 42 |         expect(example.fn).to(equal, fn);
 43 |       });
 44 |       
 45 |       it("sets #failed and #passed to false", function() {
 46 |         expect(example.passed).to(beFalse);
 47 |         expect(example.failed).to(beFalse);
 48 |       });
 49 |     });
 50 | 
 51 |     describe("#clone", function() {
 52 |       it("makes a copy of the Example, with fresh SubscriptionNodes", function() {
 53 |         var originalPassCallback = mockFunction("original pass callback");
 54 |         var originalFailCallback = mockFunction("original fail callback");
 55 |         var originalCompletedCallback = mockFunction("original completed callback");
 56 |         var clonePassCallback = mockFunction("clone pass callback");
 57 |         var cloneFailCallback = mockFunction("clone fail callback");
 58 |         var cloneCompletedCallback = mockFunction("clone completed callback");
 59 | 
 60 | 
 61 |         example.onPass(originalPassCallback);
 62 |         example.onFail(originalFailCallback);
 63 |         example.onExampleCompleted(originalCompletedCallback);
 64 | 
 65 |         var clone = example.clone();
 66 | 
 67 |         expect(clone.name).to(equal, example.name);
 68 |         expect(clone.fn).to(equal, example.fn);
 69 | 
 70 |         clone.onPass(clonePassCallback);
 71 |         clone.onFail(cloneFailCallback);
 72 |         clone.onExampleCompleted(cloneCompletedCallback);
 73 | 
 74 |         clone.run();
 75 |         expect(clonePassCallback).to(haveBeenCalled, once);
 76 |         expect(originalPassCallback).toNot(haveBeenCalled);
 77 |         expect(cloneCompletedCallback).to(haveBeenCalled, once);
 78 |         expect(originalCompletedCallback).toNot(haveBeenCalled);
 79 | 
 80 |         shouldFail = true;
 81 |         clone.run();
 82 |         expect(cloneFailCallback).to(haveBeenCalled, once);
 83 |         expect(originalFailCallback).toNot(haveBeenCalled);
 84 |       });
 85 |     });
 86 | 
 87 |     describe("#run", function() {
 88 |       it("with the same example context, calls parentDescription.runBefores, invokes the example function, calls parentDescription.runAfters, then calls Screw.resetMocks", function() {
 89 |         example.run();
 90 |         expect(events).to(equal, ["runBefores called", "example function called", "runAfters called", "resetMocks called"]);
 91 |         expect(exampleContexts.length).to(equal, 3);
 92 |         expect(exampleContexts[0]).to(equal, exampleContexts[1]);
 93 |         expect(exampleContexts[0]).to(equal, exampleContexts[2]);
 94 |       });
 95 | 
 96 |       context("if the example fails", function() {
 97 |         before(function() {
 98 |           shouldFail = true;
 99 |         });
100 |         
101 |         it("invokes callbacks registered with #onFail", function() {
102 |           var callbackInvoked = false;
103 |           example.onFail(function() {
104 |             callbackInvoked = true;
105 |           })
106 |           example.run();
107 |           expect(callbackInvoked).to(beTrue);
108 |         });
109 | 
110 |         it("assigns #failed to true and #passed to false", function() {
111 |           expect(example.passed).to(beFalse);
112 |           expect(example.failed).to(beFalse);
113 |           example.run();
114 |           expect(example.passed).to(beFalse);
115 |           expect(example.failed).to(beTrue);
116 |         });
117 |       });
118 | 
119 |       context("if the example passes", function() {
120 |         before(function() {
121 |           expect(shouldFail).to(beFalse);
122 |         });
123 | 
124 |         it("invokes callbacks registered with #onPass", function() {
125 |           var callbackInvoked = false;
126 |           example.onPass(function() {
127 |             callbackInvoked = true;
128 |           })
129 |           example.run();
130 |           expect(callbackInvoked).to(beTrue);
131 |         });
132 | 
133 |         it("assigns #passed to true and #failed to false", function() {
134 |           expect(example.passed).to(beFalse);
135 |           expect(example.failed).to(beFalse);
136 |           example.run();
137 |           expect(example.passed).to(beTrue);
138 |           expect(example.failed).to(beFalse);
139 |         });
140 |       });
141 |     });
142 | 
143 |     describe("#totalExamples", function() {
144 |       it("always returns 1", function() {
145 |         expect(example.totalExamples()).to(equal, 1);
146 |       });
147 |     });
148 | 
149 |     describe("#path", function() {
150 |       it("returns #index concatenated to the #path of the #parentDescription", function() {
151 |         expect(example.path()).to(equal, parentDescription.path() + [example.index]);
152 |       });
153 |     });
154 | 
155 |     describe("#failureMessage", function() {
156 |       describe("when the example passes", function() {
157 |         it("returns null", function() {
158 |           example.run();
159 |           expect(example.failureMessage).to(equal, null);
160 |         });
161 |       });
162 | 
163 |       describe("when the example fails", function() {
164 |         before(function() {
165 |           shouldFail = true;
166 |         });
167 | 
168 |         it("returns the a message including the example's name and the error message", function() {
169 |           example.run();
170 |           expect(example.failureMessage).to(match, "sad times");
171 |         });
172 |       });
173 |     });
174 |   });
175 | }});
176 | 


--------------------------------------------------------------------------------
/client/lib/screw/description.js:
--------------------------------------------------------------------------------
  1 | (function(Screw, Monarch) {
  2 | 
  3 | Monarch.constructor("Screw.Description", Screw.RunnableMethods, {
  4 |   initialize: function(name) {
  5 |     this.name = name;
  6 |     this.children = [];
  7 |     this.childDescriptions = [];
  8 |     this.examples = [];
  9 |     this.inits = [];
 10 |     this.befores = [];
 11 |     this.afters = [];
 12 |     this.childSubscriptions = new Monarch.SubscriptionBundle();
 13 |     this.exampleCompletedSubscriptionNode = new Monarch.SubscriptionNode();
 14 |     this.hasScenario = false;
 15 |   },
 16 | 
 17 |   clone: function() {
 18 |     var clone = Screw.$.extend(new Screw.Description(), this);
 19 |     clone.exampleCompletedSubscriptionNode = new Monarch.SubscriptionNode();
 20 |     clone.childSubscriptions = new Monarch.SubscriptionBundle();
 21 |     clone.children = [];
 22 |     clone.childDescriptions = [];
 23 |     clone.examples = [];
 24 | 
 25 |     Screw.each(this.children, function() {
 26 |       var childClone = this.clone();
 27 |       if (childClone.constructor == Screw.Description) {
 28 |         clone.addDescription(childClone);
 29 |       } else {
 30 |         clone.addExample(childClone);
 31 |         }
 32 |     });
 33 | 
 34 |     return clone;
 35 |   },
 36 | 
 37 |   clearChildren: function() {
 38 |     this.childSubscriptions.destroyAll();
 39 |     this.children = [];
 40 |     this.childDescriptions = [];
 41 |     this.examples = [];
 42 |   },
 43 | 
 44 |   totalExamples: function() {
 45 |     var totalExamples = this.examples.length;
 46 |     Screw.each(this.childDescriptions, function() {
 47 |       totalExamples += this.totalExamples();
 48 |     })
 49 |     return totalExamples;
 50 |   },
 51 | 
 52 |   failedExamples: function() {
 53 |     var failedExamples = [];
 54 |     Screw.each(this.examples, function() {
 55 |       if (this.failed) {
 56 |         failedExamples.push(this);
 57 |       }
 58 |     });
 59 |     Screw.each(this.childDescriptions, function() {
 60 |       failedExamples = failedExamples.concat(this.failedExamples());
 61 |     });
 62 |     return failedExamples;
 63 |   },
 64 | 
 65 |   failureMessages: function() {
 66 |     var messages = [];
 67 |     Screw.each(this.failedExamples(), function() {
 68 |       messages.push(this.failureMessage);
 69 |     });
 70 |     return messages;
 71 |   },
 72 | 
 73 |   runnableAtPath: function(path) {
 74 |     var currentRunnable = this;
 75 |     Screw.each(path, function() {
 76 |       currentRunnable = currentRunnable.children[this];
 77 |     });
 78 |     return currentRunnable;
 79 |   },
 80 | 
 81 |   addDescription: function(description) {
 82 |     if (this.hasScenarios) {
 83 |       this.addDescriptionToScenarios(description);
 84 |     } else {
 85 |       this.addChildDescriptionOrScenario(description)
 86 |     }
 87 |   },
 88 | 
 89 |   addDescriptionToScenarios: function(description) {
 90 |     this.scenarioChildDescriptions.push(description);
 91 |     Screw.each(this.childDescriptions, function() {
 92 |       this.addDescription(description.clone());
 93 |     });
 94 |   },
 95 | 
 96 |   addScenario: function(scenarioDescription) {
 97 |     if (!this.hasScenarios) {
 98 |       this.scenarioExamples = this.examples;
 99 |       this.scenarioChildDescriptions = this.childDescriptions;
100 |       this.children = [];
101 |       this.childDescriptions = [];
102 |       this.examples = [];
103 |       this.hasScenarios = true;
104 |     }
105 | 
106 |     Screw.each(this.scenarioExamples, function() {
107 |       scenarioDescription.addExample(this.clone());
108 |     });
109 |     Screw.each(this.scenarioChildDescriptions, function() {
110 |       scenarioDescription.addDescription(this.clone());
111 |     });
112 | 
113 |     this.addChildDescriptionOrScenario(scenarioDescription);
114 |   },
115 | 
116 |   addChildDescriptionOrScenario: function(description) {
117 |     var self = this;
118 |     description.parentDescription = this;
119 |     description.index = this.children.length;
120 |     this.children.push(description);
121 |     this.childDescriptions.push(description);
122 | 
123 |     this.childSubscriptions.add(description.onExampleCompleted(function(example) {
124 |       self.exampleCompletedSubscriptionNode.publish(example);
125 |     }));
126 |   },
127 | 
128 |   addExample: function(example) {
129 |     if (this.hasScenarios) {
130 |       this.addExampleToScenarios(example);
131 |     } else {
132 |       var self = this;
133 |       example.parentDescription = this;
134 |       example.index = this.children.length;
135 |       this.children.push(example);
136 |       this.examples.push(example);
137 | 
138 |       this.childSubscriptions.add(example.onExampleCompleted(function(example) {
139 |         self.exampleCompletedSubscriptionNode.publish(example);
140 |       }));
141 |     }
142 |   },
143 | 
144 |   addExampleToScenarios: function(example) {
145 |     this.scenarioExamples.push(example);
146 |     Screw.each(this.childDescriptions, function() {
147 |       this.addExample(example.clone());
148 |     });
149 |   },
150 | 
151 |   addInit: function(fn) {
152 |     this.inits.push(fn);
153 |   },
154 | 
155 |   addBefore: function(fn) {
156 |     this.befores.push(fn);
157 |   },
158 | 
159 |   addAfter: function(fn) {
160 |     this.afters.push(fn);
161 |   },
162 | 
163 |   addToQueue: function(queue) {
164 |     Monarch.Util.each(this.examples, function(example) {
165 |       example.addToQueue(queue);
166 |     });
167 | 
168 |     Monarch.Util.each(this.childDescriptions, function(description) {
169 |       description.addToQueue(queue);
170 |     });
171 |   },
172 | 
173 |   run: function() {
174 |     var queue = new Monarch.Queue();
175 |     Monarch.Util.each(this.examples, function(example) {
176 |       queue.add(function() {
177 |         example.run();
178 |       })
179 |     });
180 | 
181 |     Monarch.Util.each(this.childDescriptions, function(description) {
182 |        queue.add(function() {
183 |          description.run();
184 |        });
185 |     });
186 |     
187 |     queue.start();
188 |   },
189 | 
190 |   runInits: function(exampleContext) {
191 |     if (this.parentDescription) {
192 |       this.parentDescription.runInits(exampleContext);
193 |     }
194 | 
195 |     Screw.each(this.inits, function() {
196 |       this.call(exampleContext);
197 |     });
198 |   },
199 | 
200 |   runBefores: function(exampleContext) {
201 |     if (this.parentDescription) {
202 |       this.parentDescription.runBefores(exampleContext);
203 |     }
204 | 
205 |     Screw.each(this.befores, function() {
206 |       this.call(exampleContext);
207 |     });
208 |   },
209 | 
210 |   runAfters: function(exampleContext) {
211 |     Screw.each(this.afters, function() {
212 |       this.call(exampleContext);
213 |     });
214 | 
215 |     if (this.parentDescription) {
216 |       this.parentDescription.runAfters(exampleContext);
217 |     }
218 |   },
219 | 
220 | 
221 |   fullName: function() {
222 |     if (this.parentDescription) {
223 |       return this.parentDescription.fullName() + this.name + " :: ";
224 |     } else {
225 |       return "";
226 |     }
227 |   }
228 | 
229 | });
230 | 
231 | })(Screw, Monarch);
232 | 


--------------------------------------------------------------------------------
/client/spec/mock_spec.js:
--------------------------------------------------------------------------------
  1 | Screw.Unit(function(c) { with(c) {
  2 |   describe("#mock", function() {
  3 |     context("when passed an object and the name of a function on that object", function() {
  4 |       var object;
  5 |       before(function() {
  6 |         object = {
  7 |           foo: function() {
  8 |             return "originalFooValue";
  9 |           },
 10 |           bar: function() {
 11 |             this.barArguments = arguments;
 12 |             return "originalBarValue";
 13 |           }
 14 |         };
 15 |         mock(object, 'foo');
 16 |       });
 17 | 
 18 |       it("records the #callCount on that function", function() {
 19 |         expect(object.foo.callCount).to(equal, 0);
 20 |         object.foo();
 21 |         expect(object.foo.callCount).to(equal, 1);
 22 |         object.foo();
 23 |         expect(object.foo.callCount).to(equal, 2);
 24 |       });
 25 | 
 26 |       it("pushes the arguments of the call to a #callArgs array on that function", function() {
 27 |         expect(object.foo.callArgs).to(equal, []);
 28 |         object.foo("bar", "baz");
 29 |         expect(object.foo.callArgs).to(equal, [["bar", "baz"]]);
 30 |         object.foo("quux");
 31 |         expect(object.foo.callArgs).to(equal, [["bar", "baz"], ["quux"]]);
 32 |       });
 33 | 
 34 |       it("sets #mostRecentArgs on the function", function() {
 35 |         expect(object.foo.mostRecentArgs).to(equal, null);
 36 |         object.foo("bar", "baz");
 37 |         expect(object.foo.mostRecentArgs).to(equal, ["bar", "baz"]);
 38 |         object.foo("quux");
 39 |         expect(object.foo.mostRecentArgs).to(equal, ["quux"]);
 40 |       });
 41 |       
 42 |       context("when passed a function as its third argument", function() {
 43 |         var callArgs;
 44 |         before(function() {
 45 |           callArgs = [];
 46 |           mock(object, "bar", function() {
 47 |             callArgs.push(Array.prototype.slice.call(arguments));
 48 |           });
 49 |         });
 50 | 
 51 |         it("calls the function", function() {
 52 |           object.bar("bar", "baz");
 53 |           expect(callArgs).to(equal, [["bar", "baz"]]);
 54 |           object.bar("quux");
 55 |           expect(callArgs).to(equal, [["bar", "baz"], ["quux"]]);
 56 |         });
 57 |       });
 58 | 
 59 |       context("when passed 'proxy' as its third argument", function() {
 60 |         before(function() {
 61 |           mock(object, "bar", "proxy");
 62 |         });
 63 | 
 64 |         it("still invokes the original function from the wrapper, but records the call for verification", function() {
 65 |           expect(object.bar("bar", "baz")).to(equal, "originalBarValue");
 66 |           expect(object.bar.mostRecentArgs).to(equal, ["bar", "baz"]);
 67 |           expect(object.barArguments[0]).to(equal, "bar");
 68 |           expect(object.barArguments[1]).to(equal, "baz");
 69 |         });
 70 |       });
 71 |     });
 72 |   })
 73 | 
 74 |   describe("#mockFunction", function() {
 75 |     var mockFn;
 76 |     before(function() {
 77 |       mockFn = mockFunction();
 78 |     });
 79 | 
 80 |     it("records the #callCount on that function", function() {
 81 |       expect(mockFn.callCount).to(equal, 0);
 82 |       mockFn();
 83 |       expect(mockFn.callCount).to(equal, 1);
 84 |       mockFn();
 85 |       expect(mockFn.callCount).to(equal, 2);
 86 |     });
 87 | 
 88 |     it("pushes the arguments of the call to a #callArgs array on that function", function() {
 89 |       expect(mockFn.callArgs).to(equal, []);
 90 |       mockFn("bar", "baz");
 91 |       expect(mockFn.callArgs).to(equal, [["bar", "baz"]]);
 92 |       mockFn("quux");
 93 |       expect(mockFn.callArgs).to(equal, [["bar", "baz"], ["quux"]]);
 94 |     });
 95 | 
 96 |     it("sets #mostRecent args on the function", function() {
 97 |       expect(mockFn.mostRecentArgs).to(equal, null);
 98 |       mockFn("bar", "baz");
 99 |       expect(mockFn.mostRecentArgs).to(equal, ["bar", "baz"]);
100 |       mockFn("quux");
101 |       expect(mockFn.mostRecentArgs).to(equal, ["quux"]);
102 |     });
103 | 
104 |     it("pushes the 'this' value of the call to a #thisValues array and sets #mostRecentThisVaule", function() {
105 |       var a = { mockFn: mockFn };
106 |       var b = { mockFn: mockFn };
107 | 
108 |       expect(mockFn.thisValues).to(equal, []);
109 |       expect(mockFn.mostRecentThisValue).to(beNull);
110 |       a.mockFn();
111 |       expect(mockFn.thisValues).to(equal, [a]);
112 |       expect(mockFn.mostRecentThisValue).to(equal, a);
113 | 
114 |       b.mockFn();
115 |       expect(mockFn.thisValues).to(equal, [a, b]);
116 |       expect(mockFn.mostRecentThisValue).to(equal, b);
117 |     });
118 | 
119 |     context("when passed a functionName as its only argument", function() {
120 |       it("assigns functionName to the given name", function() {
121 |         var mockFn = mockFunction("function name");
122 |         expect(mockFn.functionName).to(equal, "function name");
123 |       });
124 |     });
125 | 
126 |     context("when passed a function as its only argument", function() {
127 |       var thisValue, callArgs;
128 |       before(function() {
129 |         callArgs = [];
130 |         mockFn = mockFunction(function() {
131 |           thisValue = this;
132 |           callArgs.push(Array.prototype.slice.call(arguments));
133 |         });
134 |       });
135 | 
136 |       it("calls the function with the same 'this'", function() {
137 |         var a = { mockFn: mockFn };
138 |         var b = { mockFn: mockFn };
139 |         a.mockFn("bar", "baz");
140 |         expect(thisValue).to(equal, a);
141 |         expect(callArgs).to(equal, [["bar", "baz"]]);
142 | 
143 |         b.mockFn("quux");
144 |         expect(thisValue).to(equal, b);
145 |         expect(callArgs).to(equal, [["bar", "baz"], ["quux"]]);
146 |       });
147 |     });
148 | 
149 |     context("when passed a functionName and a function as its arguments", function() {
150 |       it("assigns functionName to the given name and calls the function when it is called", function() {
151 |         var functionToCall = mockFunction("function to call");
152 |         var mockFn = mockFunction("function name", functionToCall);
153 |         expect(mockFn.functionName).to(equal, "function name");
154 |         
155 |         mockFn();
156 | 
157 |         expect(functionToCall).to(haveBeenCalled);
158 |       });
159 |     });
160 | 
161 |     describe("#clear on the results of #mockFunction", function() {
162 |       it("resets all recorded call data", function() {
163 |         var a = { mockFn: mockFn };
164 |         a.mockFn("foo");
165 | 
166 |         expect(mockFn.thisValues).to(equal, [a]);
167 |         expect(mockFn.mostRecentThisValue).to(equal, a);
168 |         expect(mockFn.callCount).to(equal, 1);
169 |         expect(mockFn.callArgs).to(equal, [["foo"]]);
170 |         expect(mockFn.mostRecentArgs).to(equal, ["foo"]);
171 | 
172 |         mockFn.clear();
173 | 
174 |         expect(mockFn.thisValues).to(equal, []);
175 |         expect(mockFn.mostRecentThisValue).to(equal, null);
176 |         expect(mockFn.callCount).to(equal, 0);
177 |         expect(mockFn.callArgs).to(equal, []);
178 |         expect(mockFn.mostRecentArgs).to(equal, null);
179 |       });
180 |     });
181 | 
182 |   });
183 | }});


--------------------------------------------------------------------------------
/client/spec/interface/description_spec.js:
--------------------------------------------------------------------------------
  1 | Screw.Unit(function(c) { with(c) {
  2 |   describe("Screw.Interface.Description", function() {
  3 |     var description, view;
  4 |     before(function() {
  5 |       var parentDescription = new Screw.Description("parent description");
  6 |       description = new Screw.Description("description");
  7 |       parentDescription.addDescription(description);
  8 |     });
  9 | 
 10 |     describe("#focus", function() {
 11 |       it("sets window.location to match the path of the view's Description", function() {
 12 |         view = Screw.Interface.Description.toView({description: description, buildImmediately: true});
 13 |         mock(Screw.Interface, 'getLocation', function() {
 14 |           return { href: "http://localhost:8080/specs?[[0]]"};
 15 |         });
 16 | 
 17 |         mock(Screw.Interface, 'setLocation');
 18 |         view.focus();
 19 |         expect(Screw.Interface.setLocation).to(haveBeenCalled, withArgs("http://localhost:8080/specs?" + JSON.stringify([description.path()])));
 20 |       });
 21 |     });
 22 | 
 23 |     describe("#content", function() {
 24 |       context("when the view is instantiated without the buildImmediately option", function() {
 25 |         var example1, example2, setTimeoutCallback;
 26 |         before(function() {
 27 |           example1 = new Screw.Example("example 1", function() { });
 28 |           example2 = new Screw.Example("example 2", function() { });
 29 |           description.addExample(example1);
 30 |           description.addExample(example2);
 31 |         });
 32 | 
 33 |         it("renders the outline of the Description's view immediately", function() {
 34 |           view = Screw.Interface.Description.toView({description: description});
 35 | 
 36 |           var examples = view.find('ul.examples');
 37 |           expect(examples.length).to(equal, 1);
 38 |           expect(examples.find('li').length).to(equal, 0);
 39 |         });
 40 | 
 41 |         it("renders the Description's descendents in a setTimeout context", function() {
 42 |           mock(window, "setTimeout", function(callback, delay) { callback.call(window); });
 43 |           view = Screw.Interface.Description.toView({description: description});
 44 | 
 45 |           var examples = view.find('ul.examples');
 46 |           expect(examples.length).to(equal, 1);
 47 |           expect(examples.find('li').length).to(equal, 2);
 48 |           expect(examples.html()).to(match, Screw.Interface.Example.toView({example: example1}).html());
 49 |           expect(examples.html()).to(match, Screw.Interface.Example.toView({example: example2}).html());
 50 |         });
 51 |       });
 52 | 
 53 |       context("when the view's Description has #examples", function() {
 54 |         var example1, example2;
 55 |         before(function() {
 56 |           example1 = new Screw.Example("example 1", function() {
 57 |             if (shouldFail) throw(new Error(failureMessage));
 58 |           });
 59 |           example2 = new Screw.Example("example 2", function() {
 60 |             if (shouldFail) throw(new Error(failureMessage));
 61 |           });
 62 |           description.addExample(example1);
 63 |           description.addExample(example2);
 64 |           view = Screw.Interface.Description.toView({description: description, buildImmediately: true});
 65 |         });
 66 | 
 67 |         it("renders all examples within a ul.examples", function() {
 68 |           var examples = view.find('ul.examples');
 69 |           expect(examples.length).to(equal, 1);
 70 |           expect(examples.find('li').length).to(equal, 2);
 71 |           expect(examples.html()).to(match, Screw.Interface.Example.toView({example: example1}).html());
 72 |           expect(examples.html()).to(match, Screw.Interface.Example.toView({example: example2}).html());
 73 |         });
 74 |       });
 75 | 
 76 |       context("when the view's Description has no #examples", function() {
 77 |         before(function() {
 78 |           view = Screw.Interface.Description.toView({description: description, buildImmediately: true});
 79 |         });
 80 | 
 81 |         it("does not render a ul.examples", function() {
 82 |           expect(view.find('ul.examples')).to(beEmpty);
 83 |         });
 84 |       });
 85 | 
 86 |       context("when the view's Description has #childDescriptions", function() {
 87 |         var childDescription1, childDescription2;
 88 |         before(function() {
 89 |           childDescription1 = new Screw.Description("child description 1");
 90 |           childDescription2 = new Screw.Description("child description 2");
 91 |           description.addDescription(childDescription1);
 92 |           description.addDescription(childDescription2);
 93 |           view = Screw.Interface.Description.toView({description: description, buildImmediately: true});
 94 |         });
 95 | 
 96 |         it("renders all child descriptions within a ul.childDescriptions", function() {
 97 |           var childDescriptions = view.find('ul.childDescriptions');
 98 |           expect(childDescriptions.length).to(equal, 1);
 99 |           expect(childDescriptions.find('li').length).to(equal, 2);
100 |           expect(childDescriptions.html()).to(match, Screw.Interface.Description.toView({description: childDescription1, buildImmediately: true}).html());
101 |           expect(childDescriptions.html()).to(match, Screw.Interface.Description.toView({description: childDescription2, buildImmediately: true}).html());
102 |         });
103 | 
104 |       });
105 | 
106 |       context("when the view's Description has no #childDescriptions", function() {
107 |         before(function() {
108 |           view = Screw.Interface.Description.toView({description: description, buildImmediately: true});
109 |         });
110 | 
111 |         it("does not render a ul.childDescriptions", function() {
112 |           expect(view.find('ul.childDescriptions')).to(beEmpty);
113 |         });
114 |       });
115 |     });
116 | 
117 |     describe("when span.name is clicked", function() {
118 |       before(function() {
119 |         view = Screw.Interface.Description.toView({description: description, buildImmediately: true});
120 |       });
121 | 
122 |       it("calls #focus on the view", function() {
123 |         mock(view, 'focus');
124 |         view.find("span.name").click();
125 |         expect(view.focus).to(haveBeenCalled);
126 |       });
127 |     });
128 | 
129 |     describe("when an Example nested within the associated Description is completed", function() {
130 |       var grandchildExample, shouldFail;
131 |       before(function() {
132 |         view = Screw.Interface.Description.toView({description: description, buildImmediately: true});
133 |         var childDescription = new Screw.Description("child description");
134 |         grandchildExample = new Screw.Example("grandchild example", function() {
135 |           if (shouldFail) throw(new Error("fails intentionally"));
136 |         })
137 |         childDescription.addExample(grandchildExample);
138 |         description.addDescription(childDescription);
139 |       });
140 | 
141 |       context("when the Example passes", function() {
142 |         before(function() {
143 |           shouldFail = false;
144 |         });
145 | 
146 |         it("applies the 'passed' class to its content", function() {
147 |           expect(view.hasClass('failed')).to(beFalse);
148 |           expect(view.hasClass('passed')).to(beFalse);
149 | 
150 |           grandchildExample.run();
151 | 
152 |           expect(view.hasClass('failed')).to(beFalse);
153 |           expect(view.hasClass('passed')).to(beTrue);
154 |         });
155 |       });
156 | 
157 |       context("when the Example fails", function() {
158 |         before(function() {
159 |           shouldFail = true;
160 |         });
161 | 
162 |         it("applies the 'failed' class to its content", function() {
163 |           expect(view.hasClass('failed')).to(beFalse);
164 |           expect(view.hasClass('passed')).to(beFalse);
165 |           grandchildExample.run();
166 |           expect(view.hasClass('failed')).to(beTrue);
167 |           expect(view.hasClass('passed')).to(beFalse);
168 |         });
169 |       });
170 |     });
171 |   });
172 | }});
173 | 


--------------------------------------------------------------------------------
/client/spec/integration_spec.js:
--------------------------------------------------------------------------------
  1 | Screw.Unit(function(c) { with(c) {
  2 |   var globalBeforeInvoked = false, globalAfterInvoked = false;
  3 |   before(function() { globalBeforeInvoked = true });
  4 |   after(function() { globalAfterInvoked = true });
  5 | 
  6 |   describe("a simple [describe]", function() {
  7 |     it("invokes the global [before] before an [it]", function() {
  8 |       expect(globalBeforeInvoked).to(equal, true);
  9 |       globalBeforeInvoked = false;
 10 |     });
 11 | 
 12 |     it("invokes the global [before] before each [it]", function() {
 13 |       expect(globalBeforeInvoked).to(equal, true);
 14 |       globalAfterInvoked = false;
 15 |     });
 16 | 
 17 |     it("invokes the global [after] after an [it]", function() {
 18 |       expect(globalAfterInvoked).to(equal, true);
 19 |     });
 20 |   });
 21 | 
 22 |   describe("a [describe] with a [before] and [after] block", function() {
 23 |     var beforeInvoked = false, afterInvoked = false;
 24 |     before(function() { beforeInvoked = true });
 25 |     after(function() { afterInvoked = true });
 26 | 
 27 |     describe('[after] blocks', function() {
 28 |       it("does not invoke the [after] until after the first [it]", function() {
 29 |         expect(afterInvoked).to(equal, false);
 30 |       });
 31 | 
 32 |       it("invokes the [after] after the first [it]", function() {
 33 |         expect(afterInvoked).to(equal, true);
 34 |         afterInvoked = false;
 35 |       });
 36 | 
 37 |       it("invokes the [after] after each [it]", function() {
 38 |         expect(afterInvoked).to(equal, true);
 39 |       });
 40 |     });
 41 | 
 42 |     describe('[before] blocks', function() {
 43 |       it("invokes the [before] before an it", function() {
 44 |         expect(beforeInvoked).to(equal, true);
 45 |         beforeInvoked = false;
 46 |       });
 47 | 
 48 |       it("invokes the [before] before each it", function() {
 49 |         expect(beforeInvoked).to(equal, true);
 50 |       });
 51 |     });
 52 |   });
 53 | 
 54 |   describe("A [describe] with two [before] and two [after] blocks", function() {
 55 |     var beforeInvocations = [], afterInvocations = [];
 56 |     before(function() { beforeInvocations.push('before 1') });
 57 |     before(function() { beforeInvocations.push('before 2') });
 58 | 
 59 |     after(function() { afterInvocations.push('after 1') });
 60 |     after(function() { afterInvocations.push('after 2') });
 61 | 
 62 |     it("invokes the [before]s in lexical order before each [it]", function() {
 63 |       expect(beforeInvocations).to(equal, ['before 1', 'before 2']);
 64 |     });
 65 | 
 66 |     it("invokes the [afters]s in lexical order after each [it]", function() {
 67 |       expect(afterInvocations).to(equal, ['after 1', 'after 2']);
 68 |     });
 69 |   });
 70 | 
 71 |   describe("A describe with a nested describe", function() {
 72 |     var beforeInvocations = [], afterInvocations = [], clearAfterInvocations, expectedThisInvocations;
 73 |     before(function() {
 74 |       clearAfterInvocations = true;
 75 |       beforeInvocations = [];
 76 |       beforeInvocations.push("outermost before");
 77 | 
 78 |       expectedThisInvocations = undefined;
 79 |       this.invocations = [];
 80 |       this.invocations.push("outermost before");
 81 |     });
 82 | 
 83 |     after(function() {
 84 |       afterInvocations.push("outermost after");
 85 |       this.invocations.push("outermost after");
 86 |       if (clearAfterInvocations) afterInvocations = [];
 87 |       if (expectedThisInvocations) {
 88 |         expect(this.invocations).to(equal, expectedThisInvocations);
 89 |       }
 90 |     });
 91 | 
 92 |     it("outside a nested [describe], does not invoke any of the nested's [before]s", function() {
 93 |       expect(beforeInvocations).to(equal, ["outermost before"]);
 94 |       clearAfterInvocations = false;
 95 |     });
 96 | 
 97 |     it("outside a nested [describe], does not invoke any of the nested's [after]s", function() {
 98 |       expect(afterInvocations).to(equal, ["outermost after"]);
 99 |     });
100 | 
101 |     describe("a nested [describe]", function() {
102 |       before(function() {
103 |         beforeInvocations.push("inner before");
104 |         this.invocations.push("inner before");
105 |       });
106 | 
107 |       after(function() {
108 |         afterInvocations.push("inner after");
109 |         this.invocations.push("inner after");
110 |       });
111 | 
112 |       it("runs [before]s in the parent [describe] before each [it]", function() {
113 |         expect(beforeInvocations).to(equal, ["outermost before", "inner before"]);
114 |         clearAfterInvocations = false;
115 |       });
116 | 
117 |       it("runs [after]s in the parent [describe] after each [it]", function() {
118 |         expect(afterInvocations).to(equal, ["inner after", "outermost after"]);
119 |       });
120 | 
121 |       describe("a doubly nested [describe]", function() {
122 |         before(function() {
123 |           beforeInvocations.push('innermost before');
124 |           this.invocations.push('innermost before');
125 |         });
126 | 
127 |         after(function() {
128 |           afterInvocations = [];
129 |           afterInvocations.push('innermost after');
130 |           this.invocations.push('innermost after');
131 |         });
132 | 
133 |         it("runs all befores and afters in the context of the same object", function() {
134 |           this.invocations.push("example");
135 |           expectedThisInvocations = ["outermost before", "inner before", "innermost before", "example", "innermost after", "inner after", "outermost after"];
136 |         });
137 | 
138 |         describe('[before] blocks', function() {
139 |           it("runs [before]s in all ancestors before an [it]", function() {
140 |             expect(beforeInvocations).to(equal, ["outermost before", "inner before", "innermost before"]);
141 |           });
142 | 
143 |           it("runs [before]s in all ancestors before each [it]", function() {
144 |             expect(beforeInvocations).to(equal, ["outermost before", "inner before", "innermost before"]);
145 |             clearAfterInvocations = false;
146 |           });
147 |         });
148 | 
149 |         describe('[after] blocks', function() {
150 |           it("runs [after]s in all ancestors after each [it]", function() {
151 |             expect(afterInvocations).to(equal, ["innermost after", "inner after", "outermost after"]);
152 |           });
153 |         });
154 |       });
155 |     });
156 |   });
157 | 
158 |   describe("A describe block with exceptions", function() {
159 |     var afterInvoked = false;
160 |     after(function() {
161 |       afterInvoked = true;
162 |     });
163 | 
164 |     describe("an exception in a test", function() {
165 |       it("fails because it throws an exception (NOTE: deliberate failure required to exercise the next example)", function() {
166 |         throw(new Error('an exception'));
167 |       });
168 | 
169 |       it("invokes [after]s even if the previous [it] raised an exception", function() {
170 |         expect(afterInvoked).to(equal, true);
171 |       });
172 |     });
173 |   });
174 | 
175 |   describe("A describe with init blocks and before blocks", function() {
176 |     var initAndBeforeInvocations;
177 | 
178 |     init(function() {
179 |       initAndBeforeInvocations = ["outer init"];
180 |     });
181 | 
182 |     before(function() {
183 |       initAndBeforeInvocations.push("outer before");
184 |     });
185 | 
186 |     describe("a nested describe with init and before blocks", function() {
187 |       init(function() {
188 |         initAndBeforeInvocations.push("inner init");
189 |       });
190 | 
191 |       before(function() {
192 |         initAndBeforeInvocations.push("inner before");
193 |       });
194 | 
195 |       it("invokes all the init blocks, then all the before blocks, then this example", function() {
196 |         expect(initAndBeforeInvocations).to(equal, ["outer init", "inner init", "outer before", "inner before"]);
197 |       });
198 |     });
199 |   });
200 | 
201 |   describe("A describe with scenarios", function() {
202 |     var exampleRunCount = 0;
203 |     var nestedDescribeBeforeRunCount = 0;
204 |     var scenarioNumber;
205 | 
206 |     scenario("1, defined before example", function() {
207 |       before(function() {
208 |         scenarioNumber = 1;
209 |       });
210 |     });
211 | 
212 |     it("runs this example within every scenario", function() {
213 |       exampleRunCount++;
214 |       expect(scenarioNumber).to(equal, exampleRunCount);
215 |     });
216 | 
217 |     scenario("2, defined after example", function() {
218 |       before(function() {
219 |         scenarioNumber = 2;
220 |       });
221 |     });
222 | 
223 |     scenario("3, defined after example", function() {
224 |       before(function() {
225 |         scenarioNumber = 3;
226 |       });
227 |     });
228 | 
229 |     describe("should be copied within each scenario", function() {
230 |       before(function() {
231 |         nestedDescribeBeforeRunCount++;
232 |         expect(scenarioNumber).to(equal, nestedDescribeBeforeRunCount);
233 |       })
234 | 
235 |       it("runs this example within its describe in every scenario", function() {
236 |         expect(scenarioNumber).to(equal, nestedDescribeBeforeRunCount);
237 |       });
238 |     });
239 |   });
240 | }});
241 | 


--------------------------------------------------------------------------------
/client/spec/interface/runner_spec.js:
--------------------------------------------------------------------------------
  1 | Screw.Unit(function(c) { with(c) {
  2 |   describe("Screw.Interface.Runner", function() {
  3 |     var root, childDescription1, childDescription1Example, childDescription2, view, show;
  4 | 
  5 |     before(function() {
  6 |       Screw.Monarch.Queue.synchronous = true;
  7 | 
  8 |       root = new Screw.Description("all specs");
  9 |       childDescription1 = new Screw.Description("child description 1");
 10 |       childDescription2 = new Screw.Description("child description 2");
 11 |       childDescription1Example = new Screw.Example("child description 1 example", function() {  });
 12 |       childDescription1.addExample(childDescription1Example);
 13 | 
 14 |       root.addDescription(childDescription1);
 15 |       root.addDescription(childDescription2);
 16 | 
 17 |       view = Screw.Interface.Runner.toView({root: root, buildImmediately: true, show: show});
 18 |       mock(Screw.jQuery, 'cookie');
 19 |       mock(Screw.jQuery, 'ajax');
 20 |     });
 21 |     
 22 |     after(function() {
 23 |       Screw.Monarch.Queue.synchronous = false;
 24 |     });
 25 | 
 26 |     init(function() {
 27 |       show = 'all'
 28 |     });
 29 | 
 30 | 
 31 |     describe(".runPaths", function() {
 32 |       it("returns the string following # parsed as JSON", function() {
 33 |         mock(Screw.Interface, 'getLocation', function() {
 34 |           return {
 35 |             href: "http://localhost:8080/specs?[[1], [2,0,0]]"
 36 |           }
 37 |         });
 38 |         expect(Screw.Interface.Runner.runPaths()).to(equal, [[1], [2,0,0]]);
 39 |       });
 40 |     });
 41 | 
 42 |     describe(".toView", function() {
 43 |       context("when passed the show: 'all' option", function() {
 44 |         it("renders itself with the 'showAll' class and not the 'showFailed' class", function() {
 45 |           expect(view.hasClass("showAll")).to(beTrue);
 46 |           expect(view.hasClass("showFailed")).to(beFalse);
 47 |         });
 48 |       });
 49 | 
 50 |       context("when passed the show: 'failed' option'", function() {
 51 |         init(function() {
 52 |           show = 'failed';
 53 |         });
 54 | 
 55 |         it("renders itself with the 'showFailed' class and not the 'showAll' class", function() {
 56 |           expect(view.hasClass("showFailed")).to(beTrue);
 57 |           expect(view.hasClass("showAll")).to(beFalse);
 58 |         });
 59 |       });
 60 |     });
 61 | 
 62 | 
 63 |     describe("#run", function() {
 64 |       context("when passed an array of paths as the runPaths: option", function() {
 65 |         it("calls addToQueue on the examples or descriptions corresponding to the paths, then starts the queue", function() {
 66 |           mock(childDescription1, 'addToQueue');
 67 |           mock(childDescription1Example, 'addToQueue');
 68 |           mock(childDescription2, 'addToQueue');
 69 | 
 70 |           view.run([[0, 0], [1]]);
 71 | 
 72 |           expect(childDescription1.addToQueue).toNot(haveBeenCalled);
 73 |           expect(childDescription1Example.addToQueue).to(haveBeenCalled, once);
 74 |           expect(childDescription2.addToQueue).to(haveBeenCalled, once);
 75 |         });
 76 |       });
 77 | 
 78 |       context("when passed no runPaths", function() {
 79 |         it("calls #addToQueue on root", function() {
 80 |           mock(root, 'addToQueue');
 81 |           view.run();
 82 |           expect(root.addToQueue).to(haveBeenCalled);
 83 |         });
 84 |       });
 85 |     });
 86 | 
 87 |     describe("buttons", function() {
 88 |       var passingExample, failingExample1, failingExample2, example1;
 89 |       before(function() {
 90 | 
 91 |         passingExample = new Screw.Example("passing example 1", function() {
 92 |         });
 93 |         failingExample1 = new Screw.Example("failing example 1", function() {
 94 |           throw new Error();
 95 |         });
 96 |         failingExample2 = new Screw.Example("failing example 1", function() {
 97 |           throw new Error();
 98 |         });
 99 |         childDescription1.addExample(passingExample);
100 |         childDescription1.addExample(failingExample1);
101 |         childDescription1.addExample(failingExample2);
102 |         view = Screw.Interface.Runner.toView({root: root, buildImmediately: true});
103 |       });
104 | 
105 |       describe("when the 'Show Failed' button is clicked", function() {
106 |         before(function() {
107 |           Screw.$('div#testContent').html(view);
108 |         });
109 | 
110 |         after(function() {
111 |           Screw.$("div#testContent").html("");
112 |         });
113 | 
114 |         it("applies the 'showFailed' class to the root element of the view", function() {
115 |           expect(view.hasClass('showFailed')).to(beFalse);
116 |           view.find("button#showFailed").click();
117 |           expect(view.hasClass('showFailed')).to(beTrue);
118 |         });
119 | 
120 |         it("removes the 'showAll' class from the root element of the view", function() {
121 |           view.addClass("showAll");
122 |           view.find("button#showFailed").click();
123 |           expect(view.hasClass('showAll')).to(beFalse);
124 |         });
125 | 
126 |         it("stores a cookie to retain the setting across refreshes", function() {
127 |           view.find("button#showFailed").click();
128 |           expect(Screw.jQuery.cookie).to(haveBeenCalled, withArgs("_screwUnit_show", "failed", {path: "/"}));
129 |         });
130 |       });
131 | 
132 |       describe("when the 'Show All' button is clicked", function() {
133 |         before(function() {
134 |           Screw.$('div#testContent').html(view);
135 |         });
136 | 
137 |         after(function() {
138 |           Screw.$("div#testContent").html("");
139 |         });
140 | 
141 |         it("applies the 'showAll' class to the root element of the view", function() {
142 |           view.removeClass("showAll");
143 |           expect(view.hasClass('showAll')).to(beFalse);
144 |           view.find("button#showAll").click();
145 |           expect(view.hasClass('showAll')).to(beTrue);
146 |         });
147 | 
148 |         it("removes the 'showAll' class from the root element of the view", function() {
149 |           view.addClass("showFailed");
150 |           view.find("button#showAll").click();
151 |           expect(view.hasClass('showFailed')).to(beFalse);
152 |         });
153 | 
154 |         it("stores a cookie to retain the setting across refreshes", function() {
155 |           view.find("button#showAll").click();
156 |           expect(Screw.jQuery.cookie).to(haveBeenCalled, withArgs("_screwUnit_show", "all", {path: "/"}));
157 |         });
158 |       });
159 | 
160 |       describe("when the Rerun All button is clicked", function() {
161 |         it("sets window.location to the current path, without any path specifier", function() {
162 |           mock(Screw.Interface, 'getLocation', function() {
163 |             return { href: "http://localhost:8080/specs?[[0]]"};
164 |           });
165 | 
166 |           mock(Screw.Interface, 'setLocation');
167 |           view.find("button#rerunAll").click();
168 |           expect(Screw.Interface.setLocation).to(haveBeenCalled, withArgs("http://localhost:8080/specs"));
169 |         });
170 |       });
171 | 
172 |       describe("when the Rerun Failed button is clicked", function() {
173 |         it("sets window.location to the paths of all currently failing examples", function() {
174 |           view.run();
175 |           mock(Screw.Interface, 'getLocation', function() {
176 |             return { href: "http://localhost:8080/specs?[[0]]"};
177 |           });
178 |           mock(Screw.Interface, 'setLocation');
179 | 
180 |           view.find("button#rerunFailed").click();
181 | 
182 |           expect(Screw.Interface.setLocation).to(haveBeenCalled);
183 |           expect(Screw.Interface.setLocation).to(haveBeenCalled, withArgs("http://localhost:8080/specs?" + JSON.stringify([failingExample1.path(), failingExample2.path()])));
184 |         });
185 |       });
186 |     });
187 | 
188 |     describe("#exampleCompleted", function() {
189 |       describe("when the examples are completed", function() {
190 |         before(function() {
191 |           view.completedExampleCount = 0;
192 |           view.totalExamples = 1;
193 |         });
194 | 
195 |         describe("when there were failures", function() {
196 |           before(function() {
197 |             mock(Screw.rootDescription(), "failedExamples", function() { return [1]; });
198 |           });
199 | 
200 |           it("adds the .failed class to the root description", function() {
201 |             view.exampleCompleted();
202 | 
203 |             expect(Screw.rootDescription().failedExamples).to(haveBeenCalled, once);
204 |             expect(view.find("ul.descriptions").hasClass("failed")).to(beTrue);
205 |           });
206 |         });
207 | 
208 |         describe("when all examples passed", function() {
209 |           before(function() {
210 |             mock(Screw.rootDescription(), "failedExamples", function() { return []; });
211 |           });
212 | 
213 |           it("adds the .passed class to the root description", function() {
214 |             view.exampleCompleted();
215 |             expect(Screw.rootDescription().failedExamples).to(haveBeenCalled, once);
216 |             expect(view.find("ul.descriptions").hasClass("passed")).to(beTrue);
217 |           });
218 |         });
219 |       });
220 |     });
221 |   });
222 | }});
223 | 


--------------------------------------------------------------------------------
/client/lib/screw/matchers.js:
--------------------------------------------------------------------------------
  1 | (function(Screw, Monarch) {
  2 | 
  3 | Monarch.module("Screw.Matchers", {
  4 |   eq: {
  5 |     match: function(expected, actual) {
  6 |       return expected === actual;
  7 |     },
  8 | 
  9 |     failureMessage: function(expected, actual, not) {
 10 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not === ' : ' to === ') + Screw.$.print(expected);
 11 |     }
 12 |   },
 13 | 
 14 |   equal: {
 15 |     match: function(expected, actual) {
 16 |       if (_ && _.isEqual) return _.isEqual(expected, actual);
 17 | 
 18 |       if(expected == actual) return true;
 19 |       if(actual == undefined) return false;
 20 | 
 21 |       if (expected instanceof Array) {
 22 |         if (! (actual instanceof Array)) return false;
 23 |         for (var i = 0; i < actual.length; i++)
 24 |           if (!Screw.Matchers.equal.match(expected[i], actual[i])) return false;
 25 |         return actual.length == expected.length;
 26 |       } else if (expected instanceof Object) {
 27 |         for (var key in expected)
 28 |           if (!this.match(expected[key], actual[key])) return false;
 29 |         for (var key in actual)
 30 |           if (!this.match(actual[key], expected[key])) return false;
 31 |         return true;
 32 |       }
 33 |       return false;
 34 |     },
 35 | 
 36 |     failureMessage: function(expected, actual, not) {
 37 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not equal ' : ' to equal ') + Screw.$.print(expected);
 38 |     }
 39 |   },
 40 | 
 41 |   beGt: {
 42 |     match: function(expected, actual) {
 43 |       return actual > expected;
 44 |     },
 45 | 
 46 |     failureMessage: function(expected, actual, not) {
 47 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not ' : ' to ') + 'be greater than ' + Screw.$.print(expected);
 48 |     }
 49 |   },
 50 | 
 51 |   beGte: {
 52 |     match: function(expected, actual) {
 53 |       return actual >= expected;
 54 |     },
 55 | 
 56 |     failureMessage: function(expected, actual, not) {
 57 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not ' : ' to ') + 'be greater than or equal to ' + Screw.$.print(expected);
 58 |     }
 59 |   },
 60 | 
 61 |   beLt: {
 62 |     match: function(expected, actual) {
 63 |       return actual < expected;
 64 |     },
 65 | 
 66 |     failureMessage: function(expected, actual, not) {
 67 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not ' : ' to ') + 'be less than ' + Screw.$.print(expected);
 68 |     }
 69 |   },
 70 | 
 71 |   beLte: {
 72 |     match: function(expected, actual) {
 73 |       return actual <= expected;
 74 |     },
 75 | 
 76 |     failureMessage: function(expected, actual, not) {
 77 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not ' : ' to ') + 'be less than or equal to ' + Screw.$.print(expected);
 78 |     }
 79 |   },
 80 | 
 81 |   match: {
 82 |     match: function(expected, actual) {
 83 |       if (expected.constructor == RegExp)
 84 |         return expected.exec(actual.toString());
 85 |       else
 86 |         return actual.indexOf(expected) > -1;
 87 |     },
 88 | 
 89 |     failureMessage: function(expected, actual, not) {
 90 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not match ' : ' to match ') + Screw.$.print(expected);
 91 |     }
 92 |   },
 93 | 
 94 |   beBlank: {
 95 |     match: function(expected, actual) {
 96 |       if (actual == undefined) return true;
 97 |       if (typeof(actual) == "string") actual = actual.replace(/^\s*(.*?)\s*$/, "$1");
 98 |       return Screw.Matchers.beEmpty.match(expected, actual);
 99 |     },
100 | 
101 |     failureMessage: function(expected, actual, not) {
102 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not be blank' : ' to be blank');
103 |     }
104 |   },
105 | 
106 |   beEmpty: {
107 |     match: function(expected, actual) {
108 |       if (actual.length == undefined) throw(new Error(actual.toString() + " does not respond to length"));
109 | 
110 |       return actual.length == 0;
111 |     },
112 | 
113 |     failureMessage: function(expected, actual, not) {
114 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not be empty' : ' to be empty');
115 |     }
116 |   },
117 | 
118 |   haveLength: {
119 |     match: function(expected, actual) {
120 |       if (actual.length == undefined) throw(new Error(actual.toString() + " does not respond to length"));
121 | 
122 |       return actual.length == expected;
123 |     },
124 | 
125 |     failureMessage: function(expected, actual, not) {
126 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not' : ' to') + ' have length ' + expected;
127 |     }
128 |   },
129 | 
130 |   beAnInstanceOf: {
131 |     match: function(expected, actual) {
132 |       return actual instanceof eval(expected);
133 |     },
134 | 
135 |     failureMessage: function(expected, actual, not) {
136 |       return 'expected ' + typeof actual + (not ? ' not' : '') + ' be an instance of ' + expected;
137 |     }
138 |   },
139 | 
140 |   beNull: {
141 |     match: function(expected, actual) {
142 |       return actual == null;
143 |     },
144 | 
145 |     failureMessage: function(expected, actual, not) {
146 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not be null' : ' to be null');
147 |     }
148 |   },
149 | 
150 |   beUndefined: {
151 |     match: function(expected, actual) {
152 |       return actual == undefined;
153 |     },
154 | 
155 |     failureMessage: function(expected, actual, not) {
156 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not be undefined' : ' to be undefined');
157 |     }
158 |   },
159 | 
160 |   beTrue: {
161 |     match: function(expected, actual) {
162 |       return actual;
163 |     },
164 | 
165 |     failureMessage: function(expected, actual, not) {
166 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not be true' : ' to be true');
167 |     }
168 |   },
169 | 
170 |   beFalse: {
171 |     match: function(expected, actual) {
172 |       return !actual;
173 |     },
174 | 
175 |     failureMessage: function(expected, actual, not) {
176 |       return 'expected ' + Screw.$.print(actual) + (not ? ' to not be false' : ' to be false');
177 |     }
178 |   },
179 | 
180 |   haveBeenCalled: {
181 |     match: function(expectation, mockFunction) {
182 |       if (expectation) {
183 |         return this.matchWithExpectation(expectation, mockFunction);
184 |       } else {
185 |         return mockFunction.callCount > 0;
186 |       }
187 |     },
188 | 
189 |     matchWithExpectation: function(expectation, mockFunction) {
190 |       if (expectation._withArgs_) {
191 |         if (mockFunction.callCount == 0 ) return false;
192 |         return Screw.Matchers.equal.match(expectation.arguments, mockFunction.mostRecentArgs);
193 |       } else if (expectation._onObject_) {
194 |         return Screw.Matchers.equal.match(expectation.object, mockFunction.mostRecentThisValue);
195 |       } else if (typeof expectation == "number") {
196 |         return mockFunction.callCount == expectation;
197 |       } else {
198 |         throw new Error("unrecognized expectation argument for mock function: " + expectation);
199 |       }
200 |     },
201 | 
202 |     errorMessageExpectationFragment: function(expectation, not) {
203 |       if (!expectation) {
204 |         if (not) {
205 |           return "";
206 |         } else {
207 |           return " at least once";
208 |         }
209 |       } else {
210 |         if (expectation._withArgs_) {
211 |           return " with arguments " + Screw.$.print(expectation.arguments);
212 |         } else if (expectation._onObject_) {
213 |           return " on object " + Screw.$.print(expectation.object);
214 |         } else {
215 |           return " " + expectation + " time" + ((expectation == 1) ? "" : "s");
216 |         }
217 |       }
218 |     },
219 | 
220 |     errorMessageActualFragment: function(expected, actual, not) {
221 |       if (expected && expected._withArgs_) {
222 |         if (actual.callCount === 0) {
223 |           return "0 times";
224 |         } else {
225 |           return "with arguments " + Screw.$.print(actual.mostRecentArgs);
226 |         }
227 |       } else if (expected && expected._onObject_) {
228 |         return "on object " + Screw.$.print(actual.mostRecentThisValue);
229 |       } else {
230 |         return actual.callCount + " time" + ((actual.callCount == 1) ? "" : "s");
231 |       }
232 |     },
233 | 
234 |     failureMessage: function(expected, actual, not) {
235 |       var message;
236 |       if (not) {
237 |         message = 'expected ' + actual.functionName + ' to have not been called' + this.errorMessageExpectationFragment(expected, not);
238 |       } else {
239 |         message = 'expected ' + actual.functionName + ' to have been called' + this.errorMessageExpectationFragment(expected, not);
240 |       }
241 |       message += ' but it was called ' + this.errorMessageActualFragment(expected, actual, not);
242 |       return message;
243 |     }
244 |   },
245 | 
246 |   once: 1,
247 |   twice: 2,
248 |   thrice: 3,
249 | 
250 |   withArgs: function() {
251 |     return {
252 |       _withArgs_: true,
253 |       arguments: Array.prototype.slice.call(arguments)
254 |     };
255 |   },
256 | 
257 |   onObject: function(object) {
258 |     return {
259 |       _onObject_: true,
260 |       object: object
261 |     };
262 |   },
263 | 
264 |   contain: {
265 |     match: function(expected, actual) {
266 |       for(var i = 0; i < actual.length; i++) {
267 |         if (actual[i] == expected) return true;
268 |       }
269 |       return false;
270 |     },
271 | 
272 |     failureMessage: function(expected, actual, not) {
273 |       if (not) {
274 |         return "expected " + Screw.$.print(actual) + " to not contain " + Screw.$.print(expected) + ", but it did";
275 |       } else {
276 |         return "expected " + Screw.$.print(actual) + " to contain " + Screw.$.print(expected) + ", but it did not";
277 |       }
278 |     }
279 |   },
280 | 
281 |   throwException: {
282 |     match: function(expected, actual) {
283 |       var threwException;
284 |       try {
285 |         actual();
286 |         threwException = false;
287 |       } catch(e) {
288 |         threwException = true;
289 |       }
290 |       return threwException;
291 |     },
292 | 
293 |     failureMessage: function(expected, actual, not) {
294 |       if (not) {
295 |         return "expected function to not throw an exception, but it did";
296 |       } else {
297 |         return "expected function to throw an exception, but it did not";
298 |       }
299 |     }
300 |   }
301 | });
302 | 
303 | })(Screw, Monarch);
304 | 


--------------------------------------------------------------------------------
/README.markdown:
--------------------------------------------------------------------------------
  1 | Screw.Unit is a Behavior-Driven Testing Framework for Javascript. It features nested describes. Its goals are to provide:
  2 | 
  3 | * a DSL for elegant, readable, organized specs;
  4 | * an interactive runner that can execute focused specs and describes; 
  5 | * and brief, extensible source-code.
  6 | 
  7 | # What it is
  8 | 
  9 | ![Test Runner](http://s3.amazonaws.com/assets.pivotallabs.com/87/original/runner.png)
 10 | 
 11 | The testing language is closure-based. Consider,
 12 | 
 13 |     describe("Matchers", function() {
 14 |       it("invokes the provided matcher on a call to expect", function() {
 15 |         expect(true).to(equal, true);
 16 |         expect(true).to_not(equal, false);
 17 |       });
 18 |     });
 19 | 
 20 | A key feature of Screw.Unit are nested `describes` and the cascading `before` (and `after`) behavior that entails:
 21 | 
 22 |     describe("a nested describe", function() {
 23 |       var invocations = [];
 24 |       
 25 |       before(function() {
 26 |         invocations.push("before");
 27 |       });
 28 | 
 29 |       describe("a doubly nested describe", function() {
 30 |         before(function() {
 31 |           invocations.push('inner before');
 32 |         });
 33 | 
 34 |         it("runs befores in all ancestors prior to an it", function() {
 35 |           expect(invocations).to(equal, ["before", "inner before"]);
 36 |         });
 37 |       });
 38 |     });
 39 | 
 40 | # The Runner
 41 | 
 42 | The Screw.Unit runner is pretty fancy, supporting focused `describes` and focused `its`:
 43 | 
 44 | ![Focused Runner](http://s3.amazonaws.com/assets.pivotallabs.com/86/original/focused.png)
 45 | 
 46 | Click on a `describe` or `it` to run just those tests.
 47 | 
 48 | # Global Befores and Afters
 49 | 
 50 | A global `before` is a `before` block run before all tests in a test suite, regardless of their nesting. This is often useful to reset global variables, or blank-out DOM nodes before each test is run. Put this at the top of the your suite file or in your spec helper.
 51 | 
 52 |     Screw.Unit(function(c) { with(c) {
 53 |       before(function() { ... });
 54 |     }});
 55 |     
 56 | Note that you can have any number of `Screw.Unit(...)` blocks in one file. Thus, you can have multiple global `befores` and `afters`.
 57 | 
 58 | # Custom Matchers
 59 | 
 60 | A custom matcher is a custom assertion specifically tailored to your application. These are helpful in increasing the readability and declarativity of your tests. To create a custom matcher, fill in the blanks for this code:
 61 | 
 62 |     Screw.Matchers["be_even"] = {
 63 |       match: function(expected, actual) {
 64 |         return actual % 2 == 0;
 65 |       },
 66 |       failure_message: function(expected, actual, not) {
 67 |         return 'expected ' + $.print(actual) + (not ? ' not' : '') + ' to be even';
 68 |       }
 69 |     }
 70 | 
 71 | You can invoke this matcher as follows: `expect(2).to(be_even)`.
 72 | 
 73 | # The Anatomy of Test Infrastructure
 74 | 
 75 | Typical test infrastructure spans multiple files:
 76 | 
 77 | * A `suite.html` file that has the necessary html, script tags, and link tags, to include your source code as well as the test infrastructure.
 78 | * A `spec_helper.js` file with global `before` and `after` blocks.
 79 | * A set of custom matchers.
 80 | * Your individual tests.
 81 | 
 82 | The file structure will typically look like:
 83 | 
 84 |     spec/
 85 |       suite.html
 86 |       spec_helper.js
 87 |       matchers/
 88 |         a_matcher.js
 89 |         another_matcher.js
 90 |       models/
 91 |         a_spec.js
 92 |         another_spec.js
 93 |       views/
 94 |         yet_another_spec.js
 95 | 
 96 | The `models` and `views` directories are here only for comparison. As a general rule, mirror the file structure of your source code in your spec directory. For example, if you have an MVC application and you organize your source code into `models`, `views`, and `controllers` directories, have parallel directories in your spec/ directory, with tests for your models, views, and controllers in their respective directories.
 97 | 
 98 | # Writing Good Tests
 99 | 
100 | A great test maximizes these features:
101 | 
102 | * it provides **documentation**, explaining the intended functioning of the system as well as how the source code works;
103 | * it supports **ongoing development**, as you bit-by-bit write a failing test and make it pass;
104 | * it supports later **refactoring** and **prevents regression** as you add other features;
105 | * and it **requires little modification** as the implementation of the system changes, especially changes to unrelated code.
106 | 
107 | This section focuses principally on tests as documentation. **To provide documentation, as well as support future modification, a test should be readable and well organized.** Here are some recommendations on how to do just that.
108 | 
109 | ## Use Nested Describes to Express Context
110 | 
111 | Often, when you test a system (a function, an object), it behaves differently in different contexts. Use **nested** describes liberally to express the context under which you make an assertion.
112 | 
113 |     describe("Caller#prioritize", function() {
114 |       describe("when there are two callers in the queue", function() {
115 |         describe("and one caller has been waiting longer than another", function() {
116 |           ...
117 |         });
118 |       });
119 |     });
120 | 
121 | In addition to using nested describes to express context, use them to organize tests by the structural properties of your source code and programming language. In Javascript this is typically prototype and function. A parent describe for a prototype contains nested describes for each of its methods. If you have cross-cutting concerns (e.g., related behavior that spans across methods or prototypes), use a describe to group them conceptually.
122 | 
123 |     describe("Car", function() {
124 |       describe("#start", function() {
125 |       });
126 |       
127 |       describe("#stop", function() {
128 |       });
129 |       
130 |       describe("callbacks", function() {
131 |         describe("after_purchase", function() {
132 |         });
133 |       });
134 |       
135 |       describe("logging", function() {
136 |       });
137 |     });
138 | 
139 | In this example, one parent `describe` is used for all `Car` behavior. There is a describe for each method. Finally, cross-cutting concerns like callbacks and logging are grouped because of their conceptual affinity.
140 | 
141 | # Test Size
142 | 
143 | Individual tests should be short and sweet. It is sometimes recommended to make only one assertion per test:
144 | 
145 |     it("chooses the caller who has been waiting the longest", function() {
146 |       expect(Caller.prioritize()).to(equal, caller_waiting_the_longest);
147 |     });
148 | 
149 | According to some, the ideal test is one line of code. In practice, it may be excessive to divide your tests to be this small. At ten lines of code (or more), a test is difficult to read quickly. Be pragmatic, bearing in mind the aims of testing.
150 | 
151 | Although one assertion per test is a good rule of thumb, feel free to violate the rule if equal clarity and better terseness is achievable:
152 | 
153 |     it("returns the string representation of the boolean", function() {
154 |       expect($.print(true)).to(equal, 'true');
155 |       expect($.print(false)).to(equal, 'false');
156 |     });
157 | 
158 | Two tests would be overkill in this example.
159 | 
160 | ## Variable Naming
161 | 
162 | Name variables descriptively, especially ones that will become expected values in assertions. `caller_waiting_the_longest` is better than `c1`.
163 | 
164 | ## Dividing code between tests and `befores`
165 | 
166 | If there is only one line of setup and it is used in only one test, it may be better to include the setup in the test itself:
167 | 
168 |     it("decrements the man's luck by 5", function() {
169 |       var man = new Man({luck: 5});
170 |       
171 |       cat.cross_path(man);
172 |       expect(man.luck()).to(equal, 0);
173 |     });
174 | 
175 | But in general, it's nice to keep setup code in `before` blocks, especially if the setup can be shared across tests.
176 | 
177 |     describe('Man', function() {
178 |       var man;
179 |       before(function() {
180 |         man = new Man({luck: 5});
181 |       });
182 |   
183 |       describe('#decrement_luck', function() {
184 |         it("decrements the luck field by the given amount", function() {
185 |           man.decrement_luck(3);
186 |           expect(man.luck()).to(equal, 2)
187 |         });
188 |       });
189 |       ...
190 |     });
191 | 
192 | ## Preconditions
193 | 
194 | It is ideal, if there is any chance that your preconditions are non-obvious, to make precondition asserts in your test. The last example, were it more complicated, might be better written:
195 | 
196 |     it("decrements the luck field by the given amount", function() {
197 |       expect(man.luck()).to(equal, 5);
198 | 
199 |       man.decrement_luck(3);
200 |       expect(man.luck()).to(equal, 2)
201 |     });
202 | 
203 | Whitespace, as seen here, can be helpful in distinguishing setup and preconditions from the system under test (SUT) and its assertions. It is nice to be consistent in your use of whitespace (e.g., "always follow a group of preconditions by a newline"). But it is better to use whitespace as makes the most sense given the context. As with everything in life, do it consciously and deliberately, but change your mind frequently.
204 | 
205 | ## Behavioral Testing
206 | 
207 | Behavioral testing, that is, asserting that certain functions are called rather than certain values returned, is best done with closures. The dynamic nature of JavaScript makes mocking frameworks mostly unnecessary.
208 | 
209 |     it("invokes #decrement_luck", function() {
210 |       var decrement_luck_was_called = false;
211 |       man.decrement_luck = function(amount) {
212 |         decrement_luck_was_called = true;
213 |       });
214 |       
215 |       cat.cross_path(man);
216 |       expect(decrement_luck_was_called).to(equal, true);
217 |     });
218 | 
219 | # How to Test the DOM
220 | 
221 | The simplest way to test the DOM is to have a special DOM node in your `suite.html` file. Have all tests insert nodes into this node; have a global `before` reset the node between tests.
222 | 
223 | In `suite.html`:
224 | 
225 |     <div id="dom_test"></div>
226 | 
227 | In `spec_helper.js`:
228 | 
229 |     Screw.Unit(function() {
230 |       before(function() {
231 |         document.getElementById('dom_test').innerHTML = ''; // but use your favorite JS library here.
232 |       });
233 |     });
234 |     
235 | In `some_spec.js`:
236 | 
237 |     describe("something that manipulates the DOM", function() {
238 |       it("is effortless to test!", function() {
239 |         var dom_test = document.getElementById('dom_test');
240 |         dom_test.innerHTML = 'awesome';
241 |         expect(dom_test.innerHTML).to(equal, 'awesome');
242 |       });
243 |     });
244 | 
245 | A Javascript library like jQuery, Prototype, or YUI is a essential for testing events.
246 | 
247 | # Implementation Details
248 | 
249 | Screw.Unit is implemented using some fancy metaprogramming learned from the formidable Yehuda Katz. This allows the `describe` and `it` functions to not pollute the global namespace. Essentially, we take the source code of your test and wrap it in a with block which provides a new scope:
250 | 
251 |     var contents = fn.toString().match(/^[^\{]*{((.*\n*)*)}/m)[1];
252 |     var fn = new Function("matchers", "specifications",
253 |       "with (specifications) { with (matchers) { " + contents + " } }"
254 |     );
255 | 
256 |     fn.call(this, Screw.Matchers, Screw.Specifications);
257 | 
258 | Furthermore, Screw.Unit is implemented using the **Concrete Javascript** style, which is made possible by the [Effen plugin](http://github.com/nkallen/effen/tree/master) and jQuery. Concrete Javascript is an alternative to MVC. In Concrete Javascript, DOM objects serve as the model and view simultaneously. The DOM is constructed using semantic (and visual) markup, and behaviors are attached directly to DOM elements. For example,
259 | 
260 |     $('.describe').fn({
261 |       parent: function() {
262 |         return $(this).parent('.describes').parent('.describe');
263 |       },
264 |       run: function() {
265 |         $(this).children('.its').children('.it').fn('run');
266 |         $(this).children('.describes').children('.describe').fn('run');
267 |       },
268 |     });
269 | 
270 | Here two methods (`#parent` and `#run`) are attached directly to DOM elements that have class `describe`. To invoke one of these methods, simply:
271 | 
272 |     $('.describe').fn('run');
273 | 
274 | Bind behaviors by passing a hash (see the previous example). Using CSS3 selectors and cascading to attach behaviors provides interesting kind of multiple inheritance and polymorphism:
275 | 
276 |     $('.describe, .it').fn({...}); // applies to both describe and its
277 |     $('.describe .describe').fn({...}); // applies to nested describes only
278 | 
279 | # Extensibility
280 | 
281 | Screw.Unit is designed from the ground-up to be extensible. For example, to add custom logging, simply subscribe to certain events:
282 | 
283 |     $('.it')
284 |       .bind('enqueued', function() {...})
285 |       .bind('running', function() {...})
286 |       .bind('passed', function() {...})
287 |       .bind('failed', function(e, reason) {...})
288 | 
289 | There are also events for the `loading` and `loaded` test code code, as well as just `before` and just `after` all tests are run:
290 | 
291 |     $(Screw)
292 |       .bind('loading', function() {...})
293 |       .bind('loaded', function() {...})
294 |       .bind('before', function() {...})
295 |       .bind('after', function() {...})
296 | 
297 | # Download
298 | 
299 | You can [download the source](http://github.com/nkallen/screw-unit/tree/master) from Github. There is are plenty of examples in the distribution.
300 | 
301 | # Thanks to
302 | 
303 | * Nathan Sobo
304 | * Yehuda Katz
305 | * Brian Takita
306 | * Aman Gupta
307 | * Tim Connor


--------------------------------------------------------------------------------
/client/spec/description_spec.js:
--------------------------------------------------------------------------------
  1 | Screw.Unit(function(c) { with(c) {
  2 |   describe("Screw.Description", function() {
  3 |     var description, name, examples;
  4 | 
  5 |     before(function() {
  6 |       Screw.Monarch.Queue.synchronous = true;
  7 |       name = "description"
  8 |       description = new Screw.Description(name);
  9 |       examples = [];
 10 |       examples.push(new Screw.Example("example 1", function() {}));
 11 |       examples.push(new Screw.Example("example 2", function() {}));
 12 |       Screw.each(examples, function() {
 13 |         description.addExample(this);
 14 |       });
 15 |     });
 16 |     
 17 |     after(function() {
 18 |       Screw.Monarch.Queue.synchronous = false;
 19 |     });
 20 | 
 21 |     describe("#initialize", function() {
 22 |       it("assigns #name", function() {
 23 |         expect(description.name).to(equal, name);
 24 |       });
 25 |     });
 26 | 
 27 |     describe("#clone", function() {
 28 |       it("makes a copy of the Description and all its children, setting up to propagate onExampleCompleted events from its children to a new node", function() {
 29 |         description.addDescription(new Screw.Description("child description"));
 30 |         description.childDescriptions[0].addExample(new Screw.Example("grandchild example", function() {}));
 31 | 
 32 |         var originalExampleCompletedCallback = mockFunction("original example completed callback");
 33 |         var cloneExampleCompletedCallback = mockFunction("clone example completed callback");
 34 | 
 35 |         description.onExampleCompleted(originalExampleCompletedCallback);
 36 |         var clone = description.clone();
 37 |         clone.onExampleCompleted(cloneExampleCompletedCallback)
 38 | 
 39 |         clone.examples[0].run();
 40 |         expect(originalExampleCompletedCallback).toNot(haveBeenCalled);
 41 |         expect(cloneExampleCompletedCallback).to(haveBeenCalled);
 42 | 
 43 |         originalExampleCompletedCallback.clear();
 44 |         cloneExampleCompletedCallback.clear();
 45 | 
 46 |         clone.childDescriptions[0].examples[0].run();
 47 |         expect(originalExampleCompletedCallback).toNot(haveBeenCalled);
 48 |         expect(cloneExampleCompletedCallback).to(haveBeenCalled);
 49 |       });
 50 |     });
 51 | 
 52 | 
 53 |     describe("#addScenario", function() {
 54 |       function namesOf(array) {
 55 |         return Screw.map(array, function() {
 56 |           return this.name;
 57 |         });
 58 |       }
 59 | 
 60 |       it("causes all current and future Examples / Descriptions defined on the current Description to be defined on all scenario Descriptions instead", function() {
 61 |         var examplesOnParentBeforeScenarioAdded = Screw.$.extend([], description.examples);
 62 |         expect(examplesOnParentBeforeScenarioAdded).toNot(beEmpty);
 63 | 
 64 |         description.addDescription(new Screw.Description("child description"));
 65 |         var childDescriptionsOnParentBeforeScenarioAdded = Screw.$.extend([], description.childDescriptions);
 66 |         expect(childDescriptionsOnParentBeforeScenarioAdded).toNot(beEmpty);
 67 | 
 68 |         // adding the first scenario moves all examples and child descriptions to that scenario
 69 |         var scenario1 = new Screw.Description("scenario 1");
 70 |         description.addScenario(scenario1);
 71 | 
 72 |         expect(description.examples).to(beEmpty);
 73 |         expect(description.childDescriptions).to(equal, [scenario1]);
 74 |         expect(description.scenarioExamples).to(equal, examplesOnParentBeforeScenarioAdded);
 75 |         expect(description.scenarioChildDescriptions).to(equal, childDescriptionsOnParentBeforeScenarioAdded);
 76 | 
 77 |         expect(namesOf(scenario1.examples)).to(equal, namesOf(examplesOnParentBeforeScenarioAdded));
 78 |         expect(namesOf(scenario1.childDescriptions)).to(equal, namesOf(childDescriptionsOnParentBeforeScenarioAdded));
 79 | 
 80 |         // subsequent examples and descriptions are added to scenarios, not to the description itself
 81 |         var exampleAddedAfterScenario = new Screw.Example("example added after scenario", function() {});
 82 |         description.addExample(exampleAddedAfterScenario);
 83 | 
 84 |         var childDescriptionAddedAfterScenario = new Screw.Description("child description added after scenario");
 85 |         childDescriptionAddedAfterScenario.addExample(new Screw.Example("example in child description added after scenario", function() {}));
 86 |         description.addDescription(childDescriptionAddedAfterScenario);
 87 | 
 88 |         expect(description.examples).to(beEmpty);
 89 |         expect(description.childDescriptions).to(equal, [scenario1]);
 90 | 
 91 |         var expectedScenarioExamples = examplesOnParentBeforeScenarioAdded.concat([exampleAddedAfterScenario]);
 92 |         var expectedScenarioChildDescriptions = childDescriptionsOnParentBeforeScenarioAdded.concat([childDescriptionAddedAfterScenario]);
 93 |         expect(description.scenarioExamples).to(equal, expectedScenarioExamples);
 94 |         expect(description.scenarioChildDescriptions).to(equal, expectedScenarioChildDescriptions);
 95 |         expect(namesOf(scenario1.examples)).to(equal, namesOf(expectedScenarioExamples));
 96 |         expect(namesOf(scenario1.childDescriptions)).to(equal, namesOf(expectedScenarioChildDescriptions));
 97 | 
 98 |         // subsequent scenarios are added to childDescriptions, and inherit all examples and child descriptions already on other scenarios
 99 |         var scenario2 = new Screw.Description("scenario 2");
100 |         description.addScenario(scenario2);
101 | 
102 |         expect(description.childDescriptions).to(equal, [scenario1, scenario2]);
103 | 
104 |         expect(namesOf(scenario2.examples)).to(equal, namesOf(expectedScenarioExamples));
105 |         expect(namesOf(scenario2.childDescriptions)).to(equal, namesOf(expectedScenarioChildDescriptions));
106 |         expect(namesOf(scenario1.examples)).to(equal, namesOf(expectedScenarioExamples));
107 |         expect(namesOf(scenario1.childDescriptions)).to(equal, namesOf(expectedScenarioChildDescriptions));
108 | 
109 |         // copies of examples and descriptions copied to multiple scenarios have the correct parentDescription
110 |         expect(scenario1.examples[0].parentDescription).to(equal, scenario1);
111 |         expect(scenario1.childDescriptions[0].parentDescription).to(equal, scenario1);
112 |         expect(scenario2.examples[0].parentDescription).to(equal, scenario2);
113 |         expect(scenario2.childDescriptions[0].parentDescription).to(equal, scenario2);
114 | 
115 |         // correctly wires together onExampleCompletedEvents
116 |         var descriptionExampleCompletedCallback = mockFunction("description example completed callback")
117 |         var scenario1ExampleCompletedCallback = mockFunction("scenario 1 example completed callback");
118 |         var scenario2ExampleCompletedCallback = mockFunction("scenario 2 example completed callback");
119 | 
120 |         description.onExampleCompleted(descriptionExampleCompletedCallback);
121 |         scenario1.onExampleCompleted(scenario1ExampleCompletedCallback);
122 |         scenario2.onExampleCompleted(scenario2ExampleCompletedCallback);
123 |         
124 |         scenario1.examples[0].run();
125 |         expect(descriptionExampleCompletedCallback).to(haveBeenCalled, once);
126 |         expect(scenario1ExampleCompletedCallback).to(haveBeenCalled, once);
127 |         expect(scenario2ExampleCompletedCallback).toNot(haveBeenCalled);
128 | 
129 |         descriptionExampleCompletedCallback.clear();
130 |         scenario1ExampleCompletedCallback.clear();
131 |         scenario2ExampleCompletedCallback.clear();
132 | 
133 |         scenario2.childDescriptions[1].examples[0].run();
134 |         expect(scenario2ExampleCompletedCallback).to(haveBeenCalled, once);
135 |         expect(scenario1ExampleCompletedCallback).toNot(haveBeenCalled);
136 |         expect(descriptionExampleCompletedCallback).to(haveBeenCalled, once);
137 |       });
138 |     });
139 | 
140 |     describe("#run", function() {
141 |       it("calls #run on all examples and child descriptions", function() {
142 |         var childDescription = new Screw.Description("child description");
143 |         description.addDescription(childDescription);
144 | 
145 |         Screw.each(examples, function() {
146 |           mock(this, 'run');
147 |         })
148 |         mock(childDescription, 'run');
149 | 
150 |         description.run();
151 |         
152 |         Screw.each(examples, function() {
153 |           expect(this.run).to(haveBeenCalled);
154 |         })
155 |         expect(childDescription.run).to(haveBeenCalled);
156 |       });
157 |     });
158 | 
159 |     describe("#totalExamples", function() {
160 |       it("sums all examples it contains and all the examples for all descriptions nested within it", function() {
161 |         expect(description.totalExamples()).to(equal, examples.length);
162 | 
163 |         var nestedDescription = new Screw.Description("nested description with an example");
164 |         nestedDescription.addExample(new Screw.Example("example", function() {}));
165 |         description.addDescription(nestedDescription);
166 |         expect(description.totalExamples()).to(equal, examples.length + nestedDescription.totalExamples());
167 |       });
168 |     });
169 | 
170 |     describe("with failing examples", function() {
171 |       var rootDescription, childDescription, passingChildExample, failingChildExample, passingGrandchildExample, failingGrandchildExample;
172 |       before(function() {
173 |         rootDescription = new Screw.Description("root description")
174 |         childDescription = new Screw.Description("child description")
175 |         passingChildExample = new Screw.Example("passing child example", function() {});
176 |         passingGrandchildExample = new Screw.Example("passing grandchild example", function() {});
177 |         failingChildExample = new Screw.Example("failing child example", function() {
178 |           throw new Error("child error message");
179 |         })
180 |         failingGrandchildExample = new Screw.Example("failing grandchild example", function() {
181 |           throw new Error("grandchild error message");
182 |         })
183 | 
184 |         rootDescription.addDescription(childDescription);
185 |         rootDescription.addExample(passingChildExample);
186 |         rootDescription.addExample(failingChildExample);
187 |         childDescription.addExample(passingGrandchildExample);
188 |         childDescription.addExample(failingGrandchildExample);
189 |       });
190 | 
191 |       describe("#failedExamples", function() {
192 |         it("returns all failed Examples descending from this describe", function() {
193 |           rootDescription.run();
194 |           expect(rootDescription.failedExamples()).to(equal, [failingChildExample, failingGrandchildExample]);
195 |         });
196 |       });
197 | 
198 |       describe("#failureMessages", function() {
199 |         it("returns an array of the failure messages for all failing descendent examples", function() {
200 |           rootDescription.run();
201 |           expect(rootDescription.failureMessages()).to(equal, [failingChildExample.failureMessage,  failingGrandchildExample.failureMessage]);
202 |         });
203 |       });
204 |     });
205 | 
206 |     describe("callbacks registered via #onExampleCompleted", function() {
207 |       var onExampleCompletedArgs;
208 | 
209 |       before(function() {
210 |         onExampleCompletedArgs = [];
211 |         description.onExampleCompleted(function(example) {
212 |           onExampleCompletedArgs.push(example);
213 |         });
214 |       });
215 |       
216 |       describe("when an Example has completed", function() {
217 |         it("invokes registered callbacks", function() {
218 |           var example = examples[0];
219 |           example.run();
220 |           expect(onExampleCompletedArgs).to(equal, [example]);
221 |         });
222 |       });
223 | 
224 |       describe("when a descendant Example is completed", function() {
225 |         it("invokes registered callbacks", function() {
226 |           var childDescription = new Screw.Description("child description");
227 |           var grandchildExample = new Screw.Example("grandchild example", function() {});
228 |           childDescription.addExample(grandchildExample);
229 |           description.addDescription(childDescription);
230 |           grandchildExample.run();
231 |           expect(onExampleCompletedArgs).to(equal, [grandchildExample]);
232 |         });
233 |       });
234 |     });
235 | 
236 | 
237 |     describe("methods dealing with paths", function() {
238 |       var rootDescription, childDescription0, childDescription1, grandchildDescription10;
239 |       before(function() {
240 |         rootDescription = new Screw.Description("root description");
241 |         childDescription0 = new Screw.Description("child description 0");
242 |         childDescription1 = new Screw.Description("child description 1");
243 |         grandchildDescription10 = new Screw.Description("grandchild description 1 0");
244 |         rootDescription.addDescription(childDescription0)
245 |         rootDescription.addDescription(childDescription1);
246 |         childDescription1.addDescription(grandchildDescription10);
247 |       });
248 |       
249 |       describe("#path", function() {
250 |         context("when there is no #parentDescription", function() {
251 |           it("returns an empty Array", function() {
252 |             expect(description.path()).to(beEmpty);
253 |           });
254 |         });
255 | 
256 |         context("when there is a #parentDescription", function() {
257 |           it("returns #index concatenated to the #path of the #parentDescription", function() {
258 |             expect(childDescription0.path()).to(equal, [0]);
259 |             expect(grandchildDescription10.path()).to(equal, [1, 0]);
260 |           });
261 |         });
262 |       });
263 | 
264 |       describe("#runnableAtPath", function() {
265 |         it("returns the runnable object (Example or Description) found by traversing the tree along the given path", function() {
266 |           expect(rootDescription.runnableAtPath([1, 0])).to(equal, grandchildDescription10);
267 |         });
268 |       });
269 |     });
270 |     
271 |     describe("#runBefores", function() {
272 |       it("calls #runBefores on the #parentDescription if there is one, then runs all the befores in the order they were added", function() {
273 |         var events = [];
274 |         var exampleContexts = [];
275 |         description.addBefore(function() {
276 |           events.push("parent before called")
277 |           exampleContexts.push(this);
278 |         });
279 |         var childDescription = new Screw.Description("child description");
280 |         childDescription.addBefore(function() {
281 |           events.push("child before 1 called");
282 |           exampleContexts.push(this);
283 |         });
284 | 
285 |         childDescription.addBefore(function() {
286 |           events.push("child before 2 called");
287 |           exampleContexts.push(this);
288 |         });
289 |         description.addDescription(childDescription);
290 |         
291 |         childDescription.runBefores();
292 | 
293 |         expect(events).to(equal, ["parent before called", "child before 1 called", "child before 2 called"]);
294 |         expect(exampleContexts.length).to(equal, 3);
295 |         expect(exampleContexts[0]).to(equal, exampleContexts[1]);
296 |         expect(exampleContexts[0]).to(equal, exampleContexts[2]);
297 |       });
298 |     });
299 | 
300 |     describe("#runAfters", function() {
301 |       it("runs all the afters in the order they were added, with the given example context, then calls #runAfters on the #parentDescription if there is one", function() {
302 |         var events = [];
303 |         var exampleContexts = [];
304 |         description.addAfter(function() {
305 |           events.push("parent after called")
306 |           exampleContexts.push(this);
307 |         });
308 |         var childDescription = new Screw.Description("child description");
309 |         childDescription.addAfter(function() {
310 |           events.push("child after 1 called");
311 |           exampleContexts.push(this);
312 |         })
313 | 
314 |         childDescription.addAfter(function() {
315 |           events.push("child after 2 called");
316 |           exampleContexts.push(this);
317 |         })
318 |         description.addDescription(childDescription);
319 | 
320 |         childDescription.runAfters();
321 | 
322 |         expect(events).to(equal, ["child after 1 called", "child after 2 called", "parent after called"]);
323 |         expect(exampleContexts.length).to(equal, 3);
324 |         expect(exampleContexts[0]).to(equal, exampleContexts[1]);
325 |         expect(exampleContexts[0]).to(equal, exampleContexts[2]);
326 |       });
327 |     });
328 |   });
329 | }});
330 | 


--------------------------------------------------------------------------------
/client/spec/matchers_spec.js:
--------------------------------------------------------------------------------
  1 | Screw.Unit(function(c) { with(c) {
  2 |   describe("Matchers", function() {
  3 |     describe("#eq", function() {
  4 |       it("compares the expected to the actual with the === operator (exact object equality)", function() {
  5 |         var a = {};
  6 |         var b = {};
  7 | 
  8 |         expect(a).to(eq, a);
  9 |         expect(a).toNot(eq, b);
 10 |       });
 11 |     });
 12 | 
 13 |     describe('#equal', function() {
 14 |       it("invokes the provided matcher on a call to expect", function() {
 15 |         expect(true).to(equal, true);
 16 |         expect(true).toNot(equal, false);
 17 |       });
 18 |       
 19 |       describe('when actual is an object', function() {
 20 |         describe("when expected has the same keys and values", function() {
 21 |           it("matches successfully", function() {
 22 |             expect({a: 'b', c: 'd'}).to(equal, {a: 'b', c: 'd'});
 23 |           });
 24 |         });
 25 |         
 26 |         describe("when expected has different keys and values", function() {
 27 |           it("does not match", function() {
 28 |             expect({a: 'b', c: 'd', e: 'f'}).toNot(equal, {a: 'b', c: 'd', e: 'G'});
 29 |           });
 30 |         });
 31 |         
 32 |         describe("when expected is undefined", function() {
 33 |           it("does not match", function() {
 34 |             expect({}).toNot(equal, undefined);
 35 |           });
 36 |         });
 37 |       });
 38 |       
 39 |       describe("when actual is undefined", function() {
 40 |         describe("when expected is undefined", function() {
 41 |           it("matches successfully", function() {
 42 |             expect(undefined).to(equal, undefined);
 43 |           });
 44 |         });
 45 |         
 46 |         describe("when expected is an empty object", function() {
 47 |           it("does not match", function() {
 48 |             expect(undefined).toNot(equal, {});
 49 |           });
 50 |         });
 51 |       });
 52 |       
 53 |       describe('when actual is an Array', function() {
 54 |         it("matches Arrays with the same elements", function() {
 55 |           expect([1, 2, 4]).to(equal, [1, 2, 4]);
 56 |           expect([1, 2, 3]).toNot(equal, [3, 2, 1]);
 57 |         });
 58 |         
 59 |         it("recursively applies equality to complex elements", function() {
 60 |           expect([{a: 'b'}, {c: 'd'}]).to(equal, [{a: 'b'}, {c: 'd'}]);
 61 |           expect([{a: 'b'}, {c: 'd'}]).toNot(equal, [{a: 'b'}, {c: 'E'}]);
 62 |         });
 63 |       });
 64 | 
 65 |       describe('when actual is an iterable Object', function() {
 66 |         
 67 |       });
 68 | 
 69 |       describe("when actual is a String", function() {
 70 |         it("does not match an Array with the same characters", function() {
 71 |           expect("123").toNot(equal, ["1", "2", "3"]);
 72 |         });
 73 |       });
 74 | 
 75 |       describe("when actual is a hash", function() {
 76 |         it("matches hashes with the same key-value pairs", function() {
 77 |           expect({"a":"b", "c":"d"}).to(equal, {"a":"b", "c":"d"});
 78 |           expect({"a":"b", "c":"e"}).toNot(equal, {"a":"b", "c":"d"});
 79 |           expect({"a":"b", "d":"d"}).toNot(equal, {"a":"b", "c":"d"});
 80 |         });
 81 | 
 82 |         it("recursively applies equality to complex hashes", function() {
 83 |           expect({"a":"b", "c": {"e":"f", "g":"h"}}).to(equal, {"a":"b", "c": {"e":"f", "g":"h"}});
 84 |           expect({"a":"b", "c": {"e":"f", "g":"i"}}).toNot(equal, {"a":"b", "c": {"e":"f", "g":"h"}});
 85 |           expect({"a":"b", "c": {"e":"f", "h":"h"}}).toNot(equal, {"a":"b", "c": {"e":"f", "g":"h"}});
 86 |         });
 87 |       });
 88 | 
 89 |       describe(".failureMessage", function() {
 90 |         it('prints "expected [expected] to (not) be equal [actual]"', function() {
 91 |           var message = null;
 92 |           try { expect(1).to(equal, 2) } catch(e) { message = e.message }
 93 |           expect(message).to(equal, 'expected 1 to equal 2');
 94 |           
 95 |           try { expect(1).toNot(equal, 1) } catch(e) { message = e.message }
 96 |           expect(message).to(equal, 'expected 1 to not equal 1');
 97 |         });
 98 |       });
 99 |     });
100 |     
101 |     describe('#match', function() {
102 |       describe('when actual is a regular expression', function() {
103 |         it("matches Strings produced by the grammar", function() {
104 |           expect("The wheels of the bus").to(match, /bus/);
105 |           expect("The wheels of the bus").toNot(match, /boat/);
106 |         });
107 |       });
108 |       
109 |       describe('when actual is a string', function() {
110 |         it("matches [expected]s containing [actual]s", function() {
111 |           expect("The wheels of the bus").to(match, "wheels");
112 |           expect("The wheels of the bus").toNot(match, "oars");
113 |         });
114 |       });
115 | 
116 |       describe('when actual is an integer', function() {
117 |         it("matches [expected]s containing [actual]s", function() {
118 |           expect("1 time").to(match, 1);
119 |           expect("2 times").toNot(match, 3);
120 |         });
121 |       });
122 |       
123 |       describe(".failureMessage", function() {
124 |         it('prints "expected [actual] to (not) match [expected]', function() {
125 |           var message = null;
126 |           try { expect("hello").to(match, "schmello") } catch(e) { message = e.message }
127 |           expect(message).to(equal, 'expected "hello" to match "schmello"');
128 |           
129 |           try { expect("hello").toNot(match, "ello") } catch(e) { message = e.message }
130 |           expect(message).to(equal, 'expected "hello" to not match "ello"');
131 |         });
132 |       });
133 |     });
134 |     
135 |     describe('#beEmpty', function() {
136 |       it("matches Arrays with no elements", function() {
137 |         expect([]).to(beEmpty);
138 |         expect([1]).toNot(beEmpty);
139 |       });
140 |       
141 |       describe(".failureMessage", function() {
142 |         it("prints 'expected [actual] to (not) be empty", function() {
143 |           var message = null;
144 |           try { expect([1]).to(beEmpty) } catch(e) { message = e.message }
145 |           expect(message).to(equal, 'expected [ 1 ] to be empty');
146 |           
147 |           try { expect([]).toNot(beEmpty) } catch(e) { message = e.message }
148 |           expect(message).to(equal, 'expected [] to not be empty');
149 |         });
150 |       });
151 |     });
152 | 
153 |     describe('#haveLength', function() {
154 |       it("matches Arrays of the expected length", function() {
155 |         expect([]).to(haveLength, 0);
156 |         expect([1]).to(haveLength, 1);
157 |         expect([1, 2, 3]).toNot(haveLength, 4);
158 |       });
159 | 
160 |       describe(".failureMessage", function() {
161 |         it("prints 'expected [actual] to (not) have length [expected]", function() {
162 |           var message = null;
163 |           try { expect([1, 2]).to(haveLength, 4) } catch(e) { message = e.message }
164 |           expect(message).to(equal, 'expected [ 1, 2 ] to have length 4');
165 |           
166 |           try { expect([1]).toNot(haveLength, 1) } catch(e) { message = e.message }
167 |           expect(message).to(equal, 'expected [ 1 ] to not have length 1');
168 |         });
169 |       });
170 |     });
171 | 
172 |     describe('#beNull', function() {
173 |       it("matches null", function() {
174 |         expect(null).to(beNull);
175 |         expect(1).toNot(beNull);
176 |       });
177 | 
178 |       describe(".failureMessage", function() {
179 |         it("prints 'expected [actual] to (not) be null", function() {
180 |           var message = null;
181 |           try { expect(1).to(beNull) } catch(e) { message = e.message }
182 |           expect(message).to(equal, 'expected 1 to be null');
183 | 
184 |           try { expect(null).toNot(beNull) } catch(e) { message = e.message }
185 |           expect(message).to(equal, 'expected null to not be null');
186 |         });
187 |       });
188 |     });
189 | 
190 |     describe('#beUndefined', function() {
191 |       it("matches undefined", function() {
192 |         expect(undefined).to(beUndefined);
193 |         expect(1).toNot(beUndefined);
194 |       });
195 | 
196 |       describe(".failureMessage", function() {
197 |         it("prints 'expected [actual] to (not) be undefined", function() {
198 |           var message = undefined;
199 |           try { expect(1).to(beUndefined) } catch(e) { message = e.message }
200 |           expect(message).to(equal, 'expected 1 to be undefined');
201 | 
202 |           try { expect(undefined).toNot(beUndefined) } catch(e) { message = e.message }
203 |           expect(message).to(equal, 'expected undefined to not be undefined');
204 |         });
205 |       });
206 |     });
207 | 
208 |     describe('#beTrue', function() {
209 |       it("matches values that are considered true conditions", function() {
210 |         expect(true).to(beTrue);
211 |         expect(1).to(beTrue);
212 |         expect(false).toNot(beTrue);
213 |         expect(undefined).toNot(beTrue);
214 |         expect(null).toNot(beTrue);
215 |       });
216 | 
217 |       describe(".failureMessage", function() {
218 |         it("prints 'expected [actual] to (not) be true", function() {
219 |           var message = true;
220 |           try { expect(false).to(beTrue) } catch(e) { message = e.message }
221 |           expect(message).to(equal, 'expected false to be true');
222 | 
223 |           try { expect(true).toNot(beTrue) } catch(e) { message = e.message }
224 |           expect(message).to(equal, 'expected true to not be true');
225 |         });
226 |       });
227 |     });
228 | 
229 |     describe('#beFalse', function() {
230 |       it("matches values that are considered false conditions", function() {
231 |         expect(false).to(beFalse);
232 |         expect(undefined).to(beFalse);
233 |         expect(null).to(beFalse);
234 |         expect(true).toNot(beFalse);
235 |         expect(1).toNot(beFalse);
236 |       });
237 | 
238 |       describe(".failureMessage", function() {
239 |         it("prints 'expected [actual] to (not) be false", function() {
240 |           var message = false;
241 |           try { expect(true).to(beFalse) } catch(e) { message = e.message }
242 |           expect(message).to(equal, 'expected true to be false');
243 | 
244 |           try { expect(false).toNot(beFalse) } catch(e) { message = e.message }
245 |           expect(message).to(equal, 'expected false to not be false');
246 |         });
247 |       });
248 |     });
249 |     
250 |     describe('#beGt', function() {
251 |       it('matches integers greater than the expected value', function() {
252 |         expect(2).to(beGt, 1);
253 |         expect(1).to(beGt, 0);
254 |         expect(0).to(beGt, -1);
255 |         expect(0).toNot(beGt, 0);
256 |         expect(-1).toNot(beGt, 0);
257 |         expect(0).toNot(beGt, 1);
258 |         expect(1).toNot(beGt, 5);
259 |       });
260 | 
261 |       describe(".failureMessage", function() {
262 |         it('prints "expected [expected] to (not) be greater than [actual]"', function() {
263 |           var message = null;
264 |           try { expect(1).to(beGt, 2) } catch(e) { message = e.message }
265 |           expect(message).to(equal, 'expected 1 to be greater than 2');
266 |           
267 |           try { expect(2).toNot(beGt, 1) } catch(e) { message = e.message }
268 |           expect(message).to(equal, 'expected 2 to not be greater than 1');
269 |         });
270 |       });
271 |     });
272 | 
273 |     describe('#beGte', function() {
274 |       it('matches integers greater than or equal to the expected value', function() {
275 |         expect(2).to(beGte, 1);
276 |         expect(1).to(beGte, 0);
277 |         expect(0).to(beGte, -1);
278 |         expect(-1).to(beGte, -1);
279 |         expect(0).to(beGte, 0);
280 |         expect(1).to(beGte, 1);
281 |         expect(-1).toNot(beGte, 0);
282 |         expect(0).toNot(beGte, 1);
283 |         expect(1).toNot(beGte, 5);
284 |       });
285 | 
286 |       describe(".failureMessage", function() {
287 |         it('prints "expected [expected] to (not) be greater than or equal to [actual]"', function() {
288 |           var message = null;
289 |           try { expect(1).to(beGte, 2) } catch(e) { message = e.message }
290 |           expect(message).to(equal, 'expected 1 to be greater than or equal to 2');
291 |           
292 |           try { expect(2).toNot(beGte, 1) } catch(e) { message = e.message }
293 |           expect(message).to(equal, 'expected 2 to not be greater than or equal to 1');
294 |         });
295 |       });
296 |     });
297 | 
298 |     describe('#beLt', function() {
299 |       it('matches integers less than the expected value', function() {
300 |         expect(1).to(beLt, 2);
301 |         expect(0).to(beLt, 1);
302 |         expect(-1).to(beLt, 0);
303 |         expect(0).toNot(beLt, 0);
304 |         expect(0).toNot(beLt, -1);
305 |         expect(1).toNot(beLt, 0);
306 |         expect(5).toNot(beLt, 1);
307 |       });
308 | 
309 |       describe(".failureMessage", function() {
310 |         it('prints "expected [expected] to (not) be less than [actual]"', function() {
311 |           var message = null;
312 |           try { expect(2).to(beLt, 1) } catch(e) { message = e.message }
313 |           expect(message).to(equal, 'expected 2 to be less than 1');
314 |           
315 |           try { expect(1).toNot(beLt, 2) } catch(e) { message = e.message }
316 |           expect(message).to(equal, 'expected 1 to not be less than 2');
317 |         });
318 |       });
319 |     });
320 | 
321 |     describe('#beLte', function() {
322 |       it('matches integers less than or equal to the expected value', function() {
323 |         expect(1).to(beLte, 2);
324 |         expect(0).to(beLte, 1);
325 |         expect(-1).to(beLte, 0);
326 |         expect(-1).to(beLte, -1);
327 |         expect(0).to(beLte, 0);
328 |         expect(1).to(beLte, 1);
329 |         expect(0).toNot(beLte, -1);
330 |         expect(1).toNot(beLte, 0);
331 |         expect(5).toNot(beLte, 1);
332 |       });
333 | 
334 |       describe(".failureMessage", function() {
335 |         it('prints "expected [expected] to (not) be less than or equal to [actual]"', function() {
336 |           var message = null;
337 |           try { expect(2).to(beLte, 1) } catch(e) { message = e.message }
338 |           expect(message).to(equal, 'expected 2 to be less than or equal to 1');
339 |           
340 |           try { expect(1).toNot(beLte, 2) } catch(e) { message = e.message }
341 |           expect(message).to(equal, 'expected 1 to not be less than or equal to 2');
342 |         });
343 |       });
344 |     });
345 | 
346 |     describe("#haveBeenCalled", function() {
347 |       var mockFn;
348 |       before(function() {
349 |         mockFn = mockFunction();
350 |       });
351 | 
352 |       context("when matching a mock function with no expected argument", function() {
353 |         it("matches if the function's #callCount is > 0", function() {
354 |           expect(mockFn).toNot(haveBeenCalled)
355 |           mockFn();
356 |           expect(mockFn).to(haveBeenCalled)
357 |         });
358 |       });
359 | 
360 |       context("when matching a mock function with the number of times called", function() {
361 |         it("matches if the function's #callCount matches the expectation", function() {
362 |           mockFn();
363 |           expect(mockFn).to(haveBeenCalled, once);
364 |           mockFn();
365 |           expect(mockFn).to(haveBeenCalled, twice);
366 |           mockFn();
367 |           expect(mockFn).to(haveBeenCalled, thrice);
368 |           mockFn();
369 |           expect(mockFn).to(haveBeenCalled, 4);
370 |         });
371 |       });
372 | 
373 |       context("when matching a mock function with the expected arguments", function() {
374 |         it("matches if the function's #mostRecentArgs match the expectation", function() {
375 |           mockFn("foo", "bar");
376 |           expect(mockFn).to(haveBeenCalled, withArgs("foo", "bar"));
377 |         });
378 |       });
379 | 
380 |       context("when matching a mock function with the expected this value", function() {
381 |         it("matches if the function's #mostRecentThisValue match the expectation", function() {
382 |           var a = { mockFn: mockFn };
383 |           a.mockFn();
384 |           expect(mockFn).to(haveBeenCalled, onObject(a));
385 |         });
386 |       });
387 |     });
388 | 
389 |     describe("#contain", function() {
390 |       it("matches arrays containing the expected value", function() {
391 |         expect([1,2,3]).to(contain, 2);
392 |         expect([1,2,3]).toNot(contain, 7);
393 |       });
394 | 
395 |       describe(".failure message", function() {
396 |         it('prints "expected [expected] to (not) contain [actual]"', function() {
397 |           var message = null;
398 |           try { expect([1,2]).to(contain, 3) } catch(e) { message = e.message }
399 |           expect(message).to(equal, 'expected [ 1, 2 ] to contain 3, but it did not');
400 | 
401 | 
402 |           try { expect([1,2]).toNot(contain, 2) } catch(e) { message = e.message }
403 |           expect(message).to(equal, 'expected [ 1, 2 ] to not contain 2, but it did');
404 |         });
405 | 
406 |       });
407 |     });
408 | 
409 |     describe("#throwException", function() {
410 |       var throws, doesNotThrow;
411 | 
412 |       before(function() {
413 |         throws = function() { throw new Error("intentional"); };
414 |         doesNotThrow = function() { };
415 |       });
416 | 
417 |       it("matches functions that throw exceptions when called", function() {
418 |         expect(throws).to(throwException);
419 |         expect(doesNotThrow).toNot(throwException);
420 |       });
421 | 
422 |       describe(".failureMessage", function() {
423 |         it("prints a message about the expected throwing", function() {
424 |           var message = true;
425 | 
426 |           try { expect(doesNotThrow).to(throwException) } catch(e) { message = e.message }
427 |           expect(message).to(equal, 'expected function to throw an exception, but it did not');
428 | 
429 |           try { expect(throws).toNot(throwException) } catch(e) { message = e.message }
430 |           expect(message).to(equal, 'expected function to not throw an exception, but it did');
431 |         });
432 |       });
433 | 
434 |     });
435 |   });
436 | }});


--------------------------------------------------------------------------------