patch 0.4.13

data/test/io/midi/input_test.rb

@@ -0,0 +1,130 @@
+require "helper"
+
+class Patch::IO::MIDI::InputTest < Minitest::Test
+
+  context "Input" do
+
+    setup do
+      load_test_data
+      @nodes = Patch::Config.to_nodes(@nodes_path)
+      @patches = Patch::Config.to_patches(@nodes, @patches_path)
+      @input = @nodes.find_all_by_type(:midi).first
+    end
+
+    context "#initialize" do
+
+      should "have id" do
+        refute_nil @input.id
+      end
+
+      should "have midi input" do
+        refute_nil @input
+      end
+
+      should "initialize midi listener" do
+        refute_nil @input.instance_variable_get("@listener")
+      end
+
+    end
+
+    context "#start" do
+
+      setup do
+        ::MIDIEye::Listener.any_instance.expects(:run)
+      end
+
+      teardown do
+        ::MIDIEye::Listener.any_instance.unstub(:run)
+      end
+
+      should "start listener" do
+        @input.start
+      end
+
+    end
+
+    context "#stop" do
+
+      setup do
+        refute @input.listener.running?
+        @input.start
+        assert @input.listener.running?
+      end
+
+      should "stop listener" do
+        assert @input.stop
+        sleep(0.5) # wait until listener thread is killed
+        refute @input.listener.running?
+      end
+
+    end
+
+    context "#handle_event_received" do
+
+      setup do
+        @message = MIDIMessage::ControlChange.new(0, 0x00, 0x30)
+        @patch = @patches.first
+        @scale = Object.new
+        @scale.expects(:from).once.returns(@scale)
+        @scale.expects(:to).once
+      end
+
+      teardown do
+        @scale.unstub(:from)
+        @scale.unstub(:to)
+      end
+
+      context "message value" do
+
+        setup do
+          Scale.expects(:transform).once.returns(@scale)
+        end
+
+        teardown do
+          Scale.unstub(:transform)
+        end
+
+        should "perform scaling on value" do
+          @result = @input.send(:handle_event_received, @patch, { :message => @message })
+        end
+
+      end
+
+      context "messages" do
+
+        should "return array of messages" do
+          @result = @input.send(:handle_event_received, @patch, { :message => @message })
+          refute_nil @result
+          assert_equal Array, @result.class
+          refute_empty @result
+
+          @result.each do |message|
+            assert_equal ::Patch::Message, message.class
+            assert_equal :test_patch, message.patch_name
+            refute_nil message.index
+            refute_nil message.value
+          end
+        end
+
+        should "yield array of messages" do
+          @input.send(:handle_event_received, @patch, { :message => @message }) do |hash|
+            @result = hash
+            refute_nil @result
+            assert_equal Array, @result.class
+            refute_empty @result
+
+            @result.each do |message|
+              assert_equal ::Patch::Message, message.class
+              assert_equal :test_patch, message.patch_name
+              refute_nil message.index
+              refute_nil message.value
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/test/io/midi/message_test.rb

@@ -0,0 +1,54 @@
+require "helper"
+
+class Patch::IO::MIDI::MessageTest < Minitest::Test
+
+
+  context "Message" do
+
+    setup do
+      load_test_data
+      @nodes = Patch::Config.to_nodes(@nodes_path)
+      @patches = Patch::Config.to_patches(@nodes, @patches_path)
+    end
+
+    context ".to_midi_messages" do
+
+      setup do
+        @message = Patch::Message.new(:index => 0, :patch_name => @patches.first.name, :value => 3.0)
+        @result = ::Patch::IO::MIDI::Message.to_midi_messages(@patches.first, @message)
+      end
+
+      should "have correct properties" do
+        refute_nil @result
+        refute_empty @result
+        message = @result.first
+
+        assert_equal ::MIDIMessage::ControlChange, message.class
+        assert_equal 0, message.index
+        assert_equal 75, message.value
+      end
+
+    end
+
+    context ".to_patch_messages" do
+
+      setup do
+        @message = MIDIMessage::ControlChange.new(0, 0, 127)
+        @result = ::Patch::IO::MIDI::Message.to_patch_messages(@patches.first, @message)
+      end
+
+      should "have correct values" do
+        refute_nil @result
+        refute_empty @result
+        message = @result.first
+
+        assert_equal ::Patch::Message, message.class
+        assert_equal 0, message.index
+        assert_equal 5, message.value
+      end
+
+    end
+
+  end
+
+end

