pivotal-screw-unit 0.4.0

data/core/spec/print_spec.js

@@ -0,0 +1,158 @@
+Screw.Unit(function() {
+  describe("Print", function() {
+    describe('when given undefined', function() {
+      it("returns 'undefined'", function() {
+        expect($.print(undefined)).to(equal, 'undefined');
+      });
+    });
+    
+    describe('when given null', function() {
+      it("returns 'null'", function() {
+        expect($.print(null)).to(equal, 'null');
+      });
+    });
+    
+    describe('when given a number', function() {
+      it("returns the string representation of the number", function() {
+        expect($.print(1)).to(equal, '1');
+        expect($.print(1.01)).to(equal, '1.01');
+        expect($.print(-1)).to(equal, '-1');
+      });
+    });
+    
+    describe('when given a boolean', function() {
+      it("returns the string representation of the boolean", function() {
+        expect($.print(true)).to(equal, 'true');
+        expect($.print(false)).to(equal, 'false');
+      });
+    });
+    
+    describe('when given a string', function() {
+      it("returns the string, quoted", function() {
+        expect($.print('asdf')).to(equal, '"asdf"');
+      });
+      
+      describe('when the string is longer than the [max_string] option', function() {
+        it("returns the string, truncated", function() {
+          expect($.print('asdf', { max_string: 3 })).to(equal, '"asd..."');
+        });        
+      });
+      
+      describe('when the strings has quotes or escaped characters', function() {
+        it("returns the string, with quotes and escaped characters escaped", function() {
+          expect($.print('as"df')).to(equal, '"as\\"df"');
+          expect($.print('as\tdf')).to(equal, '"as\\tdf"');
+        });        
+      });
+    });
+    
+    describe('when given a function', function() {
+      it("returns the function's signature", function() {
+        expect($.print(function() {})).to(match, /function\s*\(\)/);
+        expect($.print(function foo() {})).to(match, /function\s*foo\(\)/);
+        expect($.print(function foo(bar) {})).to(match, /function\s*foo\(bar\)/);
+      });        
+    });
+
+    describe('when given a RegExp', function() {
+      it('should print the regexp', function() {
+        expect($.print(/abc/i)).to(equal, '/abc/i');
+      });
+    });
+
+    describe('when given NaN', function() {
+      it('should print the string "NaN"', function() {
+        expect($.print(NaN)).to(equal, 'NaN');
+      });
+    });
+
+    describe('when given 0', function() {
+      it('should print the string "0"', function() {
+        expect($.print(0)).to(equal, '0');
+      });
+    });
+    
+    describe('when given an element', function() {
+      it("returns the string representation of the element", function() {
+        expect($.print($('<div></div>').get(0))).to(equal, '<div>');
+        expect($.print($('<div foo="bar"></div>').get(0))).to(equal, '<div>');
+        expect($.print($('<div class="foo" id="bar"></div>').get(0))).to(equal, '<div class="foo" id="bar">');
+      });
+
+      describe('when the element is an img', function() {
+        it('prints out the img src attribute', function() {
+          expect($.print($('<img src="test.png"/>'))).to(match, /<img src=".+?test.png">/);
+        })
+      });
+    });
+
+    describe('when given an array', function() {
+      it("returns the printed elements, comma separated, encircled by square brackets", function() {
+        expect($.print([])).to(equal, '[]');
+        expect($.print([1])).to(equal, '[ 1 ]');
+        expect($.print([1, 2, 3])).to(equal, '[ 1, 2, 3 ]');
+      });
+      
+      describe('when the array is longer than the [max_array] option', function() {
+        it("returns the printed array, truncated", function() {
+          expect($.print([1, 2, 3, 4], { max_array: 2 })).to(equal, '[ 1, 2, 2 more... ]');
+        });
+      });
+      
+      describe('when the array has arrays as its elements', function() {
+        it("returns the recursively printed array", function() {
+          expect($.print([[]])).to(equal, '[ [] ]');
+          expect($.print([ [1, 2, 3], 4 ])).to(equal, '[ [ 1, 2, 3 ], 4 ]');
+        });
+      });
+
+      describe('when the array has objects as its elements', function() {
+        it("returns recursively printed array", function() {
+          expect($.print([{}])).to(equal, '[ {} ]');
+          expect($.print([ { foo: 'bar' }, 'baz' ])).to(equal, '[ { foo: "bar" }, "baz" ]');
+        });
+      });
+    });
+
+    describe('when given arguments', function() {
+      it("returns the printed array of elements ", function() {
+        var args = null;
+        (function(){ args = arguments })(1,2,3);
+        expect($.print(args)).to(equal, '[ 1, 2, 3 ]');
+      });
+    });
+
+    describe('when given a jQuery', function() {
+      it("returns the printed array of elements engirthed in '$()'", function() {
+        expect($.print($('<div></div>'))).to(equal, '$([ <div> ])');
+      });
+    });
+    
+    describe('when given a NodeList', function() {
+      it("returns the printed array of elements in the list", function() {
+        expect($.print(document.getElementsByTagName('body'))).to(equal, '[ <body> ]');
+      });
+    });
+
+    describe('when given an object', function() {
+      it("returns the keys and values of the object, enraptured with curly braces", function() {
+        expect($.print({})).to(equal, '{}');
+        expect($.print({ foo: 1, bar: 2 })).to(equal, '{ foo: 1, bar: 2 }');
+      });
+      
+      describe('when the values of the object are non-primitive', function() {
+        it("recursively prints the keys and values", function() {
+          expect($.print({ foo: [1, 2] })).to(equal, '{ foo: [ 1, 2 ] }');
+        });
+        
+        describe('when the object has circular references', function() {
+          it("returns elipses for circularities", function() {
+            var circular = {};
+            circular[0] = circular;
+            expect($.print(circular)).to(equal, '{ 0: ... }');
+          });
+        });
+      });
+    });
+  });
+});

