js-test-server 0.2.1 → 0.2.6

data/public/js_test_server/jasmine_driver.js

@@ -0,0 +1,62 @@
+JsTestServer.JasmineDriver = {};
+
+JsTestServer.JasmineDriver.init = function() {
+  JsTestServer.JasmineDriver.instance = new JsTestServer.JasmineDriver.Instance();
+  JsTestServer.JasmineDriver.instance.start();
+};
+
+JsTestServer.JasmineDriver.Instance = function() {
+};
+
+(function(Instance) {
+  var jsTestServerConsole = "";
+  var reporter;
+
+  Instance.prototype.start = function() {
+    this.addJasmineReporter();
+    this.defineStatusMethod();
+    this.startJasmine();
+  };
+
+  Instance.prototype.addJasmineReporter = function() {
+    reporter = new JsTestServer.JasmineDriver.Reporter();
+    jasmine.getEnv().addReporter(reporter);
+  };
+
+  Instance.prototype.defineStatusMethod = function() {
+    JsTestServer.status = function() {
+      var runnerState;
+      if(jasmine.getEnv().currentRunner.finished) {
+        if(jasmine.getEnv().currentRunner.getResults().failedCount == 0) {
+          runnerState = "passed";
+        } else {
+          runnerState = "failed";
+        }
+      } else {
+        runnerState = "running";
+      }
+
+      return JsTestServer.JSON.stringify({
+        "runner_state": runnerState,
+        "console": jsTestServerConsole
+      });
+    };
+  };
+
+  Instance.prototype.startJasmine = function() {
+    var jasmineEnv = jasmine.getEnv();
+    var jsApiReporter = new jasmine.JsApiReporter();
+    jasmineEnv.addReporter(jsApiReporter);
+    jasmineEnv.addReporter(new jasmine.TrivialReporter());
+    window.onload = function() {
+      jasmineEnv.execute();
+    };
+  };
+
+  JsTestServer.JasmineDriver.Reporter = function() {
+  };
+  JsTestServer.JasmineDriver.Reporter.prototype.log = function(str) {
+    jsTestServerConsole += str;
+    jsTestServerConsole += "\n";
+  };
+})(JsTestServer.JasmineDriver.Instance);

data/public/js_test_server/remote_control.js

@@ -0,0 +1,28 @@
+(function() {
+  JsTestServer.RemoteControl = function() {
+  };
+
+  JsTestServer.RemoteControl.start = function() {
+    var instance = new JsTestServer.RemoteControl();
+    instance.start();
+  };
+
+  JsTestServer.RemoteControl.prototype.start = function() {
+    this.poll();
+  };
+
+  JsTestServer.RemoteControl.prototype.poll = function() {
+    var self = this;
+    JsTestServer.xhrGet("/remote_control/commands", function(request) {
+      if(request.status == 200) {
+        var messages = eval(request.responseText);
+        for(var i=0; i < messages.length; i++) {
+          eval(messages[i].javascript);
+        }
+        setTimeout(function() {
+          self.poll();
+        }, 100);
+      };
+    });
+  };
+})();

data/public/js_test_server/screw_unit_driver.js

@@ -0,0 +1,31 @@
+(function($) {
+  var jsTestServerStatus = {"runner_state": "running", "console": ""};
+
+  JsTestServer.status = function() {
+    return JsTestServer.JSON.stringify(jsTestServerStatus);
+  };
+
+  $(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");
+
+    jsTestServerStatus["console"] = error_text;
+    if(error_text) {
+      jsTestServerStatus["runner_state"] = "failed";
+    } else {
+      jsTestServerStatus["runner_state"] = "passed";
+    }
+  });
+})(jQuery);

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

@@ -6,8 +6,8 @@ module JsTestServer::Server::Resources
       attr_reader :doc
       before do
         JsTestServer.framework_name = "screw-unit"
-        JsTestServer::Server::Representations::Suite.project_js_files += ["/javascripts/test_file_1.js", "/javascripts/test_file_2.js"]
-        JsTestServer::Server::Representations::Suite.project_css_files += ["/stylesheets/test_file_1.css", "/stylesheets/test_file_2.css"]
+        JsTestServer::Server::Views::Suite.project_js_files += ["/javascripts/test_file_1.js", "/javascripts/test_file_2.js"]
+        JsTestServer::Server::Views::Suite.project_css_files += ["/stylesheets/test_file_1.css", "/stylesheets/test_file_2.css"]
 
         response = get(SpecFile.path("/failing_spec"))
         response.should be_http( 200, {}, "" )
