MINT-core 1.0.1 → 2.0.0

data/spec/AIO_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+require "em-spec/rspec"
+require File.expand_path(File.join(File.dirname(__FILE__), 'shared/aio_shared'))
+
+describe 'AUI' do
+
+  before :each do
+    Redis.connect.flushall
+    @interactor_class =  MINT::AIO
+  end
+
+  it_should_behave_like 'An AIO interactor'
+
+  describe 'AIO' do
+
+    it 'should call back after event has been processed' do
+      connect do |redis|
+        class CallbackContext
+          attr_accessor :called
+
+          def initialize
+            @called = false
+          end
+          def focus_next
+            @called = true
+          end
+          def inform_parent_presenting
+          end
+
+          def sync_cio_to_displayed
+          end
+          def sync_cio_to_highlighted
+          end
+          def exists_next
+            true
+          end
+          def exists_prev
+            true
+          end
+
+        end
+
+        callback = CallbackContext.new
+
+        @a = MINT::AIO.create(:name => "test")
+        @a.process_event(:organize,callback).should == [:organized]
+        callback.called.should == false
+
+        @a.process_event(:present,callback).should == [:defocused]
+        callback.called.should == false
+
+        @a.process_event(:focus,callback).should == [:focused]
+        callback.called.should == false
+
+        @a.process_event(:next,callback).should == [:defocused]
+        callback.called.should == true
+      end
+    end
+
+    it 'should serialize to JSON' do
+      connect do |redis|
+        @a = MINT::AIO.create(:name => "test")
+        require 'dm-serializer'
+        @a.states=[:focused]
+
+        puts @a.to_json                      # => { "id": 1, "name": "Berta" }
+      end
+    end
+
+  end
+
+end