data/test/io/midi/output_test.rb

@@ -0,0 +1,44 @@
+require "helper"
+
+class Patch::IO::MIDI::OutputTest < Minitest::Test
+
+  context "Output" do
+
+    setup do
+      load_test_data
+      @nodes = Patch::Config.to_nodes(@nodes_path)
+      @patches = Patch::Config.to_patches(@nodes, @patches_path)
+      @patch = @patches.first
+      @output = ::Patch::IO::MIDI::Output.new(0, $>)
+    end
+
+    context "#initialize" do
+
+      should "have id" do
+        refute_nil @output.id
+      end
+
+    end
+
+    context "#puts" do
+
+      setup do
+        @message = Patch::Message.new
+        @message.index = 0
+        @message.value = 100
+        @message.patch_name = @patch.name
+        @output.device.expects(:puts).once
+      end
+
+      teardown do
+        @output.device.unstub(:puts)
+      end
+
+      should "send midi message" do
+        @output.puts(@patch, @message)
+      end
+
+    end
+  end
+
+end

data/test/io/midi_test.rb

@@ -0,0 +1,94 @@
+require "helper"
+
+class Patch::IO::MIDITest < Minitest::Test
+
+  context "MIDI" do
+
+    context "#get_direction_class" do
+
+      should "return input class" do
+        assert_equal Patch::IO::MIDI::Input, Patch::IO::MIDI.send(:get_direction_class, "input")
+        assert_equal Patch::IO::MIDI::Input, Patch::IO::MIDI.send(:get_direction_class, :input)
+      end
+
+      should "return output class" do
+        assert_equal Patch::IO::MIDI::Output, Patch::IO::MIDI.send(:get_direction_class, "output")
+        assert_equal Patch::IO::MIDI::Output, Patch::IO::MIDI.send(:get_direction_class, :output)
+      end
+
+      should "return nil" do
+        assert_nil Patch::IO::MIDI.send(:get_direction_class, "blah")
+        assert_nil Patch::IO::MIDI.send(:get_direction_class, :blah)
+      end
+
+    end
+
+    context "#new_from_config" do
+
+      context "input" do
+
+        setup do
+          @config = {
+            :id=>2,
+            :type=>"midi",
+            :direction=>"input",
+            :name=>"Apple Inc. IAC Driver"
+          }
+          @input = Patch::IO::MIDI.new_from_config(@config)
+        end
+
+        should "be input" do
+          refute_nil @input
+          assert_equal Patch::IO::MIDI::Input, @input.class
+        end
+
+        should "have id" do
+          refute_nil @input.id
+          assert_equal 2, @input.id
+        end
+
+        should "have underlying midi input" do
+          refute_nil @input.device
+          assert_equal @config[:name], @input.device.name
+        end
+
+        should "initialize midi listener" do
+          refute_nil @input.instance_variable_get("@listener")
+        end
+
+
+      end
+
+      context "output" do
+
+        setup do
+          @config = {
+            :id=>3,
+            :type=>"midi",
+            :direction=>"output",
+            :name=>"Apple Inc. IAC Driver"
+          }
+          @output = ::Patch::IO::MIDI.new_from_config(@config)
+        end
+
+        should "be output" do
+          refute_nil @output
+          assert_equal Patch::IO::MIDI::Output, @output.class
+        end
+
+        should "have id" do
+          refute_nil @output.id
+          assert_equal 3, @output.id
+        end
+
+        should "have underlying midi output" do
+          refute_nil @output.device
+          assert_equal @config[:name], @output.device.name
+        end
+
+      end
+
+    end
+  end
+
+end

data/test/io/module_test.rb

