patch 0.4.13

data/test/js/qunit.css

@@ -0,0 +1,291 @@
+/*!
+ * QUnit 1.18.0
+ * http://qunitjs.com/
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license
+ * http://jquery.org/license
+ *
+ * Date: 2015-04-03T10:23Z
+ */
+
+/** Font Family and Sizes */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
+	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
+}
+
+#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
+#qunit-tests { font-size: smaller; }
+
+
+/** Resets */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
+	margin: 0;
+	padding: 0;
+}
+
+
+/** Header */
+
+#qunit-header {
+	padding: 0.5em 0 0.5em 1em;
+
+	color: #8699A4;
+	background-color: #0D3349;
+
+	font-size: 1.5em;
+	line-height: 1em;
+	font-weight: 400;
+
+	border-radius: 5px 5px 0 0;
+}
+
+#qunit-header a {
+	text-decoration: none;
+	color: #C2CCD1;
+}
+
+#qunit-header a:hover,
+#qunit-header a:focus {
+	color: #FFF;
+}
+
+#qunit-testrunner-toolbar label {
+	display: inline-block;
+	padding: 0 0.5em 0 0.1em;
+}
+
+#qunit-banner {
+	height: 5px;
+}
+
+#qunit-testrunner-toolbar {
+	padding: 0.5em 1em 0.5em 1em;
+	color: #5E740B;
+	background-color: #EEE;
+	overflow: hidden;
+}
+
+#qunit-userAgent {
+	padding: 0.5em 1em 0.5em 1em;
+	background-color: #2B81AF;
+	color: #FFF;
+	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
+}
+
+#qunit-modulefilter-container {
+	float: right;
+	padding: 0.2em;
+}
+
+.qunit-url-config {
+	display: inline-block;
+	padding: 0.1em;
+}
+
+.qunit-filter {
+	display: block;
+	float: right;
+	margin-left: 1em;
+}
+
+/** Tests: Pass/Fail */
+
+#qunit-tests {
+	list-style-position: inside;
+}
+
+#qunit-tests li {
+	padding: 0.4em 1em 0.4em 1em;
+	border-bottom: 1px solid #FFF;
+	list-style-position: inside;
+}
+
+#qunit-tests > li {
+	display: none;
+}
+
+#qunit-tests li.running,
+#qunit-tests li.pass,
+#qunit-tests li.fail,
+#qunit-tests li.skipped {
+	display: list-item;
+}
+
+#qunit-tests.hidepass li.running,
+#qunit-tests.hidepass li.pass {
+	visibility: hidden;
+	position: absolute;
+	width:   0px;
+	height:  0px;
+	padding: 0;
+	border:  0;
+	margin:  0;
+}
+
+#qunit-tests li strong {
+	cursor: pointer;
+}
+
+#qunit-tests li.skipped strong {
+	cursor: default;
+}
+
+#qunit-tests li a {
+	padding: 0.5em;
+	color: #C2CCD1;
+	text-decoration: none;
+}
+
+#qunit-tests li p a {
+	padding: 0.25em;
+	color: #6B6464;
+}
+#qunit-tests li a:hover,
+#qunit-tests li a:focus {
+	color: #000;
+}
+
+#qunit-tests li .runtime {
+	float: right;
+	font-size: smaller;
+}
+
+.qunit-assert-list {
+	margin-top: 0.5em;
+	padding: 0.5em;
+
+	background-color: #FFF;
+
+	border-radius: 5px;
+}
+
+.qunit-collapsed {
+	display: none;
+}
+
+#qunit-tests table {
+	border-collapse: collapse;
+	margin-top: 0.2em;
+}
+
+#qunit-tests th {
+	text-align: right;
+	vertical-align: top;
+	padding: 0 0.5em 0 0;
+}
+
+#qunit-tests td {
+	vertical-align: top;
+}
+
+#qunit-tests pre {
+	margin: 0;
+	white-space: pre-wrap;
+	word-wrap: break-word;
+}
+
+#qunit-tests del {
+	background-color: #E0F2BE;
+	color: #374E0C;
+	text-decoration: none;
+}
+
+#qunit-tests ins {
+	background-color: #FFCACA;
+	color: #500;
+	text-decoration: none;
+}
+
+/*** Test Counts */
+
+#qunit-tests b.counts                       { color: #000; }
+#qunit-tests b.passed                       { color: #5E740B; }
+#qunit-tests b.failed                       { color: #710909; }
+
+#qunit-tests li li {
+	padding: 5px;
+	background-color: #FFF;
+	border-bottom: none;
+	list-style-position: inside;
+}
+
+/*** Passing Styles */
+
+#qunit-tests li li.pass {
+	color: #3C510C;
+	background-color: #FFF;
+	border-left: 10px solid #C6E746;
+}
+
+#qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
+#qunit-tests .pass .test-name               { color: #366097; }
+
+#qunit-tests .pass .test-actual,
+#qunit-tests .pass .test-expected           { color: #999; }
+
+#qunit-banner.qunit-pass                    { background-color: #C6E746; }
+
+/*** Failing Styles */
+
+#qunit-tests li li.fail {
+	color: #710909;
+	background-color: #FFF;
+	border-left: 10px solid #EE5757;
+	white-space: pre;
+}
+
+#qunit-tests > li:last-child {
+	border-radius: 0 0 5px 5px;
+}
+
+#qunit-tests .fail                          { color: #000; background-color: #EE5757; }
+#qunit-tests .fail .test-name,
+#qunit-tests .fail .module-name             { color: #000; }
+
+#qunit-tests .fail .test-actual             { color: #EE5757; }
+#qunit-tests .fail .test-expected           { color: #008000; }
+
+#qunit-banner.qunit-fail                    { background-color: #EE5757; }
+
+/*** Skipped tests */
+
+#qunit-tests .skipped {
+	background-color: #EBECE9;
+}
+
+#qunit-tests .qunit-skipped-label {
+	background-color: #F4FF77;
+	display: inline-block;
+	font-style: normal;
+	color: #366097;
+	line-height: 1.8em;
+	padding: 0 0.5em;
+	margin: -0.4em 0.4em -0.4em 0;
+}
+
+/** Result */
+
+#qunit-testresult {
+	padding: 0.5em 1em 0.5em 1em;
+
+	color: #2B81AF;
+	background-color: #D2E0E6;
+
+	border-bottom: 1px solid #FFF;
+}
+#qunit-testresult .module-name {
+	font-weight: 700;
+}
+
+/** Fixture */
+
+#qunit-fixture {
+	position: absolute;
+	top: -10000px;
+	left: -10000px;
+	width: 1000px;
+	height: 1000px;
+}