data/core/spec/suite.html

@@ -0,0 +1,19 @@
+<html>
+  <head>
+    <script src="../lib/jquery-1.3.2.js"></script>
+    <script src="../lib/jquery.fn.js"></script>
+    <script src="../lib/jquery.print.js"></script>
+    <script src="../lib/screw.builder.js"></script>
+    <script src="../lib/screw.matchers.js"></script>
+    <script src="../lib/screw.events.js"></script>
+    <script src="../lib/screw.behaviors.js"></script>
+    <script src="spec_helper.js"></script>
+    <script src="behaviors_spec.js"></script>
+    <script src="matchers_spec.js"></script>
+    <script src="print_spec.js"></script>
+    <script src="with_screw_context_spec.js"></script>
+
+    <link rel="stylesheet" href="../lib/screw.css">
+  </head>
+  <body></body>
+</html>

data/core/spec/with_screw_context_spec.js

@@ -0,0 +1,9 @@
+Screw.Unit(function(screw) { with(screw) {
+  describe("Screw.Unit", function() {
+    describe("when the passed-in function has an arity of 1", function() {
+      it("passes the Screw.Unit context into the function", function() {
+        expect(true).to(equal, true);
+      });
+    });
+  });
+}});

data/lib/screw_unit/representations/spec.html.rb

@@ -0,0 +1,117 @@
+module ScrewUnit
+  module Representations
+    class Spec < JsTestCore::Representations::Spec
+      def title_text
+        "Screw Unit suite"
+      end
+
+      def head_content
+        core_js_files
+        script(raw(<<-JS), :type => "text/javascript")
+          (function($) {
+            Screw.Assets = {};
+            Screw.Assets.use_cache_buster = false; // TODO: NS/CTI - make this configurable from the UI.
+            var required_paths = [];
+            var included_stylesheets = {};
+            var cache_buster = parseInt(new Date().getTime()/(1*1000));
+
+            function tag(name, attributes) {
+              var html = "<" + name;
+              for(var attribute in attributes) {
+                html += (" " + attribute + "='" + attributes[attribute]) + "'";
+              };
+              html += "></";
+              html += name;
+              html += ">";
+              return html;
+            }
+
+            Screw.Assets.require = function(javascript_path, onload) {
+              if(!required_paths[javascript_path]) {
+                var full_path = javascript_path + ".js";
+                if (Screw.Assets.use_cache_buster) {
+                  full_path += '?' + cache_buster;
+                }
+                document.write(tag("script", {src: full_path, type: 'text/javascript'}));
+                if(onload) {
+                  var scripts = document.getElementsByTagName('script');
+                  scripts[scripts.length-1].onload = onload;
+                }
+                required_paths[javascript_path] = true;
+              }
+            };
+
+            Screw.Assets.stylesheet = function(stylesheet_path) {
+              if(!included_stylesheets[stylesheet_path]) {
+                var full_path = stylesheet_path + ".css";
+                if(Screw.Assets.use_cache_buster) {
+                  full_path += '?' + cache_buster;
+                }
+                document.write(tag("link", {rel: 'stylesheet', type: 'text/css', href: full_path}));
+                included_stylesheets[stylesheet_path] = true;
+              }
+            };
+
+            window.require = Screw.Assets.require;
+            window.stylesheet = Screw.Assets.stylesheet;
+          })(jQuery);
+
+          (function($) {
+            var ajax = $.ajax;
+            $(Screw).bind('after', function() {
+              var error_text = $(".error").map(function(i, error_element) {
+                var element = $(error_element);
+
+                var parent_descriptions = element.parents("li.describe");
+                var parent_description_text = [];
+
+                for(var i=parent_descriptions.length-1; i >= 0; i--) {
+                  parent_description_text.push($(parent_descriptions[i]).find("h1").text());
+                }
+
+                var it_text = element.parents("li.it").find("h2").text();
+
+                return parent_description_text.join(" ") + " " + it_text + ": " + element.text();
+              }).get().join("\\n");
+
+              ajax({
+                type: "POST",
+                url: '/session/finish',
+                data: {"text": error_text}
+              });
+            });
+          })(jQuery);
+        JS
+        project_js_files
+        link :rel => "stylesheet", :href => "/core/screw.css"
+        project_css_files
+
+        spec_script_elements
+      end
+
+      def core_js_files
+        script :src => jquery_js_file
+        script :src => "/core/jquery.fn.js"
+        script :src => "/core/jquery.print.js"
+        script :src => "/core/screw.builder.js"
+        script :src => "/core/screw.matchers.js"
+        script :src => "/core/screw.events.js"
+        script :src => "/core/screw.behaviors.js"
+      end
+
+      def project_js_files
+      end
+
+      def project_css_files
+      end
+
+      def jquery_js_file
+        "/core/jquery-1.3.2.js"
+      end
+
+      def body_content
+        div :id => "screw_unit_content"
+      end
+    end
+  end
+end

