patch 0.4.13

data/test/io/osc_test.rb

@@ -0,0 +1,111 @@
+require "helper"
+
+class Patch::IO::OSCTest < Minitest::Test
+
+  context "OSC" do
+
+    context "#new_from_config" do
+
+      context "server" do
+
+        setup do
+          @config = {
+            :id => 3,
+            :type => "osc",
+            :server => {
+              :port => 8000
+            }
+          }
+          @server = Patch::IO::OSC.new_from_config(@config)
+        end
+
+        should "be server" do
+          refute_nil @server
+          assert Patch::IO::OSC::Server, @server.class
+        end
+
+        should "have id" do
+          refute_nil @server.id
+          assert_equal 3, @server.id
+        end
+
+        should "not initialize client" do
+          assert_nil @server.instance_variable_get("@client")
+        end
+
+        should "initialize server" do
+          refute_nil @server.instance_variable_get("@server")
+        end
+
+      end
+
+      context "server with echo" do
+
+        setup do
+          @config = {
+            :id => 4,
+            :type => "osc",
+            :client => {
+              :host => "192.168.1.118",
+              :port => 9000
+            },
+            :server => {
+              :port => 8000
+            }
+          }
+          @server = Patch::IO::OSC.new_from_config(@config)
+        end
+
+        should "be server" do
+          refute_nil @server
+          assert Patch::IO::OSC::Server, @server.class
+        end
+
+        should "have id" do
+          refute_nil @server.id
+          assert_equal 4, @server.id
+        end
+
+        should "initialize echo client" do
+          refute_nil @server.instance_variable_get("@client")
+        end
+
+        should "initialize server" do
+          refute_nil @server.instance_variable_get("@server")
+        end
+
+      end
+
+      context "client" do
+
+        setup do
+          @config = {
+            :id => 5,
+            :type => "osc",
+            :client => {
+              :host => "192.168.1.118",
+              :port => 9000
+            }
+          }
+          @client = ::Patch::IO::OSC.new_from_config(@config)
+        end
+
+        should "be client" do
+          refute_nil @client
+          assert Patch::IO::OSC::Client, @client.class
+        end
+
+        should "have id" do
+          refute_nil @client.id
+          assert_equal 5, @client.id
+        end
+
+        should "initialize underlying client" do
+          refute_nil @client.instance_variable_get("@client")
+        end
+
+      end
+
+    end
+  end
+end

data/test/io/websocket/node_test.rb

@@ -0,0 +1,96 @@
+require "helper"
+
+class Patch::IO::Websocket::NodeTest < Minitest::Test
+
+  context "Node" do
+
+    setup do
+      load_test_data
+      @nodes = Patch::Config.to_nodes(@nodes_path)
+      @patches = Patch::Config.to_patches(@nodes, @patches_path)
+      @server = @nodes.find_all_by_type(:websocket).first
+    end
+
+    context "#listen" do
+
+      setup do
+        EM::WebSocket.expects(:run).once
+      end
+
+      teardown do
+        EM::WebSocket.unstub(:run)
+        #Patch::IO::Websocket.any_instance.unstub(:start)
+      end
+
+      should "start server" do
+        assert @server.listen(@patches.first) do
+          @val = "something"
+        end
+      end
+
+    end
+
+    context "#start" do
+
+      setup do
+        EM::WebSocket.expects(:run).once
+      end
+
+      teardown do
+        EM::WebSocket.unstub(:run)
+        #Patch::IO::Websocket.any_instance.unstub(:start)
+      end
+
+      should "start server" do
+        assert @server.start
+      end
+
+    end
+
+    context "#puts" do
+
+      setup do
+        @message = Patch::Message.new
+        @message.index = 1
+        @message.value = 100
+        @message.patch_name = :test
+      end
+
+      should "convert message to json" do
+        @server.stubs(:running?).returns(true)
+        @server.instance_variable_set("@socket", Object.new)
+        @server.instance_variable_get("@socket").expects(:puts).once
+        assert @server.puts(@patches.first, @message)
+      end
+
+    end
+
+    context "#handle_input" do
+
+      setup do
+        @timestamp = 1396406728702
+        hash = {
+          :value => "blah",
+          :timestamp => @timestamp
+        }
+        @message = hash.to_json
+        @result = @server.send(:handle_input, nil, @message)
+      end
+
+      should "convert from String to Message" do
+        refute_nil @result
+        assert_equal ::Patch::Message, @result.class
+        assert_equal "blah", @result.value
+      end
+
+      should "convert timestamp from js time to ruby" do
+        time = @result.time
+        refute_nil time
+        assert_equal Time.at(@timestamp / 1000), time
+      end
+
+    end
+
+  end
+
+end

data/test/io/websocket_test.rb