data/test/js/test.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Patch Tests</title>
+  <link rel="stylesheet" href="qunit.css">
+  <script src="../../js/patch.Websocket.js"></script>
+</head>
+<body>
+  <div id="qunit"></div>
+  <div id="qunit-fixture"></div>
+  <script src="qunit-1.18.0.js"></script>
+  <script src="logger.js"></script>
+</body>
+</html>

data/test/js/websocket.js

@@ -0,0 +1,12 @@
+var config;
+
+module("VZ.Config", {
+  setup: function() {
+    config = new VZ.Config();
+  }, teardown: function() {
+    delete config;
+  }
+});
+test( "new", function() {
+  ok( (config !== undefined && config !== null), "config is initialized" );
+});

data/test/log_test.rb

@@ -0,0 +1,96 @@
+require "helper"
+
+class Patch::LogTest < Minitest::Test
+
+  context "Log" do
+
+    setup do
+      @out = Object.new
+    end
+
+    context "#exception" do
+
+      should "display exception" do
+        message = "blah blah"
+        @out.expects(:puts).once
+        @log = Patch::Log.new(@out)
+        begin
+          raise(message)
+        rescue Exception => e
+          @log.exception(e)
+        end
+      end
+
+    end
+
+    context "#info" do
+
+      should "display message" do
+        message = "blah blah"
+        @out.expects(:puts).once
+        @log = Patch::Log.new(@out)
+        @log.info(message)
+      end
+
+    end
+
+    context "#populate_level" do
+
+      setup do
+        @message = "blah blah"
+        @error = "error!"
+      end
+
+      should "only output info" do
+        @log = Patch::Log.new(@out, :show => :info)
+        refute @log.instance_variable_get("@exception")
+        assert @log.instance_variable_get("@info")
+        @out.expects(:puts).once
+        output = Object.new
+        output.expects(:colorize).once.with(:blue)
+        @log.expects(:format).once.with(@message, :type => :info).returns(output)
+        @log.info(@message)
+        begin
+          raise(@error)
+        rescue Exception => e
+          @log.exception(e)
+        end
+      end
+
+      should "only output exception" do
+        @log = Patch::Log.new(@out, :show => :exception)
+        assert @log.instance_variable_get("@exception")
+        refute @log.instance_variable_get("@info")
+        @out.expects(:puts).once
+        output = Object.new
+        output.expects(:colorize).once.with(:red)
+        @log.expects(:format).once.with(@error, :type => :exception).returns(output)
+        begin
+          raise(@error)
+        rescue Exception => e
+          @log.exception(e)
+        end
+      end
+
+      should "show everything" do
+        @log = Patch::Log.new(@out)
+        assert @log.instance_variable_get("@exception")
+        assert @log.instance_variable_get("@info")
+        @out.expects(:puts).twice
+        output = Object.new
+        output.expects(:colorize).once.with(:red)
+        output.expects(:colorize).once.with(:blue)
+        @log.expects(:format).once.with(@error, :type => :exception).returns(output)
+        @log.expects(:format).once.with(@message, :type => :info).returns(output)
+        begin
+          raise(@error)
+        rescue Exception => e
+          @log.exception(e)
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/message_test.rb