data/lib/screw_unit/representations.rb

@@ -0,0 +1,2 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/representations/spec.html"

data/lib/screw_unit.rb

@@ -0,0 +1,19 @@
+require "rubygems"
+
+dir = File.dirname(__FILE__)
+$:.unshift(File.expand_path("#{dir}/../vendor/js-test-core/lib"))
+require "js_test_core"
+JsTestCore::Resources::WebRoot.dispatch_specs
+
+require "#{dir}/screw_unit/representations"
+
+module ScrewUnit
+  DEFAULT_HOST = JsTestCore::DEFAULT_HOST
+  DEFAULT_PORT = JsTestCore::DEFAULT_PORT
+
+  Server = JsTestCore::Server
+  RailsServer = JsTestCore::RailsServer
+  Client = JsTestCore::Client
+end
+JsTestCore.core_path = File.expand_path("#{dir}/../core/lib")
+JsTestCore::Resources::Specs::Spec.spec_representation_class = ScrewUnit::Representations::Spec

data/spec/functional/functional_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path("#{File.dirname(__FILE__)}/functional_spec_helper")
+
+describe "ScrewUnit" do
+  attr_reader :stdout, :request
+  before do
+    @stdout = StringIO.new
+    ScrewUnit::Client.const_set(:STDOUT, stdout)
+    @request = "http request"
+  end
+
+  after do
+    ScrewUnit::Client.__send__(:remove_const, :STDOUT)
+  end
+
+  it "runs a full passing Suite" do
+    ScrewUnit::Client.run(:spec_url => "#{root_url}/specs/foo/passing_spec")
+    stdout.string.strip.should == "SUCCESS"
+  end
+
+  it "runs a full failing Suite" do
+    ScrewUnit::Client.run(:spec_url => "#{root_url}/specs/foo/failing_spec")
+    stdout.string.strip.should include("FAILURE")
+    stdout.string.strip.should include("A failing spec in foo fails: expected true to equal false")
+  end
+end

data/spec/functional/functional_spec_helper.rb

@@ -0,0 +1,34 @@
+require "rubygems"
+require "spec"
+require "spec/autorun"
+require "selenium_rc"
+dir = File.dirname(__FILE__)
+require "#{dir}/functional_spec_server_starter"
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end
+
+Thin::Logging.silent = false
+Thin::Logging.debug = true
+
+class Spec::ExampleGroup
+  include WaitFor
+  attr_reader :spec_root_path, :implementation_root_path, :public_path
+
+  before(:all) do
+    @spec_root_path = FunctionalSpecServerStarter.spec_root_path
+    @public_path = FunctionalSpecServerStarter.public_path
+    @implementation_root_path = FunctionalSpecServerStarter.implementation_root_path
+#    Thread.start do
+#      SeleniumRC::Server.boot
+#    end
+    FunctionalSpecServerStarter.call
+    TCPSocket.wait_for_service :host => "0.0.0.0", :port => "4444"
+  end
+
+  def root_url
+    "http://#{ScrewUnit::DEFAULT_HOST}:#{ScrewUnit::DEFAULT_PORT}"
+  end
+end
+

