MINT-core 1.0.1 → 2.0.0

data/spec/mapping_performance_spec.rb

@@ -0,0 +1,118 @@
+require "spec_helper"
+require "em-spec/rspec"
+require 'perftools'
+
+describe "MappingPerformance" do
+  include EventMachine::SpecHelper
+
+  before :all do
+    connection_options = { :adapter => "redis"}
+    DataMapper.setup(:default, connection_options)
+
+
+    connect do |redis|
+      require "MINT-core"
+      class InteractorTest < MINT::Interactor
+        def getSCXML
+          "#{File.dirname(__FILE__)}/interactor_test.scxml"
+        end
+      end
+
+      class PerformanceCounter < MINT::Interactor
+        property :counter, Integer,  :default => 0
+        property :amount, Integer,  :default => 10
+
+        def inc_counter
+          counter = attribute_get(:counter)
+          attribute_set(:counter, counter + 1)
+
+        end
+        def getSCXML
+          "#{File.dirname(__FILE__)}/performance_counter.scxml"
+        end
+      end
+
+      require "support/redis_connector_monkey_patch"  # TODO dirty patch for a bug that i have not found :(
+      DataMapper.finalize
+      DataMapper::Model.raise_on_save_failure = true
+    end
+  end
+
+
+  it "should run as quickly as possible for one mapping" do
+      connect true do |redis|
+        parser = MINT::MappingParser.new
+        m = parser.build_from_scxml File.dirname(__FILE__) +"/examples/performance_mapping.xml"
+        m.start
+
+        check_result = Proc.new {
+
+
+          done
+        }
+
+        test_complex_state_flow_w_name  redis,[["Interactor.PerformanceCounter","counter" ,["initialized","finished"]]],check_result do  |count|
+          counter = PerformanceCounter.create(:name=>"counter",:amount =>1)
+          trigger = InteractorTest.create(:name=>"test")
+          trigger.process_event :organize
+        end
+
+
+      end
+  end
+
+  it "should run as quickly as possible for two mappings" do
+    connect true do |redis|
+      parser = MINT::MappingParser.new
+      m = parser.build_from_scxml File.dirname(__FILE__) +"/examples/performance_mapping.xml"
+      m.start
+
+      m = parser.build_from_scxml File.dirname(__FILE__) +"/examples/performance_mapping.xml"
+      m.start
+
+      check_result = Proc.new {
+        done
+      }
+
+      test_complex_state_flow_w_name  redis,[["Interactor.PerformanceCounter","counter" ,["initialized","initialized","finished"]]],check_result do  |count|
+        counter = PerformanceCounter.create(:name=>"counter",:amount =>2)
+        trigger = InteractorTest.create(:name=>"test")
+        trigger.process_event :organize
+      end
+
+
+    end
+  end
+
+  it "should run as quickly as possible for 1000 mappings" do
+    PerfTools::CpuProfiler.start("/tmp/add_numbers_profile") do
+    connect(true,30) do |redis|
+      parser = MINT::MappingParser.new
+
+      obs_array =[]
+
+      for i in 1..500 do
+        m = parser.build_from_scxml File.dirname(__FILE__) +"/examples/performance_mapping.xml"
+        m.start
+        obs_array << "initialized"
+      end
+
+      obs_array << "finished"
+
+      p obs_array
+
+      check_result = Proc.new {
+        done
+      }
+
+      test_complex_state_flow_w_name  redis,[["Interactor.PerformanceCounter","counter" ,obs_array]],check_result do  |count|
+        counter = PerformanceCounter.create(:name=>"counter",:amount =>500)
+        trigger = InteractorTest.create(:name=>"test")
+        trigger.process_event :organize
+      end
+
+    end
+
+    end
+  end
+end

data/spec/mapping_server_spec.rb