@@ -0,0 +1,109 @@
+require "helper"
+
+class Patch::MessageTest < Minitest::Test
+
+  context "Message" do
+
+    setup do
+      @message = Patch::Message.new
+    end
+
+    context "#to_h" do
+
+      setup do
+        @message.index = 1
+        @message.value = 100
+        @message.patch_name = :test
+      end
+
+      should "have basic properties" do
+        @result = @message.to_h
+        refute_nil @result
+        refute_empty @result
+        refute_nil @result[:index]
+        refute_nil @result[:value]
+        refute_nil @result[:patch_name]
+        refute_nil @result[:timestamp]
+        assert_equal 1, @result[:index]
+        assert_equal 100, @result[:value]
+        assert_equal :test, @result[:patch_name]
+      end
+
+      should "have properties from hash" do
+        @message.send(:populate_from_properties, { :a_property => "hello!" })
+        @result = @message.to_h
+        refute_nil @result
+        refute_nil @result[:a_property]
+        assert_equal "hello!", @result[:a_property]
+      end
+
+    end
+
+    context "#to_json" do
+
+      setup do
+        @message.index = 10
+        @message.value = 200
+        @message.patch_name = :test
+      end
+
+      should "have all of the message properties" do
+        hash = @message.to_h
+        json = @message.to_json
+        hash.each do |key, value|
+          assert json.include?(key.to_s)
+          assert json.include?(value.to_s)
+        end
+      end
+
+    end
+
+    context "#timestamp" do
+
+      should "return js int time format" do
+        result = @message.timestamp
+        refute_nil result
+        assert_equal Fixnum, result.class
+        assert result.to_s.size > Time.new.to_i.to_s.size
+        assert_equal (result / 1000).to_s.size, Time.new.to_i.to_s.size
+      end
+
+    end
+
+    context "#timestamp_to_time" do
+
+      should "return Ruby time format" do
+        result = @message.send(:timestamp_to_time, 1413332943271)
+        refute_nil result
+        assert_equal Time, result.class
+        assert_equal 2014, result.year
+      end
+
+    end
+
+    context "#populate_from_properties" do
+
+      setup do
+        @hash = {
+          :index => 2,
+          :value => "blah",
+          :patch_name => :test,
+          :another_property => "something"
+        }
+        @message.send(:populate_from_properties, @hash)
+      end
+
+      should "have properties from hash" do
+        refute_nil @message.index
+        refute_nil @message.value
+        refute_nil @message.patch_name
+        assert_equal 2, @message.index
+        assert_equal "blah", @message.value
+        assert_equal :test, @message.patch_name
+      end
+
+    end
+
+  end
+
+end

data/test/node/container_test.rb