data/spec/functional/functional_spec_server_starter.rb

@@ -0,0 +1,63 @@
+require "rubygems"
+require "timeout"
+require "lsof"
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift "#{dir}/../../lib"
+require "screw_unit"
+require "nokogiri"
+
+module WaitFor
+  extend self
+  def wait_for(time=5)
+    Timeout.timeout(time) do
+      loop do
+        value = yield
+        return value if value
+      end
+    end
+  end
+end
+
+class FunctionalSpecServerStarter
+  class << self
+    include WaitFor
+    def call(threaded=true)
+      return if $screw_unit_server_started
+      Lsof.kill(8080)
+      wait_for do
+        !Lsof.running?(8080)
+      end
+      if threaded
+        Thread.start do
+          ScrewUnit::Server.run(spec_root_path, implementation_root_path, public_path)
+        end
+      else
+        ScrewUnit::Server.run(spec_root_path, implementation_root_path, public_path)
+      end
+      wait_for do
+        Lsof.running?(8080)
+      end
+      $screw_unit_server_started = true
+    end
+
+    def spec_root_path
+      File.expand_path("#{dir}/../example_specs")
+    end
+
+    def public_path
+      File.expand_path("#{dir}/../example_public")
+    end
+
+    def implementation_root_path
+      File.expand_path("#{public_path}/javascripts")
+    end
+
+    def dir
+      dir = File.dirname(__FILE__)
+    end
+  end
+end
+
+if $0 == __FILE__
+  FunctionalSpecServerStarter.call(false)
+end

data/spec/functional_suite.rb

@@ -0,0 +1,10 @@
+class FunctionalSuite
+  def run
+    dir = File.dirname(__FILE__)
+    Dir["#{dir}/functional/**/*_spec.rb"].each do |file|
+      require file
+    end
+  end
+end
+
+FunctionalSuite.new.run

data/spec/spec_suite.rb