@@ -0,0 +1,161 @@
+require "spec_helper"
+
+require "em-spec/rspec"
+
+class FakeMappingServerClient < EventMachine::Connection
+  include EM::Protocols::LineText2
+
+  attr_writer :onopen, :onclose, :onmessage, :onregistered
+  attr_reader :data
+
+  def post_init
+    @state = :new
+    @data = []
+
+  end
+
+  def set_expectations(mapping_name,detail_level,expected_data)
+    @mapping_name = mapping_name
+    @expected_data = expected_data
+    @detail_level = detail_level
+  end
+  def receive_line(rd)
+    @data << rd
+    if @state == :new
+      @onopen.call if @onopen
+      @state = :open
+    end
+    p "received #{rd}"
+    if rd.eql? "READY"
+      @state = :ready
+      send_data("REGISTER%#{@mapping_name}%#{@detail_level}\r\n")
+    elsif rd.eql? "REGISTERED%#{@mapping_name}%#{@detail_level}"
+      @state = :registered
+      @onregistered.call if @onregistered
+
+    else
+      d = rd.split("%")
+      if d.length ==3
+        if d[1].eql?  @mapping_name and (d[0].eql? "INFO" or d[0].eql? @detail_level)
+          MultiJson.decode(d[2]).should == @expected_data.shift
+
+          EM::stop if @expected_data.length == 0
+        end
+      else
+        p "Unknown command received:#{rd}"
+      end
+
+
+    end
+  end
+  def unbind
+    @onclose.call if @onclose
+  end
+end
+
+describe "Mapping server" do
+  include EventMachine::SpecHelper
+
+
+  before :all do
+    connection_options = { :adapter => "redis"}
+    DataMapper.setup(:default, connection_options)
+
+
+    connect do |redis|
+      require "MINT-core"
+      class Logging
+        def self.log(mapping,data)
+          p "log: #{mapping} #{data}"
+        end
+      end
+      DataMapper.finalize
+      DataMapper::Model.raise_on_save_failure = true
+    end
+  end
+
+  before(:each) do
+      Redis.new(:db => 15).flushdb
+  end
+
+  it "should open connection and accept register command" do
+    connect true do |redis|
+      CUIControl.clearHighlighted
+
+      server = MappingServer.new(:host => '0.0.0.0', :port => 12345)
+      server.start
+
+      # opens the socket client connection
+      socket = EM.connect('0.0.0.0', 12345, FakeMappingServerClient)
+      socket.set_expectations("Mouse Interactor Highlighting","INFO",[])
+      # assigning the onopen client callback directly
+      socket.onopen = lambda {
+
+        server.connections.size.should == 1
+        socket.data.last.chomp.should == "READY"
+        EM.stop
+      }
+
+    end
+  end
+
+  it "should return all information about mapping states after registration with DETAIL" do
+    connect true do |redis|
+      CUIControl.clearHighlighted
+      server = MappingServer.new(:host => '0.0.0.0', :port => 12345)
+      server.start
+
+      # opens the socket client connection
+      socket = EM.connect('0.0.0.0', 12345, FakeMappingServerClient  )
+      socket.set_expectations("Mouse Interactor Highlighting","DETAIL",[{"id"=>"33113", "mapping_state"=>"loaded"},
+                                                                        {"id"=>"33113", "mapping_state"=>"started"},
+                                                                        {"id"=>"111", "state"=>"activated"},
+                                                                        {"id"=>"111", "element"=>"Interactor.IR.IRMode.Pointer.Mouse", "result"=>{}, "state"=>"false"},
+                                                                        {"id"=>"111", "element"=>"Interactor.IR.IRMode.Pointer.Mouse", "result"=>{"p"=>{"classtype"=>"MINT::Mouse", "mint_model"=>"core", "name"=>"mouse", "states"=>["left_released", "stopped", "right_released"], "abstract_states"=>"Mouse|root|connected|leftbutton|pointer|rightbutton", "new_states"=>["connected", "leftbutton", "pointer", "rightbutton", "left_released", "stopped", "right_released"], "x"=>-1, "y"=>-1}}, "state"=>"true", "name"=>"mouse"},
+                                                                        {"id"=>"2222", "state"=>"activated"},
+                                                                        {"id"=>"2222", "state"=>"succeeded"},
+                                                                        {"id"=>"33113", "mapping_state"=>"succeeded"},
+                                                                        {"id"=>"33113", "mapping_state"=>"restarted"},
+                                                                        {"id"=>"111", "state"=>"activated"}])
+      m = server.manager
+
+      socket.onregistered= lambda {
+        m.load(File.dirname(__FILE__) +"/examples/mim_streaming_example.xml").started {
+          mouse = MINT::Mouse.create(:name =>"mouse")  # previously activated observation should be false
+          mouse.process_event :connect # observation should be true
+          #mouse.process_event :move
+          #mouse.process_event :stop
+
+        }
+
+      }
+    end
+  end
+  it "should return all information about mapping states after registration with DETAIL" do
+    connect true do |redis|
+      CUIControl.clearHighlighted
+      server = MappingServer.new(:host => '0.0.0.0', :port => 12345)
+      server.start
+
+      # opens the socket client connection
+      socket = EM.connect('0.0.0.0', 12345, FakeMappingServerClient  )
+      socket.set_expectations("Mouse Interactor Highlighting","INFO",[#{"id"=>"33113", "mapping_state"=>"loaded"},
+                                                                       # {"id"=>"33113", "mapping_state"=>"started"},
+                                                                        {"id"=>"33113", "mapping_state"=>"succeeded", "name"=>"mouse"}
+                                                                        #{"id"=>"33113", "mapping_state"=>"restarted"}
+                                                                        ])
+      m = server.manager
+
+      socket.onregistered= lambda {
+        m.load(File.dirname(__FILE__) +"/examples/mim_streaming_example.xml").started {
+          mouse = MINT::Mouse.create(:name =>"mouse")  # previously activated observation should be false
+          mouse.process_event :connect # observation should be true
+          #mouse.process_event :move
+          #mouse.process_event :stop
+
+        }
+
+      }
+    end
+  end
+end

