screw-unit-server 0.3.0 → 0.5.3

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

@@ -3,24 +3,21 @@ 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/resources"
+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::SpecFile.spec_representation_class = ScrewUnit::Representations::Spec
+module ScrewUnit
+  include JsTestCore
 
-class JsTestCore::Resources::Specs::SpecFile
-  include ScrewUnit::Resources::Spec
-end
-
-class JsTestCore::Resources::Specs::SpecDir
-  include ScrewUnit::Resources::Spec
+  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

@@ -1,14 +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
-    mock(ScrewUnit::Client).puts("SUCCESS")
     ScrewUnit::Client.run(:spec_url => "#{root_url}/specs/foo/passing_spec")
+    stdout.string.strip.should == "SUCCESS"
   end
 
   it "runs a full failing Suite" do
-    mock(ScrewUnit::Client).puts("FAILURE")
-    mock(ScrewUnit::Client).puts('expected true to equal false')
     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

@@ -1,55 +1,43 @@
 require "rubygems"
 require "spec"
-
+require "spec/autorun"
+require "selenium_rc"
+require "thin"
 dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift "#{dir}/../../lib"
-require "screw_unit"
-require "hpricot"
-require "lsof"
+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
 
-Thin::Logging.silent = false
-Thin::Logging.debug = true
+Sinatra::Application.use ShowTestExceptions
+Sinatra::Application.set :raise_errors, true
 
-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
+Sinatra::Application.use(ScrewUnit::App)
 
-module Spec::Example::ExampleMethods
+
+class Spec::ExampleGroup
   include WaitFor
-  attr_reader :spec_root_path, :implementation_root_path, :public_path
+  attr_reader :spec_root_path, :public_path
+
   before(:all) do
-    Lsof.kill(8080)
-    wait_for do
-      !Lsof.running?(8080)
-    end
-    dir = File.dirname(__FILE__)
-    @spec_root_path = "#{dir}/../example_specs"
-    @public_path = "#{dir}/../example_public"
-    @implementation_root_path = "#{public_path}/javascripts"
-    unless $screw_unit_server_started
+    @spec_root_path = FunctionalSpecServerStarter.spec_root_path
+    @public_path = FunctionalSpecServerStarter.public_path
+    unless SeleniumRC::Server.service_is_running?
       Thread.start do
-        ScrewUnit::Server.run(spec_root_path, implementation_root_path, public_path)
+        SeleniumRC::Server.boot
       end
-      $screw_unit_server_started = true
-    end
-    wait_for do
-      Lsof.running?(8080)
     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

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

@@ -4,35 +4,60 @@ module JsTestCore
   module Resources
     module Specs
       describe SpecFile do
-        describe "#spec_files" do
-          attr_reader :absolute_path, :relative_path, :file
+        describe "File" do
+          describe "GET /specs/failing_spec" do
+            attr_reader :html, :doc
+            before do
+              response = get(SpecFile.path("/failing_spec"))
+              response.should be_http(
+                200,
+                {},
+                ""
+              )
+
+              @doc = Nokogiri::HTML(response.body)
+            end
 
-          before do
-            @absolute_path = "#{spec_root_path}/failing_spec.js"
-            @relative_path = "/specs/failing_spec.js"
-            @file = SpecFile.new(absolute_path, relative_path)
+            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
+
+        describe "Directory" do
+          describe "GET /specs" do
+            attr_reader :dir, :html, :doc
 
-          describe "#get" do
-            attr_reader :html, :doc
             before do
-              request = request('get', '/specs')
-              response = Rack::Response.new
-              file.get(request, response)
-              @html = response.body
-              @doc = Hpricot(html)
+              response = get(SpecFile.path("/"))
+              response.should be_http(
+                200,
+                {},
+                ""
+              )
+
+              @doc = Nokogiri::HTML(response.body)
             end
 
-            it "returns script tags for the test javascript file" do
-              doc.at("script[@src='/specs/failing_spec.js']").should exist
+            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 exist
-              doc.at("script[@src='/core/screw.builder.js']").should exist
-              doc.at("script[@src='/core/screw.events.js']").should exist
-              doc.at("script[@src='/core/screw.behaviors.js']").should exist
-              doc.at("script[@src='/core/screw.assets.js']").should exist
+              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

data/spec/unit/unit_spec_helper.rb

@@ -1,120 +1,51 @@
 require "rubygems"
 require "spec"
-dir = File.dirname(__FILE__)
+require "spec/autorun"
+require "rack/test"
+ARGV.push("-b")
 
-$LOAD_PATH.unshift "#{dir}/../../lib"
+dir = File.dirname(__FILE__)
+LIBRARY_ROOT_DIR = File.expand_path("#{dir}/../..")
+$LOAD_PATH.unshift File.expand_path("#{LIBRARY_ROOT_DIR}/lib")
 require "screw_unit"
-require "hpricot"
+require "nokogiri"
 require "guid"
+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"
 
 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
+Sinatra::Application.use ShowTestExceptions
+Sinatra::Application.set :raise_errors, true
+Sinatra::Application.set :show_exceptions, false
+JsTestCore::App.set :raise_errors, true
+JsTestCore::App.set :show_exceptions, false
 
-class Spec::Example::ExampleGroup
-  class << self
-    def thin_logging
-      @thin_logging = true if @thin_logging.nil?
-      @thin_logging
-    end
-
-    attr_writer :thin_logging
-  end
-end
+Sinatra::Application.use(ScrewUnit::App)
 
-module Spec::Example::ExampleMethods
-  attr_reader :spec_root_path, :implementation_root_path, :public_path, :server, :connection
+class Spec::ExampleGroup
+  include Rack::Test::Methods
+  include BeHttp
+  
+  attr_reader :spec_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)
+    JsTestCore::Configuration.instance.spec_root_path = spec_root_path
+    JsTestCore::Configuration.instance.public_path = public_path
   end
 
-  def put(url, params={})
-    request(:put, url, params)
+  def app
+    Sinatra::Application
   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