@@ -0,0 +1,3 @@
+dir = File.dirname(__FILE__)
+raise "Failure" unless system(%Q|ruby #{dir}/unit_suite.rb|)
+raise "Failure" unless system(%Q|ruby #{dir}/functional_suite.rb|)

data/spec/unit/js_test_core/specs/spec_dir_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
+
+module JsTestCore
+  module Resources
+    module Specs
+      describe SpecDir do
+
+        describe "GET /specs" do
+          attr_reader :dir, :html, :doc
+
+          before do
+            mock(connection).send_head(200, is_a(Hash))
+            mock(connection).send_data(/Content-Length:/)
+            mock(connection).send_data(anything) do |@html|
+              # do nothing
+            end
+
+            connection.receive_data("GET /specs HTTP/1.1\r\nHost: _\r\n\r\n")
+            @doc = Nokogiri::HTML(html)
+          end
+
+          it "returns script tags for each test javascript file" do
+            doc.at("script[@src='/specs/failing_spec.js']").should_not be_nil
+            doc.at("script[@src='/specs/foo/failing_spec.js']").should_not be_nil
+            doc.at("script[@src='/specs/foo/passing_spec.js']").should_not be_nil
+          end
+
+          it "returns the screw unit template" do
+            doc.at("link[@href='/core/screw.css']").should_not be_nil
+            doc.at("script[@src='/core/screw.builder.js']").should_not be_nil
+            doc.at("script[@src='/core/screw.events.js']").should_not be_nil
+            doc.at("script[@src='/core/screw.behaviors.js']").should_not be_nil
+            doc.at("body/#screw_unit_content").should_not be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/js_test_core/specs/spec_file_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
+
+module JsTestCore
+  module Resources
+    module Specs
+      describe SpecFile do
+        describe "GET /specs/failing_spec" do
+          attr_reader :html, :doc
+          before do
+            mock(connection).send_head(200, is_a(Hash))
+            mock(connection).send_data(/Content-Length:/)
+            mock(connection).send_data(anything) do |@html|
+              # do nothing
+            end
+
+            connection.receive_data("GET /specs/failing_spec HTTP/1.1\r\nHost: _\r\n\r\n")
+            @doc = Nokogiri::HTML(html)            
+          end
+
+          it "returns script tags for the test javascript file" do
+            doc.at("script[@src='/specs/failing_spec.js']").should_not be_nil
+          end
+
+          it "returns the screw unit template" do
+            doc.at("link[@href='/core/screw.css']").should_not be_nil
+            doc.at("script[@src='/core/screw.builder.js']").should_not be_nil
+            doc.at("script[@src='/core/screw.events.js']").should_not be_nil
+            doc.at("script[@src='/core/screw.behaviors.js']").should_not be_nil
+            doc.at("body/#screw_unit_content").should_not be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/unit_spec_helper.rb

@@ -0,0 +1,119 @@
+require "rubygems"
+require "spec"
+require "spec/autorun"
+dir = File.dirname(__FILE__)
+
+$LOAD_PATH.unshift "#{dir}/../../lib"
+require "screw_unit"
+require "nokogiri"
+require "guid"
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end
+
+module Spec
+  module Matchers
+    class Exist
+      def matches?(actual)
+        @actual = actual
+        !@actual.nil?
+      end
+    end
+  end
+end
+
+class Spec::ExampleGroup
+  class << self
+    def thin_logging
+      @thin_logging = true if @thin_logging.nil?
+      @thin_logging
+    end
+
+    attr_writer :thin_logging
+  end
+
+  attr_reader :spec_root_path, :implementation_root_path, :public_path, :server, :connection
+  before(:all) do
+    dir = File.dirname(__FILE__)
+    @spec_root_path = File.expand_path("#{dir}/../example_specs")
+    @implementation_root_path = File.expand_path("#{dir}/../example_public/javascripts")
+    @public_path = File.expand_path("#{dir}/../example_public")
+  end
+
+  before(:each) do
+    JsTestCore::Server.instance = JsTestCore::Server.new(spec_root_path, implementation_root_path, public_path)
+    stub(EventMachine).run do
+      raise "You need to mock calls to EventMachine.run or the process will hang"
+    end
+    stub(EventMachine).start_server do
+      raise "You need to mock calls to EventMachine.start_server or the process will hang"
+    end
+    stub(EventMachine).send_data do
+      raise "Calls to EventMachine.send_data must be mocked or stubbed"
+    end
+    @connection = Thin::JsTestCoreConnection.new(Guid.new)
+    stub(EventMachine).send_data {raise "EventMachine.send_data must be handled"}
+    stub(EventMachine).close_connection {raise "EventMachine.close_connection must be handled"}
+    @server = JsTestCore::Server.instance
+    Thin::Logging.silent = !self.class.thin_logging
+    Thin::Logging.debug = self.class.thin_logging
+  end
+
+  after(:each) do
+    Thin::Logging.silent = true
+    Thin::Logging.debug = false
+  end
+
+  def get(url, params={})
+    request(:get, url, params)
+  end
+
+  def post(url, params={})
+    request(:post, url, params)
+  end
+
+  def put(url, params={})
+    request(:put, url, params)
+  end
+
+  def delete(url, params={})
+    request(:delete, url, params)
+  end
+
+  def env_for(method, url, params)
+    Rack::MockRequest.env_for(url, params.merge({:method => method.to_s.upcase, 'js_test_core.connection' => connection}))
+  end
+
+  def create_request(method, url, params={})
+    env = env_for(method, url, params)
+    server.call(env)[2]
+  end
+  alias_method :request, :create_request
+
+  def core_path
+    JsTestCore::Server.core_path
+  end
+
+  def spec_file(relative_path)
+    absolute_path = spec_root_path + relative_path
+    JsTestCore::Resources::File.new(absolute_path, "/specs#{relative_path}")
+  end
+
+  def spec_dir(relative_path="")
+    absolute_path = spec_root_path + relative_path
+    JsTestCore::Resources::SpecDir.new(absolute_path, "/specs#{relative_path}")
+  end
+
+  def contain_spec_file_with_correct_paths(path_relative_to_spec_root)
+    expected_absolute_path = spec_root_path + path_relative_to_spec_root
+    expected_relative_path = "/specs" + path_relative_to_spec_root
+
+    ::Spec::Matchers::SimpleMatcher.new(expected_relative_path) do |globbed_files|
+      file = globbed_files.find do |file|
+        file.absolute_path == expected_absolute_path
+      end
+      file && file.relative_path == expected_relative_path
+    end
+  end
+end

data/spec/unit_suite.rb

@@ -0,0 +1,10 @@
+class UnitSuite
+  def run
+    dir = File.dirname(__FILE__)
+    Dir["#{dir}/unit/**/*_spec.rb"].each do |file|
+      require file
+    end
+  end
+end
+
+UnitSuite.new.run