@@ -0,0 +1,37 @@
+require "helper"
+
+class Patch::IO::WebsocketTest < Minitest::Test
+
+  context "Websocket" do
+
+    context "#new_from_config" do
+
+      setup do
+        @config = {
+          :id => 6,
+          :type => "websocket",
+          :host => "localhost",
+          :port => 9006
+        }
+        @websocket = Patch::IO::Websocket.new_from_config(@config)
+      end
+
+      should "be node" do
+        refute_nil @websocket
+        assert Patch::IO::Websocket::Node, @websocket.class
+      end
+
+      should "have id" do
+        refute_nil @websocket.id
+        assert_equal 6, @websocket.id
+      end
+
+      should "not initialize underlying socket yet" do
+        assert_nil @websocket.instance_variable_get("@socket")
+      end
+
+    end
+
+  end
+
+end

data/test/js/logger.js

@@ -0,0 +1,67 @@
+MockConsole = function() {
+  this._last;
+}
+MockConsole.prototype.log = function(something) {
+  this._last = something;
+  return true;
+}
+MockConsole.prototype.error = MockConsole.prototype.log;
+MockConsole.prototype.last = function() {
+  var last = this._last;
+  delete this._last;
+  return last;
+}
+
+LOGMESSAGE = {
+  closed: "Closed",
+  prefix: "Test: ",
+  open: "Open"
+}
+
+var logger;
+var fakeConsole = new MockConsole();
+
+module("Patch.Logger", {
+  setup: function() {
+    logger = new Patch.Logger(LOGMESSAGE, fakeConsole);
+  }, teardown: function() {
+    delete logger;
+  }
+});
+test( "new", function(assert) {
+  assert.ok( (logger !== undefined && logger !== null), "logger is initialized" );
+});
+test( "info", function(assert) {
+  assert.ok(logger.info("hello"), "info method is called" );
+  assert.equal(fakeConsole.last(), "Test: hello", "message is sent to underlying logger" );
+});
+test( "object", function(assert) {
+  var obj = {something:"hello"};
+  assert.ok(logger.object(obj), "object method is called" );
+  assert.equal(fakeConsole.last(), obj, "object is sent to underlying logger" );
+});
+test( "debug", function(assert) {
+  // not enabled
+  logger.shouldDebug = false;
+  assert.notOk(logger.debug("hello"), "debug method is called" );
+  assert.equal(fakeConsole.last(), undefined, "message is not sent to underlying logger" );
+  // enabled
+  logger.shouldDebug = true;
+  assert.ok(logger.debug("hello"), "debug method is called" );
+  assert.equal(fakeConsole.last(), "Test: hello", "message is sent to underlying logger" );
+});
+test( "debugObject", function(assert) {
+  // not enabled
+  logger.shouldDebug = false;
+  var obj = {something:"hello"};
+  assert.notOk(logger.debugObject(obj), "debugObject method is called" );
+  assert.equal(fakeConsole.last(), undefined, "object is not sent to underlying logger" );
+  // enabled
+  logger.shouldDebug = true;
+  assert.ok(logger.debugObject(obj), "debugObject method is called" );
+  assert.equal(fakeConsole.last(), obj, "object is sent to underlying logger" );
+});
+test( "error", function(assert) {
+  assert.ok(logger.error("hello"), "error method is called" );
+  assert.equal(fakeConsole.last(), "hello", "error is sent to underlying logger" );
+});

data/test/js/message.js

@@ -0,0 +1,62 @@
+var camera;
+var number;
+
+module("VZ.Camera", {
+  setup: function() {
+    camera = new VZ.Camera();
+    number = Math.floor((Math.random() * 100) + 1);
+  }, teardown: function() {
+    delete camera;
+    delete number;
+  }
+});
+test( "new", function() {
+  ok( (camera !== undefined && camera !== null), "camera is initialized" );
+});
+test( "position.set", function() {
+  camera.position.set(1,2,3);
+  equal(camera.position.x, 1);
+  equal(camera.position.y, 2);
+  equal(camera.position.z, 3);
+});
+test( "position=", function() {
+  camera.position.x = 10;
+  camera.position.y = 20;
+  camera.position.z = 30;
+  equal(camera.position.x, 10);
+  equal(camera.position.y, 20);
+  equal(camera.position.z, 30);
+});
+test( "saveState", function() {
+  camera.position.set(1,2,3);
+  camera.aspect = 30;
+  camera.fov = 40;
+  camera.near = 50;
+  camera.far = 60;
+  camera.saveState(number);
+  equal(camera.state[number].aspect, 30, "aspect");
+  equal(camera.state[number].fov, 40, "fov");
+  equal(camera.state[number].near, 50, "near");
+  equal(camera.state[number].far, 60, "far");
+  equal(camera.state[number].position.x, 1, "x");
+  equal(camera.state[number].position.y, 2, "y");
+  equal(camera.state[number].position.z, 3, "z");
+});
+test( "restoreState", function() {
+  camera.state[number] = {
+    aspect: 123,
+    fov: 234,
+    near: 345,
+    far: 456,
+    position: new THREE.Vector3(9, 10, 11),
+    target: new THREE.Vector3(13, 14, 15)
+  }
+  camera.restoreState(number);
+  equal(camera.aspect, 123, "aspect");
+  equal(camera.fov, 234, "fov");
+  equal(camera.near, 345, "near");
+  equal(camera.far, 456, "far");
+  equal(camera.position.x, 9, "x");
+  equal(camera.position.y, 10, "y");
+  equal(camera.position.z, 11, "z");
+});