@@ -16,8 +16,8 @@ module JsTestServer::Server::Resources
       end
 
       after do
-        JsTestServer::Server::Representations::Suite.project_js_files.clear
-        JsTestServer::Server::Representations::Suite.project_css_files.clear
+        JsTestServer::Server::Views::Suite.project_js_files.clear
+        JsTestServer::Server::Views::Suite.project_css_files.clear
       end
 
       it "renders project js files" do

data/spec/unit/js_test_core/server/server_spec.rb

@@ -21,7 +21,7 @@ module JsTestServer::Server
 
       
       context "when the --framework-name and --framework-path are set" do
-        it "starts the server and sets SpecFile::suite_representation_class to be the ScrewUnit suite" do
+        it "starts the server and sets SpecFile::suite_view_class to be the ScrewUnit suite" do
           project_spec_dir = File.expand_path("#{File.dirname(__FILE__)}/../../..")
 
           mock.proxy(Thin::Runner).new(["--port", "8081", "--rackup", rackup_path, "start"]) do |runner|
@@ -43,7 +43,43 @@ module JsTestServer::Server
             "--port", "8081"
           )
 
-          JsTestServer::Configuration.instance.suite_representation_class.should == JsTestServer::Server::Representations::Suites::ScrewUnit
+          JsTestServer::Configuration.instance.suite_view_class.should == JsTestServer::Server::Views::Suites::ScrewUnit
+        end
+      end
+
+      context "when --javascript-files and --css-files are set" do
+        it "causes the suite_view_class to load the javascript and css files" do
+          project_spec_dir = File.expand_path("#{File.dirname(__FILE__)}/../../..")
+
+          mock.proxy(Thin::Runner).new(["--port", "8081", "--rackup", rackup_path, "start"]) do |runner|
+            mock(runner).run!
+          end
+
+          stub.proxy(Rack::Builder).new do |builder|
+            mock.proxy(builder).use(JsTestServer::Server::App)
+            stub.proxy(builder).use
+            mock(builder).run(is_a(JsTestServer::Server::App))
+            mock(builder).run(is_a(Sinatra::Application))
+          end
+
+          server.cli(
+            "--framework-name", "screw-unit",
+            "--framework-path", "#{project_spec_dir}/example_framework",
+            "--root-path", "#{project_spec_dir}/example_root",
+            "--spec-path", "#{project_spec_dir}/example_spec",
+            "--port", "8081",
+            "--javascript-files", "/javascripts/foo.js,/javascipts/large_file.js,/specs/spec_helper.js",
+            "--css-files", "/stylesheets/example.css"
+          )
+
+          JsTestServer::Configuration.instance.suite_view_class.project_js_files.should == [
+            "/javascripts/foo.js",
+            "/javascipts/large_file.js",
+            "/specs/spec_helper.js"
+          ]
+          JsTestServer::Configuration.instance.suite_view_class.project_css_files.should == [
+            "/stylesheets/example.css",
+          ]
         end
       end
 

data/vendor/lucky-luciano/lib/lucky_luciano.rb

@@ -0,0 +1,5 @@
+require "sinatra/base"
+
+dir = File.dirname(__FILE__)
+require "#{dir}/lucky_luciano/resource"
+require "#{dir}/lucky_luciano/resource/path"

data/vendor/lucky-luciano/lib/lucky_luciano/resource.rb

