pivotal-screw-unit-server 0.5.3

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.rb

@@ -0,0 +1,23 @@
+require "rubygems"
+
+dir = File.dirname(__FILE__)
+$:.unshift(File.expand_path("#{dir}/../vendor/js-test-core/lib"))
+require "js_test_core"
+
+require "#{dir}/screw_unit/representations"
+
+JsTestCore.core_path = File.expand_path("#{dir}/../core/lib")
+JsTestCore::Resources::SpecFile.spec_representation_class = ScrewUnit::Representations::Spec
+module ScrewUnit
+  include JsTestCore
+
+  class << self
+    def method_missing(method_name, *args, &block)
+      if JsTestCore::Configuration.instance.respond_to?(method_name)
+        JsTestCore::Configuration.instance.send(method_name, *args, &block)
+      else
+        super
+      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/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: '#{ScrewUnit::Resources::SeleniumSession.path("/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/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,43 @@
+require "rubygems"
+require "spec"
+require "spec/autorun"
+require "selenium_rc"
+require "thin"
+dir = File.dirname(__FILE__)
+LIBRARY_ROOT_DIR = File.expand_path("#{dir}/../..")
+require "#{LIBRARY_ROOT_DIR}/vendor/js-test-core/spec/spec_helpers/be_http"
+require "#{LIBRARY_ROOT_DIR}/vendor/js-test-core/spec/spec_helpers/show_test_exceptions"
+require "#{dir}/functional_spec_server_starter"
+ARGV.push("-b")
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end
+
+Sinatra::Application.use ShowTestExceptions
+Sinatra::Application.set :raise_errors, true
+
+Sinatra::Application.use(ScrewUnit::App)
+
+
+class Spec::ExampleGroup
+  include WaitFor
+  attr_reader :spec_root_path, :public_path
+
+  before(:all) do
+    @spec_root_path = FunctionalSpecServerStarter.spec_root_path
+    @public_path = FunctionalSpecServerStarter.public_path
+    unless SeleniumRC::Server.service_is_running?
+      Thread.start do
+        SeleniumRC::Server.boot
+      end
+    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,68 @@
+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
+
+      dir = File.dirname(__FILE__)
+      Dir.chdir("#{dir}/../../") do
+        Thread.start do
+          start_thin_server
+        end
+      end
+
+      wait_for do
+        Lsof.running?(8080)
+      end
+      $screw_unit_server_started = true
+    end
+
+    def start_thin_server
+      system("bin/screw_unit_server #{spec_root_path} #{public_path}")
+      at_exit do
+        Lsof.kill(8080)
+      end
+    end
+
+    def spec_root_path
+      File.expand_path("#{dir}/../example_specs")
+    end
+
+    def public_path
+      File.expand_path("#{dir}/../example_public")
+    end
+
+    def dir
+      dir = File.dirname(__FILE__)
+    end
+  end
+end
+
+if $0 == __FILE__
+  FunctionalSpecServerStarter.call(false)
+end