@@ -0,0 +1,21 @@
+require "helper"
+
+class Patch::IO::ModuleTest < Minitest::Test
+
+  context "Module" do
+
+    context ".all" do
+
+      should "contain modules" do
+        modules = Patch::IO::Module.all
+        refute_nil modules
+        refute_empty modules
+        assert modules.all? { |mod| mod.kind_of?(Module) }
+        assert modules.all? { |mod| mod.name.match(/\APatch\:\:IO/) }
+      end
+
+    end
+
+  end
+
+end

data/test/io/osc/action_test.rb

@@ -0,0 +1,76 @@
+require "helper"
+
+class Patch::IO::OSC::ActionTest < Minitest::Test
+
+  context "Action" do
+
+    setup do
+      @actions = [
+        {
+          :name=>"Volume",
+          :key=>"volume",
+          :default=> {
+            :scale=>0..2.0
+          },
+          :midi => {
+            :channel=>4,
+            :index=>7
+          }
+        },
+        {
+          :name=>"Z Depth",
+          :key=>"zDepth",
+          :default=>{
+            :scale=>0..1000
+          },
+          :osc=>{
+            :address=>"\\A/1/faderA\\z",
+            :scale=> {
+              :osc=>0..1.0
+            }
+          }
+        }
+      ]
+    end
+
+    context "#osc?" do
+
+      should "return true for actions with osc" do
+        assert Patch::IO::OSC::Action.osc?(@actions[1])
+      end
+
+      should "return false for actions without osc" do
+        refute Patch::IO::OSC::Action.osc?(@actions[0])
+      end
+
+    end
+
+    context "#osc_actions" do
+
+      should "return only osc actions" do
+        actions = Patch::IO::OSC::Action.osc_actions(@actions)
+        refute_nil actions
+        refute_empty actions
+        assert_equal 1, actions.size
+        assert_equal @actions[1], actions.first
+      end
+
+    end
+
+    context "#find_by_address" do
+
+      should "return action with address" do
+        addy = "/1/faderA"
+        action = Patch::IO::OSC::Action.find_by_address(@actions, addy)
+        refute_nil action
+        assert_match addy, action[:osc][:address]
+      end
+
+      should "return nil if not found" do
+        assert_nil Patch::IO::OSC::Action.find_by_address(@actions, "/1/faderZ")
+      end
+
+    end
+
+  end
+end

data/test/io/osc/client_test.rb

@@ -0,0 +1,49 @@
+require "helper"
+
+class Patch::IO::OSC::ClientTest < Minitest::Test
+
+  context "Client" do
+
+    setup do
+      load_test_data
+      @nodes = Patch::Config.to_nodes(@nodes_path)
+      @patches = Patch::Config.to_patches(@nodes, @patches_path)
+      @client = ::Patch::IO::OSC::Client.new("blah", 9000)
+    end
+
+    context "#puts" do
+
+      setup do
+        @resource = @client.instance_variable_get("@client")
+        @resource.expects(:send).once
+      end
+
+      context "osc message" do
+
+        setup do
+          @message = ::OSC::Message.new( "/1/rotaryA" , 0.5)
+        end
+
+        should "send message to underlying client" do
+          assert @client.puts(@patches.first, @message)
+        end
+
+      end
+
+      context "patch message" do
+
+        setup do
+          @message = Patch::Message.new(:index => 0, :patch_name => @patches.first.name, :value => 5)
+        end
+
+        should "send message to underlying client" do
+          assert @client.puts(@patches.first, @message)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/io/osc/message_test.rb