@@ -0,0 +1,142 @@
+module LuckyLuciano
+  class Resource
+    class << self
+      attr_reader :base_path_definition
+
+      def map(base_path_definition)
+        @base_path_definition = base_path_definition
+      end
+
+      def recorded_http_handlers
+        @recorded_http_handlers ||= []
+      end
+
+      def route_handler
+        create_sinatra_handler
+      end
+
+      ["get", "put", "post", "delete"].each do |http_verb|
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{http_verb}(relative_path, opts={}, &block)
+          recorded_http_handlers << [:#{http_verb}, relative_path, opts, block]
+        end
+        RUBY
+      end
+
+      def [](sub_path=nil)
+        Path.new(self, sub_path)
+      end
+
+      def path(*sub_paths)
+        params = sub_paths.last.is_a?(Hash) ? sub_paths.pop : {}
+
+        sub_path_definition = sub_paths.join("/")
+
+        full_path = normalize_seperators("#{base_path(params)}/#{path_from_definition(sub_path_definition, params)}").gsub(/\/$/, "")
+
+        base_path_param_keys = param_keys_from(base_path_definition)
+        query_params = params.delete_if do |key, value|
+          base_path_param_keys.include?(key)
+        end
+
+        sub_path_param_keys = param_keys_from(sub_path_definition)
+        query_params = params.delete_if do |key, value|
+          sub_path_param_keys.include?(key)
+        end
+
+        if query_params.empty?
+          full_path
+        else
+          query = build_query(query_params)
+          "#{full_path}?#{query}"
+        end
+      end
+
+      def base_path(params={})
+        path_from_definition(base_path_definition, params)
+      end
+
+      def normalize_seperators(url)
+        url.gsub(Regexp.new("//+"), '/')
+      end
+
+      protected
+
+      def path_from_definition(definition, params={})
+        param_keys = param_keys_from(definition)
+        if param_keys.empty?
+          definition.dup
+        else
+          param_keys.each do |base_path_param|
+            unless params.include?(base_path_param.to_sym)
+              raise ArgumentError, "Expected #{base_path_param.inspect} to have a value"
+            end
+          end
+          definition.split("/").map do |segment|
+            if param_key = segment_param_key(segment)
+              params[param_key]
+            else
+              segment
+            end
+          end.join("/")
+        end
+      end
+
+      def param_keys_from(definition)
+        definition.split("/").find_all do |segment|
+          segment_param_key(segment)
+        end.map do |param|
+          param[1..-1].to_sym
+        end
+      end
+
+      def segment_param_key(segment)
+        segment[0..0] == ':' ? segment[1..-1].to_sym : nil
+      end
+
+      def build_query(params)
+        params.to_a.inject([]) do |splatted_params, (key, value)|
+          [value].flatten.each do |value_in_param|
+            splatted_params << "#{URI.escape(key.to_s)}=#{URI.escape(value_in_param.to_s)}"
+          end
+          splatted_params
+        end.join("&")
+      end
+
+      def create_sinatra_handler
+        resource_class = self
+        Module.new do
+          (class << self; self; end).class_eval do
+            define_method(:registered) do |app|
+              resource_class.recorded_http_handlers.each do |handler|
+                verb, relative_path, opts, block = handler
+                full_path = resource_class.normalize_seperators(
+                  "#{resource_class.base_path_definition}/#{relative_path}"
+                ).gsub(%r{^.+/$}) do |match|
+                    match.gsub(%r{/$}, "")
+                end
+                app.send(verb, full_path, opts) do
+                  resource_class.new(self).instance_eval(&block)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    attr_reader :app
+
+    def initialize(app)
+      @app = app
+    end
+
+    def method_missing(method_name, *args, &block)
+      if app.respond_to?(method_name)
+        app.send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/vendor/lucky-luciano/lib/lucky_luciano/resource/path.rb

@@ -0,0 +1,24 @@
+class LuckyLuciano::Resource::Path
+  attr_reader :resource, :sub_paths
+  def initialize(resource, *sub_paths)
+    @resource = resource
+    @sub_paths = sub_paths
+  end
+
+  def =~(other)
+    to_s =~ other
+  end
+
+  def [](*additional_sub_paths)
+    sub_paths.push(*additional_sub_paths)
+    self
+  end
+
+  def to_s
+    resource.path(*sub_paths)
+  end
+
+  def ==(other)
+    to_s == other.to_s
+  end
+end

data/vendor/lucky-luciano/lib/lucky_luciano/rspec.rb

@@ -0,0 +1,4 @@
+dir = File.dirname(__FILE__)
+Dir["#{dir}/rspec/**/*.rb"].each do |file|
+  require file
+end

data/vendor/lucky-luciano/lib/lucky_luciano/rspec/be_http.rb

@@ -0,0 +1,32 @@
+module BeHttp
+  include Spec::Matchers
+  def be_http(status, headers, body)
+    SimpleMatcher.new(nil) do |given, matcher|
+      description = (<<-DESC).gsub(/^ +/, "")
+      be an http of
+      expected status: #{status.inspect}
+      actual status  : #{given.status.inspect}
+
+      expected headers containing: #{headers.inspect}
+      actual headers             : #{given.headers.inspect}
+
+      expected body containing: #{body.inspect}
+      actual body             : #{given.body.inspect}
+      DESC
+      matcher.failure_message = description
+      matcher.negative_failure_message = "not #{description}"
+
+      passed = true
+      unless given.status == status
+        passed = false
+      end
+      unless headers.all?{|k, v| given.headers[k] == headers[k]}
+        passed = false
+      end
+      unless body.is_a?(Regexp) ? given.body =~ body : given.body.include?(body)
+        passed = false
+      end
+      passed
+    end
+  end
+end

data/vendor/lucky-luciano/spec/lucky_luciano/resource_spec.rb

@@ -0,0 +1,276 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+module LuckyLuciano
+  module ResourceSpec
+    class Root < Resource
+      map "/"
+    end
+
+    class ResourceFixture < Resource
+      map "/foobar"
+    end
+
+    class ResourceFixtureWithSubPaths < Resource
+      map "/foobar/"
+
+      get "/baz" do
+        "Response from /foobar/baz"
+      end
+
+      get "/users/:user_id" do
+        "User id is #{params[:user_id]}"
+      end
+    end
+
+    class User < Resource
+      map "/users/:user_id"
+
+      get "/friends" do
+        "User #{params['user_id']} friends"
+      end
+    end
+
+    describe Resource do
+      include ResourceSpec
+
+      before do
+        ResourceFixture.recorded_http_handlers.clear
+      end
+
+      macro("http verb") do |verb|
+        describe ".#{verb}" do
+          context "" do
+            before do
+              ResourceFixture.send(verb, "/") do
+                "He sleeps with the fishes"
+              end
+            end
+            
+            it "creates a route to #{verb.upcase} the given path that executes the given block" do
+              app.register(ResourceFixture.route_handler)
+              response = send(verb, "/foobar")
+              response.should be_http( 200, {}, "He sleeps with the fishes" )
+            end
+          end
+
+          context "when the base path is blank and the relative path is blank" do
+            before do
+              Root.send(verb, "") do
+                "Response from /"
+              end
+            end
+
+            it "creates a route to /" do
+              app.register(Root.route_handler)
+              response = send(verb, "/")
+              response.should be_http( 200, {}, "Response from /" )
+            end
+          end
+
+          context "when the relative path does not have a leading slash" do
+            before do
+              ResourceFixtureWithSubPaths.send(verb, "no_leading_slash") do
+                "Response from /foobar/no_leading_slash"
+              end
+            end
+
+            it "creates a route to #{verb.upcase} the given path that executes the given block" do
+              app.register(ResourceFixtureWithSubPaths.route_handler)
+              response = send(verb, "/foobar/no_leading_slash")
+              response.should be_http( 200, {}, "Response from /foobar/no_leading_slash" )
+            end
+          end
+
+
+          it "does not respond to another type of http request" do
+            ResourceFixture.send(verb, "/") do
+              ""
+            end
+            app.register(ResourceFixture.route_handler)
+            get("/foobar").status.should == 404 unless verb == "get"
+            put("/foobar").status.should == 404 unless verb == "put"
+            post("/foobar").status.should == 404 unless verb == "post"
+            delete("/foobar").status.should == 404 unless verb == "delete"
+          end
+
+          describe "Instance behavior" do
+            attr_reader :evaluation_target
+            before do
+              evaluation_target = nil
+              ResourceFixture.send(verb, "/") do
+                evaluation_target = self
+                ""
+              end
+              app.register(ResourceFixture.route_handler)
+
+              send(verb, "/foobar")
+              @evaluation_target = evaluation_target
+            end
+            
+            it "evaluates the block in as a Resource" do
+              evaluation_target.class.should == ResourceFixture
+            end
+
+            it "sets app to be the Sinatra context" do
+              evaluation_target.app.class.should == Sinatra::Application
+            end
+
+            it "delegates methods to the #app" do
+              return_value = nil
+              mock.proxy(evaluation_target.app).params {|val| return_value = val}
+              evaluation_target.params.should == return_value
+            end
+            
+            context "when the #app does not respond to the method" do
+              it "raises a NoMethodError from the Resource's perspective" do
+                lambda do
+                  evaluation_target.i_dont_exist
+                end.should raise_error(NoMethodError, /ResourceFixture/)
+              end
+            end
+          end
+
+        end
+      end
+
+      send("http verb", "get")
+      send("http verb", "put")
+      send("http verb", "post")
+      send("http verb", "delete")
+
+      describe ".[][]" do
+        context "when passed nothing" do
+          it "returns the base_path" do
+            ResourceFixture[].should == "/foobar"
+            ResourceFixture[][].should == "/foobar"
+          end
+        end
+
+        context "when passed a sub path" do
+          it "merges the base_path into the sub path, regardless of a / in front" do
+            ResourceFixtureWithSubPaths["/baz"].to_s.should == "/foobar/baz"
+            ResourceFixtureWithSubPaths["baz"].to_s.should == "/foobar/baz"
+          end
+
+          context "when passed a multiple sub paths" do
+            it "joins the sub paths with '/'" do
+              ResourceFixtureWithSubPaths["users"][99].should == "/foobar/users/99"
+            end
+          end
+
+          context "when passed a hash as the last argument" do
+            context "when using a single path argument" do
+              it "creates url params from the hash" do
+                path = ResourceFixtureWithSubPaths["/users/:user_id"][:user_id => 99, :single_value_param => "single_value_param_value", 'multiple_value_param[]' => [1,2,3]]
+                path.should be_url("/foobar/users/99", [
+                  "multiple_value_param[]=1",
+                  "multiple_value_param[]=2",
+                  "multiple_value_param[]=3",
+                  "single_value_param=single_value_param_value",
+                ])
+              end
+            end
+
+            context "when using multiple path arguments" do
+              it "creates url params from the hash" do
+                path = ResourceFixtureWithSubPaths["users"][99][:single_value_param => "single_value_param_value", 'multiple_value_param[]' => [1,2,3]]
+                path.should be_url("/foobar/users/99", [
+                  "multiple_value_param[]=1",
+                  "multiple_value_param[]=2",
+                  "multiple_value_param[]=3",
+                  "single_value_param=single_value_param_value",
+                ])
+              end
+            end
+            
+            def be_url(expected_path, expected_query_parts)
+              Spec::Matchers::SimpleMatcher.new("match url") do |actual|
+                uri = URI.parse(actual.to_s)
+                uri.path.should == expected_path
+                query_parts = uri.query.split("&")
+                query_parts.should =~ expected_query_parts
+              end
+            end
+          end
+        end
+      end
+
+      describe ".path" do
+        context "when passed nothing" do
+          it "returns the base_path" do
+            ResourceFixture.path.should == "/foobar"
+          end
+        end
+        
+        context "when passed a sub path" do
+          it "merges the base_path into the sub path, regardless of a / in front" do
+            ResourceFixtureWithSubPaths.path("/baz").should == "/foobar/baz"
+            ResourceFixtureWithSubPaths.path("baz").should == "/foobar/baz"
+          end
+          
+          context "when passed a multiple sub paths" do
+            it "joins the sub paths with '/'" do
+              ResourceFixtureWithSubPaths.path("users", 99).should == "/foobar/users/99"
+            end
+          end
+
+          context "when passed a hash as the last argument" do
+            context "when using a single path argument" do
+              it "creates url params from the hash" do
+                path = ResourceFixtureWithSubPaths.path(
+                  "/users/:user_id", {:user_id => 99, :single_value_param => "single_value_param_value", 'multiple_value_param[]' => [1,2,3]}
+                )
+                uri = URI.parse(path)
+                uri.path.should == "/foobar/users/99"
+                query_parts = uri.query.split("&")
+                query_parts.should =~ [
+                  "multiple_value_param[]=1",
+                  "multiple_value_param[]=2",
+                  "multiple_value_param[]=3",
+                  "single_value_param=single_value_param_value",
+                ]
+              end
+            end
+
+            context "when using multiple path arguments" do
+              it "creates url params from the hash" do
+                path = ResourceFixtureWithSubPaths.path(
+                  "users", 99, {:single_value_param => "single_value_param_value", 'multiple_value_param[]' => [1,2,3]}
+                )
+                uri = URI.parse(path)
+                uri.path.should == "/foobar/users/99"
+                query_parts = uri.query.split("&")
+                query_parts.should =~ [
+                  "multiple_value_param[]=1",
+                  "multiple_value_param[]=2",
+                  "multiple_value_param[]=3",
+                  "single_value_param=single_value_param_value",
+                ]
+              end
+            end
+          end
+        end
+        
+        context "when the base_path contains a parameter" do
+          context "when not passed" do
+            it "raises an ArgumentError" do
+              lambda do
+                User.path
+              end.should raise_error(
+                ArgumentError,
+                %r{Expected :user_id to have a value}
+              )
+            end
+          end
+
+          context "when first argument is a hash" do
+            it "returns the full path with the base path param value" do
+              User.path("friends", :user_id => 99).should == "/users/99/friends"
+            end
+          end
+        end
+      end
+    end
+  end
+
+end