@@ -0,0 +1,104 @@
+require "helper"
+
+class Patch::Node::ContainerTest < Minitest::Test
+
+  context "Container" do
+
+    setup do
+      @nodes_hash = {
+        :nodes => [
+          {
+            :id => 1,
+            :type => "websocket",
+            :host => "localhost",
+            :port => 9006
+          },
+          {
+            :id => 2,
+            :type => "midi",
+            :direction => "input",
+            :name => "Apple Inc. IAC Driver"
+          },
+          {
+            :id => 3,
+            :type => "osc",
+            :server => {
+              :port => 8000
+            },
+            :client => {
+              :host => "192.168.1.118",
+              :port => 9000
+            }
+          }
+        ]
+      }.freeze
+      @nodes = Patch::Config.to_nodes(@nodes_hash)
+    end
+
+    context "#find_all_by_type" do
+
+      should "return osc nodes" do
+        nodes = @nodes.find_all_by_type(:osc)
+        refute_nil nodes
+        refute_empty nodes
+        assert nodes.all? { |node| node.class.name.match(/\APatch\:\:IO\:\:OSC/) }
+      end
+
+      should "return midi nodes" do
+        nodes = @nodes.find_all_by_type(:midi)
+        refute_nil nodes
+        refute_empty nodes
+        assert nodes.all? { |node| node.class.name.match(/\APatch\:\:IO\:\:MIDI/)  }
+      end
+
+      should "return websocket nodes" do
+        nodes = @nodes.find_all_by_type(:websocket)
+        refute_nil nodes
+        refute_empty nodes
+        assert nodes.all? { |node| node.class.name.match(/\APatch\:\:IO\:\:Websocket/)  }
+      end
+
+      should "not return non existant nodes" do
+        nodes = @nodes.find_all_by_type(:http)
+        refute_nil nodes
+        assert_empty nodes
+      end
+
+    end
+
+    context "#enable" do
+
+      setup do
+        @node_classes = [Patch::IO::MIDI::Input, Patch::IO::OSC::Server, Patch::IO::Websocket::Node]
+        @node_classes.each { |c| c.any_instance.expects(:start).once }
+      end
+
+      teardown do
+        @node_classes.each { |c| c.any_instance.unstub(:start) }
+      end
+
+      should "enable nodes" do
+        assert @nodes.enable
+      end
+
+    end
+
+    context "#find_by_id" do
+
+      should "return node with id" do
+        node = @nodes.find_by_id(2)
+        refute_nil node
+        refute_nil node.id
+        assert_equal 2, node.id
+      end
+
+      should "return nil if not found" do
+        node = @nodes.find_by_id(99)
+        assert_nil node
+      end
+
+    end
+
+  end
+
+end

data/test/node/map_test.rb

@@ -0,0 +1,50 @@
+require "helper"
+
+class Patch::Node::MapTest < Minitest::Test
+
+  context "Map" do
+
+    setup do
+      load_test_data
+      @nodes = Patch::Config.to_nodes(@nodes_path)
+      @patches = Patch::Config.to_patches(@nodes, @patches_path)
+    end
+
+    context "#nodes" do
+
+      setup do
+        @map = @patches.first.maps.first
+      end
+
+      should "return all from and to nodes" do
+        @nodes = @map.nodes
+        refute_nil @nodes
+        refute_empty @nodes
+        assert @map.from.all? { |node| @nodes.include?(node) }
+        assert @map.to.all? { |node| @nodes.include?(node) }
+      end
+
+    end
+
+    context "#enable" do
+
+      setup do
+        @maps = @patches.first.maps
+        refute_empty @nodes
+        assert [Patch::IO::MIDI::Input, Patch::IO::OSC::Server, Patch::IO::Websocket::Node].all? { |klass| @nodes.map(&:class).include?(klass) }
+        ::Patch::Thread.expects(:new).times(@nodes.count)
+      end
+
+      teardown do
+        ::Patch::Thread.unstub(:new)
+      end
+
+      should "create node start threads" do
+        assert @maps.first.enable(@patches.first)
+      end
+
+    end
+
+  end
+
+end

data/test/node_test.rb

@@ -0,0 +1,14 @@
+require "helper"
+
+class Patch::NodeTest < Minitest::Test
+
+  context "Node" do
+
+    should "load classes" do
+      refute_nil Patch::Node::Container
+      refute_nil Patch::Node::Map
+    end
+    
+  end
+
+end