data/spec/AIReference_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+require "em-spec/rspec"
+
+
+describe 'AUI' 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 :(
+
+      DataMapper.finalize
+      DataMapper::Model.raise_on_save_failure = true
+    end
+  end
+
+  describe 'AIReference' do
+    it 'should initialize with initiated' do
+      connect do |redis|
+        @a = MINT::AIReference.create(:name=>"ref")
+
+        @a.states.should ==[:initialized]
+        @a.new_states.should == [:initialized]
+      end
+    end
+
+    it 'should refer to correct object' do
+      connect do |redis|
+        @a = MINT::AIReference.create(:name=>"ref",:refers=>"target")
+        MINT::AIO.create(:name=>"target")
+
+        @a.refers.name.should == "target"
+      end
+    end
+
+    it 'should focus referred object' do
+      connect do |redis|
+        @a = MINT::AIReference.create(:name=>"ref",:refers=>"target")
+        MINT::AIO.create(:name=>"target")
+
+        #Todo ask Sebastian about the functioning of AIReference
+        @a.process_event(:organize)
+        @a.refers.process_event(:organize)
+        @a.process_event(:present)
+        @a.refers.process_event(:present)
+        @a.process_event(:focus)
+        @a.refers.states.should == [:focused]
+      end
+    end
+
+    describe 'without refers' do
+
+      it 'should return to defocused in case there is no referred object' do
+        connect do |redis|
+          @a = MINT::AIReference.create(:name=>"ref")
+          @a.process_event(:organize)
+          @a.process_event(:present)
+          @a.process_event(:focus)
+          @a.states.should == [:defocused]
+        end
+      end
+    end
+
+    describe 'with refers' do
+      it 'should initialize with initiated and store reference correctly' do
+        connect true do |redis|
+          @a = MINT::AIReference.create(:name=>"ref")
+
+          test_state_flow redis,"Interactor.AIO.test" ,%w(initialized)   do
+
+            @r = MINT::AIO.create(:name => "test")
+            @a = MINT::AIReference.create(:name=>"reference", :refers => "test")
+
+            @a.states.should ==[:initialized]
+            @a.new_states.should == [:initialized]
+            @a.refers.name.should=="test"
+          end
+        end
+
+      end
+
+      it 'should forward focus' do
+        connect true do |redis|
+
+          test_state_flow redis,"Interactor.AIO.AIIN.AIINDiscrete.AIReference.reference" ,[["presenting", "defocused"],"focused", "defocused"]     do
+            @r = MINT::AIO.create(:name => "test",:states=>[:defocused])
+            @a = MINT::AIReference.create(:name=>"reference", :refers => "test",:states=>[:organized])
+            @a.process_event :present
+            @a.process_event :focus
+            @a.states.should ==[:defocused]
+            MINT::AIO.get("aui","test").states.should ==[:focused]
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/AISinglePresence_spec.rb

@@ -1,94 +1,238 @@
 require "spec_helper"
 
-include MINT
+require "em-spec/rspec"
+
+
+
 describe 'AUI' do
-  before :each do
-    connection_options = { :adapter => "in_memory"}
+  include EventMachine::SpecHelper
+
+  before :all do
+    class ::AISinglePresenceHelper
+      def self.create_data
+        MINT::AISinglePresence.create(:name=>"a", :children =>"e1|e2|e3")
+
+        MINT::AIO.create(:name => "e1",:parent=>"a")
+        MINT::AIO.create(:name => "e2",:parent=>"a")
+        MINT::AIO.create(:name => "e3",:parent=>"a")
+
+        @a = MINT::AISinglePresence.first
+        @a
+      end
+
+    end
+    connection_options = { :adapter => "redis"}
     DataMapper.setup(:default, connection_options)
-    #    DataMapper.setup(:default, { :adapter => "rinda",:local =>Rinda::TupleSpace.new})
-    AISinglePresence.new(:name=>"a", :childs =>[
-        AIO.new(:name => "e1"),
-        AIO.new(:name => "e2"),
-        AIO.new(:name => "e3")
-    ]).save
-
-    @a = AISinglePresence.first
+
+
+    connect do |redis|
+      require "MINT-core"
+      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
 
+
+
   describe 'AISinglePresence' do
-it 'should initialize with initiated' do
-      @a.states.should ==[:initialized]
-      @a.new_states.should == [:initialized]
+    it 'should initialize with initiated' do
+      connect do |redis|
+        @a = AISinglePresenceHelper.create_data
+        @a.states.should ==[:initialized]
+        @a.new_states.should == [:initialized]
+      end
     end
 
     it 'should transform to organizing state ' do
-      @a.process_event(:organize).should ==[:organized]
-      @a.states.should == [:organized]
-      @a.new_states.should == [:organized]
+      connect do |redis|
+        @a = AISinglePresenceHelper.create_data
+        @a.process_event(:organize).should ==[:organized]
+        @a.states.should == [:organized]
+        @a.new_states.should == [:organized]
+      end
     end
 
     it 'should transform first child to presented if presented and rest to suspended' do
-      AUIControl.organize(@a,nil,0)
-      # @a.process_event(:organize).should ==[:organized]
-      @a.states.should == [:organized]
-      @a.new_states.should == [:organized]
-      @a.process_event(:present).should ==[:defocused]
-      children = @a.childs
-      children[0].states.should == [:defocused]
-      children[1].states.should == [:suspended]
-      children[2].states.should == [:suspended]
+      connect true do |redis|
+        # Sync AIO to defocused
+        parser = MINT::MappingParser.new
+        m = parser.build_from_scxml File.dirname(__FILE__) +"/../lib/MINT-core/model/mim/aisinglepresence_present_to_child_present.xml"
+        m.start
+
+
+        check_result = Proc.new {
+          MINT::AIO.first(:name=>"e1").states.should ==[:defocused]
+          MINT::AIO.first(:name=>"e2").states.should ==[:suspended]
+          MINT::AIO.first(:name=>"e3").states.should ==[:suspended]
+
+          done
+        }
+
+        test_complex_state_flow_w_name redis,[["Interactor.AIO.AIOUT.AIContainer.AISinglePresence","a" ,["initialized","organized",["presenting", "wait_for_children"],"children_finished","defocused"]],["Interactor.AIO","e1" ,["initialized","organized",["presenting", "defocused"]]]],check_result do  |count|
+          @a = AISinglePresenceHelper.create_data
+
+          AUIControl.organize(@a,nil,0)
+          # @a.process_event(:organize).should ==[:organized]
+          @a.states.should == [:organized]
+          @a.new_states.should == [:organized]
+          @a.process_event(:present).should ==[:wait_for_children]
+
+        end
+      end
     end
 
-    it 'should hide the other elements if a child is presented' do
-      AUIControl.organize(@a,nil,0)
-      @a.process_event(:present).should == [:defocused]
+    it 'should hide the other elements if a child is presented using present' do
+      pending "requires child to inform parent about presenting"
+      connect true do |redis|
+        # Sync AIO to defocused
+        parser = MINT::MappingParser.new
+        m = parser.build_from_scxml File.dirname(__FILE__) +"/../lib/MINT-core/model/mim/aisinglepresence_present_to_child_present.xml"
+        m.start
+
 
-      AIO.first(:name => "e1").states.should == [:defocused]
-      AIO.first(:name => "e2").states.should == [:suspended]
-      AIO.first(:name => "e3").states.should == [:suspended]
+        check_result = Proc.new {
+          MINT::AIO.first(:name => "e1").states.should == [:suspended]
+          MINT::AIO.first(:name => "e2").states.should == [:defocused]
+          MINT::AIO.first(:name => "e3").states.should == [:suspended]
 
-      e3 = AIO.first(:name => "e3")
-      e3.states.should ==[:suspended]
-      e3.process_event(:present).should == [:defocused]
+          done
+        }
 
-      AIO.first(:name => "e1").states.should == [:suspended]
-      AIO.first(:name => "e2").states.should == [:suspended]
-      AIO.first(:name => "e3").states.should == [:defocused]
+        test_complex_state_flow_w_name redis,[["Interactor.AIO","e1" ,["initialized","organized",["presenting", "defocused"],"suspended"]]],check_result do  |count|
+          @a = AISinglePresenceHelper.create_data
 
-      e2 = AIO.first(:name => "e2")
-      e2.states.should ==[:suspended]
-      e2.process_event(:present).should == [:defocused]
+          AUIControl.organize(@a,nil,0)
+          @a.process_event(:present).should == [:wait_for_children]
 
-      AIO.first(:name => "e1").states.should == [:suspended]
-      AIO.first(:name => "e2").states.should == [:defocused]
-      AIO.first(:name => "e3").states.should == [:suspended]
+          e3 = MINT::AIO.first(:name => "e3")
+          e3.process_event(:present).should == [:defocused]
+          e2 = MINT::AIO.first(:name => "e2")
+          e2.process_event(:present).should == [:defocused]
+        end
+      end
 
     end
 
-    it 'should hide the other elements if a child is presented (using next and prev events)' do
-      AUIControl.organize(@a,nil,0)
-      @a.process_event(:present).should == [:defocused]
+    it 'should permit navigation before the first child ' do
+      connect true do |redis|
+        # Sync AIO to defocused
+        parser = MINT::MappingParser.new
+        m = parser.build_from_scxml File.dirname(__FILE__) +"/../lib/MINT-core/model/mim/aisinglepresence_present_to_child_present.xml"
+        m.start
+
+
+        check_result = Proc.new {
+          @a = MINT::AISinglePresence.first
+          @a.process_event :focus
+          @a.process_event :enter
+          @a.process_event :next
+          MINT::AIO.first(:name => "e2").states.should == [:defocused]
+
+          @a.process_event :prev
+          MINT::AIO.first(:name => "e2").states.should == [:suspended]
+          MINT::AIO.first(:name => "e1").states.should == [:defocused]
+
+          @a.process_event :prev
+          MINT::AIO.first(:name => "e2").states.should == [:suspended]
+          MINT::AIO.first(:name => "e1").states.should == [:defocused]
 
-      AIO.first(:name => "e1").states.should == [:defocused]
-      AIO.first(:name => "e2").states.should == [:suspended]
-      AIO.first(:name => "e3").states.should == [:suspended]
+          @a.process_event :next
+          MINT::AIO.first(:name => "e1").states.should == [:suspended]
+          MINT::AIO.first(:name => "e2").states.should == [:defocused]
+          done
+        }
 
-      @a.process_event(:focus).should == [:waiting]
-      @a.process_event(:enter).should == [:entered]
-      @a.process_event(:next).should == [:entered]
+        test_complex_state_flow_w_name redis,[["Interactor.AIO.AIOUT.AIContainer.AISinglePresence","a" ,["initialized","organized",["presenting", "wait_for_children"],"children_finished","defocused"]]],check_result do  |count|
+          @a = AISinglePresenceHelper.create_data
 
-      AIO.first(:name => "e1").states.should == [:suspended]
-      AIO.first(:name => "e2").states.should == [:defocused]
-      AIO.first(:name => "e3").states.should == [:suspended]
+          AUIControl.organize(@a,nil,0)
+          # @a.process_event(:organize).should ==[:organized]
+          @a.states.should == [:organized]
+          @a.new_states.should == [:organized]
+          @a.process_event(:present).should ==[:wait_for_children]
 
-      @a.process_event(:prev).should == [:entered]
+        end
+      end
 
-      AIO.first(:name => "e1").states.should == [:defocused]
-      AIO.first(:name => "e2").states.should == [:suspended]
-      AIO.first(:name => "e3").states.should == [:suspended]
     end
 
 
+    it 'should hide the other elements if a child is presented with next and prev events' do
+      connect true do |redis|
+        # Sync AIO to defocused
+        parser = MINT::MappingParser.new
+        m = parser.build_from_scxml File.dirname(__FILE__) +"/../lib/MINT-core/model/mim/aisinglepresence_present_to_child_present.xml"
+        m.start
+
+        check_result2 = Proc.new {
+          MINT::AIO.first(:name => "e1").states.should == [:defocused]
+          MINT::AIO.first(:name => "e2").states.should == [:suspended]
+          MINT::AISinglePresence.first(:name => "a").active_child == "e1"
+          done
+        }
+
+        check_result = Proc.new {
+          redis.pubsub.unsubscribe("Interactor.AIO.AIOUT.AIContainer.AISinglePresence")
+
+          a = MINT::AISinglePresence.first(:name => "a")
+          a.process_event(:focus).should == [:waiting]
+
+          test_complex_state_flow_w_name redis,[["Interactor.AIO","e1" ,["suspended",["presenting", "defocused"]]],["Interactor.AIO","e2" ,[["presenting", "defocused"],"suspended"]]],check_result2 do  |count|
+            a.process_event(:enter).should == [:entered]
+            a.process_event(:next).should == [:entered]
+            a.process_event(:prev).should == [:entered]
+          end
+        }
+
+        test_complex_state_flow_w_name redis,[["Interactor.AIO.AIOUT.AIContainer.AISinglePresence","a" ,["initialized","organized",["presenting", "wait_for_children"],"children_finished","defocused"]]],check_result do  |count|
+          @a = AISinglePresenceHelper.create_data
+
+          AUIControl.organize(@a,nil,0)
+          @a.process_event(:present).should == [:wait_for_children]
+        end
+      end
+
+
+    end
+
+    describe 'synchronized with Redis-PubSub' do
+      it 'should transform first child to presented if presented and rest to suspended' do
+        connect true do |redis|
+
+          parser = MINT::MappingParser.new
+          m = parser.build_from_scxml File.dirname(__FILE__) +"/../lib/MINT-core/model/mim/aisinglepresence_present_to_child_present.xml"
+          m.start
+
+          check_result = Proc.new {
+            test_state_flow redis,"Interactor.AIO.AIOUT.AIContainer.AISinglePresence" ,
+                            ["defocused",["focused", "waiting"], "entered"] do
+              @a.process_event(:focus)
+
+              @a.process_event(:enter)
+            end
+            done
+
+          }
+
+          test_complex_state_flow_w_name redis,[["Interactor.AIO.AIOUT.AIContainer.AISinglePresence" ,"a",
+                                                 ["initialized", "organized", ["presenting", "wait_for_children"] ,"children_finished","defocused"] ]],check_result do  |count|
+
+            @a = AISinglePresenceHelper.create_data
+            AUIControl.organize(@a,nil,0)
+
+            @a.process_event(:present)
+
+
+
+          end
+
+
+        end
+      end
+
+    end
 
   end
 end