data/spec/mapping_spec.rb

@@ -0,0 +1,307 @@
+require "spec_helper"
+
+require "em-spec/rspec"
+
+
+describe 'Mapping' do
+  include EventMachine::SpecHelper
+
+  before :all do
+
+    connection_options = { :adapter => "redis"}
+    DataMapper.setup(:default, connection_options)
+
+    connect do |redis|
+      require "MINT-core"
+      require "support/redis_connector_monkey_patch"  # TODO dirty patch for a bug that i have not found :(
+      include MINT
+
+      class InteractorTest < MINT::Interactor
+
+        def show_states c
+          puts "States #{c['states']}"
+        end
+
+        def getSCXML
+          "#{File.dirname(__FILE__)}/interactor_test.scxml"
+        end
+      end
+      class InteractorTest_2 <InteractorTest
+      end
+      class InteractorTest2 <InteractorTest
+        def getSCXML
+          "#{File.dirname(__FILE__)}/interactor_test_2.scxml"
+        end
+      end
+
+      class Logging
+      def self.log(mapping,data)
+        p "log: #{mapping} #{data}"
+      end
+      end
+      DataMapper.finalize
+      DataMapper::Model.raise_on_save_failure = true
+    end
+  end
+
+  describe 'without Parser' do
+
+
+    describe 'Sequential' do
+      describe 'with EventAction' do
+        it 'should fire event if all observations have been true' do
+          connect true do |redis|
+            o1 = Observation.new(:element =>"Interactor.InteractorTest",:name => "test_1", :states =>[:organized],:process=> :onchange)
+            o2 = Observation.new(:element =>"Interactor.InteractorTest.InteractorTest_2",:name => "test_2", :states =>[:initialized], :result => "p",:process=> :continuous )
+            a = EventAction.new(:event => :organize, :target => "p")
+            m = MINT::SequentialMapping.new(:name=>"Interactor.InteractorTest Observation", :observations => [o1,o2],:actions =>[a])
+            m.start
+
+            test_state_flow redis,"Interactor.InteractorTest.InteractorTest_2.test_2" ,["initialized", "organized"] do
+              test_1 = InteractorTest.create(:name => "test_1")
+              test_1.process_event :organize
+              test_2 = InteractorTest_2.create(:name => "test_2")
+            end
+          end
+        end
+
+        describe "sync mapping"    do
+          it 'should support name selector and not observations for sync mappings' do
+            connect true do |redis|
+              o1 = Observation.new(:element =>"Interactor.AIO", :states =>[:presenting],:result=>"aio")
+              o2 = NegationObservation.new(:element =>"Interactor.CIO", :name =>"aio.name" ,:states =>[:displaying], :result => "cio", :process => :continuous )
+              a = EventAction.new(:event => :display, :target => "cio")
+              m = MINT::SequentialMapping.new(:name=>"Sync CIO to display", :observations => [o1,o2],:actions =>[a])
+              m.start
+
+              test_state_flow redis,"Interactor.CIO.test" ,[["displaying", "init_js"],"displayed"] do
+                aio = MINT::AIO.create(:name => "test", :states => [:organized])
+                cio = MINT::CIO.create(:name => "test", :states=>[:positioned])
+                aio.process_event :present
+
+              end
+            end
+          end
+          it 'should support not end up in cycles for sync mappings' do
+            connect true do |redis|
+              o1 = Observation.new(:element =>"Interactor.AIO", :states =>[:presenting],:result=>"aio",:process => :onchange)
+              o2 = NegationObservation.new(:element =>"Interactor.CIO", :name =>"aio.name" ,:states =>[:displaying], :result => "cio",:process => :instant )
+              a = EventAction.new(:event => :display, :target => "cio")
+              m = MINT::SequentialMapping.new(:name=>"Sync CIO to display", :observations => [o1,o2],:actions =>[a])
+              m.state_callback = Logging.method(:log)
+              m.start
+
+              o3 = Observation.new(:element =>"Interactor.CIO", :states =>[:displaying],:result=>"cio",:process => :onchange)
+              o4 = NegationObservation.new(:element =>"Interactor.AIO", :name =>"cio.name" ,:states =>[:presenting], :result => "aio",:process => :instant)
+              a1 = EventAction.new(:event => :present, :target => "aio")
+              m1 = MINT::SequentialMapping.new(:name=>"Sync CIO display to AIO presenting", :observations => [o3,o4],:actions =>[a1])
+              m1.state_callback = Logging.method(:log)
+              m1.start
+
+              test_state_flow redis,"Interactor.AIO.test" ,[["presenting", "defocused"]] do
+                aio = MINT::AIO.create(:name => "test", :states => [:organized])
+                cio = MINT::CIO.create(:name => "test", :states=>[:positioned])
+                cio.process_event :display
+
+              end
+            end
+          end
+        end
+
+
+
+      end
+    end
+
+
+    describe 'Complementary' do
+      describe 'with EventAction' do
+        it 'should fire event if the observation is true' do
+          connect true do |redis|
+            o = Observation.new(:element =>"Interactor.InteractorTest", :name => "test", :result => "p", :states =>[:initialized], :process=>"onchange")
+            a = EventAction.new(:event => :organize,:target => "p")
+            m = MINT::ComplementaryMapping.new(:name=>"Interactor.InteractorTest Observation", :observations => [o],:actions =>[a])
+            m.start
+
+            test_state_flow redis,"Interactor.InteractorTest.test" ,["initialized", "organized"] do
+              @a = InteractorTest.create(:name => "test")
+            end
+          end
+        end
+
+        it 'should fire event if both observations are true' do
+          connect true do |redis|
+            o1 = Observation.new(:element =>"Interactor.InteractorTest",:name => "test_1", :states =>[:organized], :process=>"onchange")
+            o2 = Observation.new(:element =>"Interactor.InteractorTest.InteractorTest_2",:name => "test_2", :states =>[:initialized], :result => "p",:process=>"instant")
+            a = EventAction.new(:event => :organize, :target => "p")
+            m = MINT::ComplementaryMapping.new(:name=>"Interactor.InteractorTest Observation", :observations => [o1,o2],:actions =>[a])
+            m.start
+
+            test_state_flow redis,"Interactor.InteractorTest.InteractorTest_2.test_2" ,["initialized", "organized"] do
+              test_1 = InteractorTest.create(:name => "test_1")
+              test_2 = InteractorTest_2.create(:name => "test_2")
+              test_1.process_event :organize
+            end
+          end
+        end
+
+        it 'should handle a continuous observation' do
+          pending "rethink if step 3 really should happen"
+          connect true do |redis|
+            o1 = Observation.new(:element =>"Interactor.InteractorTest.InteractorTest2",:name => "test", :states =>[:presenting], :result => "p",:process => :onchange)
+            a = EventAction.new(:event => :step, :target => "p")
+            m = MINT::ComplementaryMapping.new(:name=>"Interactor.InteractorTest Observation", :observations => [o1],:actions =>[a])
+            m.start
+
+            test_state_flow redis,"Interactor.InteractorTest.InteractorTest2.test" ,["initialized", ["presenting", "step1"],"step2","step3","initialized"] do
+              test = InteractorTest2.create(:name => "test")
+              test.process_event :present
+
+            end
+
+          end
+        end
+
+        it 'should handle a non continuous observation' do
+          connect true do |redis|
+            o1 = Observation.new(:element =>"Interactor.InteractorTest.InteractorTest2",:name => "test", :states =>[:presenting], :result => "p", :process=>"onchange")
+            a = EventAction.new(:event => :step, :target => "p")
+            m = MINT::ComplementaryMapping.new(:name=>"Interactor.InteractorTest Observation", :observations => [o1],:actions =>[a])
+            m.start
+
+            test_state_flow redis,"Interactor.InteractorTest.InteractorTest2.test" ,["initialized", ["presenting", "step1"],"step2"] do
+              test = InteractorTest2.create(:name => "test")
+              test.process_event :present
+
+            end
+
+          end
+        end
+
+      end
+
+      describe 'with BackendAction' do
+        it 'should call the Backend Action if observation is true' do
+          connect true do |redis|
+            b = InteractorTest.new
+            o = Observation.new(:element =>"Interactor.InteractorTest",:name => "test", :states =>[:organized], :result => "c", :process=>"onchange")
+            a = BackendAction.new(:call => b.method(:show_states), :parameter => "c")
+            m = MINT::ComplementaryMapping.new(:name=>"BackendAction test",:observations => [o],:actions =>[a])
+            m.start
+
+            test_state_flow redis,"Interactor.InteractorTest.test" ,["initialized", "organized"] do
+              test = InteractorTest.create(:name => "test")
+              test.process_event :organize
+            end
+          end
+        end
+      end
+    end
+  end
+
+
+  describe 'with Parser' do
+    describe 'Complementary' do
+      describe 'with EventAction' do
+        it 'should fire event if the observation is true' do
+          connect true do |redis|
+            parser = MINT::MappingParser.new
+            scxml = <<EOS
+<mapping name="Interactor.InteractorTest Observation" xmlns="http://www.multi-access.de"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://www.multi-access.de mint-mappings.xsd">
+  <operator type="complementary">
+    <observations>
+      <observation interactor="Interactor.InteractorTest" name="test" states="initialized" result="p" process="onchange"/>
+    </observations>
+    <actions>
+      <event type="organize" target="p"/>
+    </actions>
+  </operator>
+
+</mapping>
+EOS
+            m = parser.build_from_scxml_string scxml
+            m.start
+
+            test_state_flow redis,"Interactor.InteractorTest.test" ,["initialized", "organized"] do
+              @a = InteractorTest.create(:name => "test")
+            end
+          end
+        end
+
+        it 'should fire event if both observations are true' do
+          connect true do |redis|
+            parser = MINT::MappingParser.new
+            scxml = <<EOS
+<mapping name="Interactor.InteractorTest Observation" xmlns="http://www.multi-access.de"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://www.multi-access.de mint-mappings.xsd">
+  <operator type="sequential">
+    <observations>
+      <observation interactor="Interactor.InteractorTest" name="test_1" states="organized" process="onchange"/>
+      <observation interactor="Interactor.InteractorTest.InteractorTest_2" name="test_2" states="initialized" process="instant" result="p"/>
+    </observations>
+    <actions>
+      <event type="organize" target="p"/>
+    </actions>
+  </operator>
+
+</mapping>
+EOS
+            m = parser.build_from_scxml_string scxml
+            m.start
+
+            test_state_flow redis,"Interactor.InteractorTest.InteractorTest_2.test_2" ,["initialized", "organized"] do
+              test_1 = InteractorTest.create(:name => "test_1")
+              test_2 = InteractorTest_2.create(:name => "test_2")
+              test_1.process_event :organize
+            end
+          end
+        end
+      end
+
+=begin
+describe 'with BindAction' do
+        it 'should bind if both observation are true' do
+          connect true do |redis|
+            o1 = Observation.new(:element =>"Interactor.InteractorTest",:name => "test", :states =>[:organized])
+            o2 = Observation.new(:element =>"Interactor.InteractorTest.InteractorTest_2",:name=>"test_2", :states =>[:presenting])
+            a = BindAction.new(:elementIn => "Interactor.InteractorTest",:nameIn => "test", :attrIn =>"data",:attrOut=>"data",
+                               :elementOut =>"Interactor.InteractorTest.InteractorTest_2", :nameOut=>"test_2" )
+            m = ComplementaryMapping.new(:name => "BindAction test", :observations => [o1,o2],:actions =>[a])
+            m.start
+
+            test_state_flow redis,"Interactor.InteractorTest" ,["initialized", "organized"] do
+              test_1 = InteractorTest.create(:name => "test")
+              test_2 = InteractorTest_2.create(:name => "test_2")
+              test_1.process_event :organize
+              test_2.process_event :organize
+              test_2.process_event :present
+            end
+          end
+        end
+
+      end
+
+      describe 'with BackendAction' do
+        it 'should call the Backend Action if observation is true' do
+          connect true do |redis|
+            b = InteractorTest.new
+            o = Observation.new(:element =>"Interactor.InteractorTest",:name => "test", :states =>[:organized], :result => "c")
+            a = BackendAction.new(:call => b.method(:show_states), :parameter => "c")
+            m = ComplementaryMapping.new(:name=>"BackendAction test",:observations => [o],:actions =>[a])
+            m.start
+
+            test_state_flow redis,"Interactor.InteractorTest" ,["initialized", "organized"] do
+              test = InteractorTest.create(:name => "test")
+              test.process_event :organize
+            end
+          end
+        end
+      end
+=end
+    end
+  end
+
+end