@@ -0,0 +1,53 @@
+require "helper"
+
+class Patch::IO::OSC::MessageTest < Minitest::Test
+
+  context "Message" do
+
+    setup do
+      load_test_data
+      @nodes = Patch::Config.to_nodes(@nodes_path)
+      @patches = Patch::Config.to_patches(@nodes, @patches_path)
+    end
+
+    context ".to_osc_messages" do
+
+      setup do
+        @message = Patch::Message.new(:index => 0, :patch_name => @patches.first.name, :value => 5)
+        @result = ::Patch::IO::OSC::Message.to_osc_messages(@patches.first, @message)
+      end
+
+      should "have correct properties" do
+        refute_nil @result
+        refute_empty @result
+        message = @result.first
+
+        assert_equal ::OSC::Message, message.class
+        assert_equal "/1/rotaryA", message.address
+        assert_equal 1, message.to_a[0]
+      end
+
+    end
+
+    context ".to_patch_messages" do
+
+      setup do
+        @message = ::OSC::Message.new("/1/rotaryA", 1)
+        @result = ::Patch::IO::OSC::Message.to_patch_messages(@patches.first, @message)
+      end
+
+      should "have correct values" do
+        refute_nil @result
+        refute_empty @result
+        message = @result.first
+
+        assert_equal ::Patch::Message, message.class
+        assert_equal 0, message.index
+        assert_equal 5, message.value
+      end
+
+    end
+
+  end
+
+end

data/test/io/osc/server_test.rb

@@ -0,0 +1,116 @@
+require "helper"
+
+class Patch::IO::OSC::ServerTest < Minitest::Test
+
+  context "Server" do
+
+    setup do
+      load_test_data
+      @nodes = Patch::Config.to_nodes(@nodes_path)
+      @patches = Patch::Config.to_patches(@nodes, @patches_path)
+      @nodes = Patch::Config.to_nodes(@nodes_path)
+      @server = @nodes.find_all_by_type(:osc).first
+      @server.instance_variable_get("@server").stubs(:run).returns(:true)
+    end
+
+    teardown do
+      @server.instance_variable_get("@server").unstub(:run)
+    end
+
+    context "#initialize" do
+
+      should "have id" do
+        refute_nil @server.id
+      end
+
+      should "initialize client" do
+        refute_nil @server.instance_variable_get("@client")
+      end
+
+      should "initialize server" do
+        refute_nil @server.instance_variable_get("@server")
+      end
+
+    end
+
+    context "#handle_message_received" do
+
+      setup do
+        @client = @server.instance_variable_get("@client").instance_variable_get("@client")
+        @message = ::OSC::Message.new( "/1/rotaryA" , 0.5)
+        @patch = @patches.first
+        @client.expects(:send).once.with(@message)
+        @scale = Object.new
+        @scale.expects(:from).once.returns(@scale)
+        @scale.expects(:to).once
+      end
+
+      teardown do
+        @client.unstub(:send)
+        @scale.unstub(:from)
+        @scale.unstub(:to)
+      end
+
+      should "return array of messages" do
+        @results = @server.send(:handle_message_received, @patch, @message)
+        refute_nil @results
+        assert_equal Array, @results.class
+        refute_empty @results
+
+        @results.each do |message|
+          assert_equal Patch::Message, message.class
+          assert_equal :test_patch, message.patch_name
+          refute_nil message.index
+          refute_nil message.value
+        end
+      end
+
+      should "yield array of messages" do
+        @server.send(:handle_message_received, @patch, @message) do |messages|
+          @results = messages
+          refute_nil @results
+          assert_equal Array, @results.class
+          refute_empty @results
+
+          @results.each do |message|
+            assert_equal Patch::Message, message.class
+            assert_equal :test_patch, message.patch_name
+            refute_nil message.index
+            refute_nil message.value
+          end
+        end
+      end
+
+      should "scale value" do
+        @results = @server.send(:handle_message_received, @patch, @message)
+      end
+    end
+
+    context "#start" do
+
+      should "start server" do
+        server = @server.instance_variable_get("@server")
+        server.expects(:run)
+        @server.start
+      end
+
+    end
+
+    context "#listen" do
+
+      setup do
+        @patch = @patches.first
+      end
+
+      should "bind addresses" do
+        resource = @server.instance_variable_get("@server")
+        osc_actions = Patch::IO::OSC::Action.osc_actions(@patch.actions)
+        resource.expects(:add_address).times(osc_actions.count)
+        assert @server.listen(@patch)
+      end
+
+    end
+
+  end
+
+end