MINT-core 1.0.1 → 2.0.0

data/spec/aisinglechoice_spec.rb

@@ -1,9 +1,10 @@
 require "spec_helper"
 
 describe 'SingleChoice' do
-  before :each do
-    connection_options = { :adapter => "in_memory"}
-    DataMapper.setup(:default, connection_options)
+
+  include EventMachine::SpecHelper
+
+  before :all do
     class CallbackContext
       attr_accessor :called
 
@@ -34,118 +35,176 @@ describe 'SingleChoice' do
     end
     @callback = CallbackContext.new
 
-    @sc =MINT::AISingleChoice.new(:name => "choice",
-                                  :childs => [
-                                      MINT::AISingleChoiceElement.new(:name => "element_1"),
-                                      MINT::AISingleChoiceElement.new(:name => "element_2"),
-                                      MINT::AISingleChoiceElement.new(:name => "element_3"),
-                                      MINT::AISingleChoiceElement.new(:name => "element_4")]
-    )
-    AUIControl.organize(@sc,nil, 0)
-    @sc.save
-  end
+    connection_options = { :adapter => "redis"}
+    DataMapper.setup(:default, connection_options)
 
-  describe "child relations" do
-    before :each do
-      @sc.process_event(:present).should == [:defocused, :listing]
-      @sc.states.should == [:defocused, :listing]
+    class ::Helper
+      def self.create_structure
+        MINT::AISingleChoice.create(:name => "choice", :children => "element_1|element_2|element_3|element_4")
+        MINT::AISingleChoiceElement.create(:name => "element_1", :parent=>"choice")
+        MINT::AISingleChoiceElement.create(:name => "element_2", :parent=>"choice")
+        MINT::AISingleChoiceElement.create(:name => "element_3", :parent=>"choice")
+        MINT::AISingleChoiceElement.create(:name => "element_4", :parent=>"choice")
+        MINT::AISingleChoice.first
+      end
 
-      @e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
-      @e2 = MINT::AISingleChoiceElement.first(:name => "element_2")
-      @e3 = MINT::AISingleChoiceElement.first(:name => "element_3")
-      @e4 = MINT::AISingleChoiceElement.first(:name => "element_4")
+      def self.initialize_main_structure
+        @sc = Helper.create_structure
+        AUIControl.organize(@sc,nil,0)
 
-      @e1.process_event(:present)
-      @e2.process_event(:present)
-      @e3.process_event(:present)
-      @e4.process_event(:present)
+        @sc.process_event(:present).should == [:wait_for_children, :listing]
+        @sc.process_event :children_finished
+        @sc.present_children
+        @sc.states.should == [:defocused, :listing]
+        @sc
+      end
     end
 
-    it 'should deactivate other chosen elements on choose' do
-      @e1.process_event(:focus).should == [:focused, :unchosen]
-      @e1.new_states.should == [:focused]
+    connect do |redis|
+      require "MINT-core"
 
-      @e1.process_event(:choose).should == [:focused, :chosen]
-      @e2.process_event(:choose).should == [:defocused, :chosen]
-
-
-      # TODO: state actualization should be done withnt :suspend, out re-querying?
-      @e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
-      @e1.states.should == [:focused, :unchosen]
+      DataMapper.finalize
+      DataMapper::Model.raise_on_save_failure = true
+    end
+  end
 
+  describe "child relationpresents" do
+    it 'should deactivate other chosen elements on choose' do
+      connect do |redis|
+        Helper.initialize_main_structure
+        @e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
+        @e2 = MINT::AISingleChoiceElement.first(:name => "element_2")
+
+        @e1.process_event(:focus).should == [:focused, :unchosen]
+        @e1.new_states.should == [:focused]
+        @e2.process_event(:focus).should == [:focused, :unchosen]
+        @e2.new_states.should == [:focused]
+
+        @e1.process_event(:choose).should == [:focused, :chosen]
+        @e2.process_event(:choose).should == [:focused, :chosen]
+
+        # TODO: state actualization should be done withnt :suspend, out re-querying?
+        @e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
+        @e1.states.should == [:focused, :unchosen]
+      end
     end
 
-    it 'should accept drag event in unchosen or chosen' do
-      @e1.process_event(:focus).should == [:focused, :unchosen]
-      @e1.states.should == [:focused, :unchosen]
+    it 'should accept drag event in listed or chosen' do
+      connect do |redis|
+        Helper.initialize_main_structure
+        @e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
+        sc =MINT::AISingleChoice.first(:name => "choice")
 
-      @e1.process_event(:drag).should == [:dragging, :chosen]
-      @e1.states.should == [:dragging, :chosen]
+        @e1.process_event(:focus).should == [:focused, :unchosen]
+        @e1.states.should == [:focused, :unchosen]
 
-      @e1.process_event(:drop).should == [:defocused, :chosen]
-      @e1.states.should == [:defocused, :chosen]
+        @e1.process_event(:drag).should == [:focused, :dragging]
+        @e1.states.should == [:focused, :dragging]
 
-      @e1.process_event(:focus).should == [:focused, :chosen]
-      @e1.states.should == [:focused, :chosen]
 
-      @e1.process_event(:drag).should == [:dragging, :chosen]
-      @e1.states.should == [:dragging, :chosen]
-  end
+        sc.process_event(:focus).should == [:focused, :listing]
+        sc.process_event(:drop).should == [:defocused, :listing]
+        @e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
+        @e1.states.should == [:focused, :unchosen]
 
-    it 'should hide child elements on suspend' do
-      sc =MINT::AISingleChoice.first(:name => "choice")
-      sc.process_event(:suspend).should == [:suspended]
-      e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
-      e1.states.should == [:suspended]
-    end
+        @e1.process_event(:choose).should == [:focused, :chosen]
+        @e1.states.should == [:focused, :chosen]
 
-    it 'should hide if suspend is called from parent AIC' do
-      sc =MINT::AISingleChoice.first(:name => "choice")
+        @e1.process_event(:drag).should == [:focused, :dragging]
+        @e1.states.should == [:focused, :dragging]
 
-      aic = MINT::AIC.create(:name => "container", :states=>[:defocused],:childs =>[sc])
+        sc.process_event(:focus).should == [:focused, :listing]
+        sc.process_event(:drop).should == [:defocused, :listing]
+        @e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
+        @e1.states.should == [:focused, :unchosen]
 
-      aic.process_event(:suspend).should == [:suspended]
-      e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
-      e1.states.should == [:suspended]
+      end
     end
 
-    it "should sync suspend to CUI"   do
-      MINT::RadioButtonGroup.create(:name =>"choice", :states => [:presenting,:listed])
-      MINT::Selectable.create(:name =>"element_1", :states =>[:displayed,:listed])
-      MINT::Selectable.create(:name =>"element_2", :states =>[:displayed,:listed])
-      MINT::Selectable.create(:name =>"element_3", :states =>[:displayed,:listed])
-      MINT::Selectable.create(:name =>"element_4", :states =>[:displayed,:listed])
+    it 'should hide child elements on suspend' do
+      connect do |redis|
+        Helper.initialize_main_structure
+
+        sc =MINT::AISingleChoice.first(:name => "choice")
+        sc.process_event(:suspend).should == [:suspended]
+        e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
+        e1.states.should == [:suspended]
+      end
+    end
 
+    it 'should hide if suspend is called from parent AIContainer' do
+      connect do |redis|
+        Helper.initialize_main_structure
 
-      sc =MINT::AISingleChoice.first(:name => "choice")
+        sc = MINT::AISingleChoice.first(:name => "choice")
 
-      aic = MINT::AIC.create(:name => "container", :states=>[:defocused],:childs =>[sc])
+        aic = MINT::AIContainer.create(:name => "container", :states=>[:defocused], :children => "choice")
 
-      aic.process_event(:suspend).should == [:suspended]
-      e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
-      e1.states.should == [:suspended]
+        aic.process_event(:suspend).should == [:suspended]
+        e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
+        e1.states.should == [:suspended]
+      end
+    end
 
-      s4=MINT::Selectable.first(:name =>"element_4")
-      s4.states.should ==[:hidden]
-      rbg = MINT::RadioButtonGroup.first(:name=>"choice")
-      rbg.states.should == [:hidden]
+    it "should sync suspend to CUI"   do
+      connect true do |redis|
+
+        parser = MINT::MappingParser.new
+        m = parser.build_from_scxml File.dirname(__FILE__) +"/../lib/MINT-core/model/mim/aio_suspend_to_cio_hide.xml"
+        m.start
+        #TODO Find out from where these RadioButtonGroup states come from
+        sc = Helper.initialize_main_structure
+
+        MINT::RadioButtonGroup.create(:name =>"choice", :states => [:displayed])
+        MINT::RadioButton.create(:name =>"element_1", :states =>[:displayed,:unselected])
+        MINT::RadioButton.create(:name =>"element_2", :states =>[:displayed,:unselected])
+        MINT::RadioButton.create(:name =>"element_3", :states =>[:displayed,:unselected])
+        MINT::RadioButton.create(:name =>"element_4", :states =>[:displayed,:unselected])
+        aic = MINT::AIContainer.create(:name => "container", :states=>[:defocused], :children => "choice")
+        MINT::CIC.create(:name => "container", :states =>[:displayed])
+
+        check_result = Proc.new {
+          e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
+          e1.states.should == [:suspended]
+
+          s4 = MINT::RadioButton.first(:name =>"element_4")
+          s4.states.should == [:hidden]
+          rbg = MINT::RadioButtonGroup.first(:name=>"choice")
+          rbg.states.should == [:hidden]
+
+          done
+        }
+
+        test_complex_state_flow_w_name redis,[["Interactor.CIO.RadioButton","element_2" ,["hidden"]]],check_result do  |count|
+          aic.process_event(:suspend).should == [:suspended]
+        end
+      end
     end
 
     it "should remove elements that have been dropped elsewhere"   do
-      pending("get drop from drag n drop working")
-      sc =MINT::AISingleChoice.first(:name => "choice")
-      e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
-      e1.process_event(:drag)
-      #e1.process_event(:drop)
-      dest =MINT::AISingleChoice.create(:name => "choice_dest",:states => [:defocused,:unchosen])
-      dest.process_event(:drop)
-      #dest.childs << e1
-      #p dest.childs.save
-      sc.childs.length.should ==3
-      dest.childs.length.should ==1
-      p sc.childs.inspect
-      e1 = MINT::AISingleChoiceElement.first(:name => "element_1").should_not == nil
-
+      connect do |redis|
+        #TODO Figure out how to make the AISingleChoice.add work again
+        Helper.initialize_main_structure
+
+        sc = MINT::AISingleChoice.first(:name => "choice")
+        e1 = MINT::AISingleChoiceElement.first(:name => "element_1")
+        e1.process_event(:focus)
+        e1.process_event(:drag)
+        dest = MINT::AISingleChoice.create(:name => "choice_dest")
+        AUIControl.organize(dest,nil, 0)
+        dest.process_event(:present)
+        dest.process_event :children_finished
+        dest.process_event(:focus)
+        dest.process_event(:drop)
+
+        sc = MINT::AISingleChoice.first(:name => "choice")
+        sc.children.length.should == 3
+
+        dest = MINT::AISingleChoice.first(:name => "choice_dest")
+        dest.children.length.should == 1
+        p sc.children.inspect
+        e1 = MINT::AISingleChoiceElement.first(:name => "element_1").should_not == nil
+      end
     end
   end
 

data/spec/aisinglechoiceelement_spec.rb

@@ -1,106 +1,190 @@
 require "spec_helper"
 
 describe 'SingleChoiceElement' do
-  before :each do
-    connection_options = { :adapter => "in_memory"}
+
+  include EventMachine::SpecHelper
+
+  before :all do
+    connection_options = { :adapter => "redis"}
     DataMapper.setup(:default, connection_options)
-    @a = MINT::AISingleChoiceElement.create(:name => "test")
+
+    connect do |redis|
+      require "MINT-core"
+
+      DataMapper.finalize
+      DataMapper::Model.raise_on_save_failure = true
+
+    end
   end
 
   it 'should initialize with initiated' do
-    @a.states.should == [:initialized]
+    connect do |redis|
+      @a = MINT::AISingleChoiceElement.create(:name => "test")
+      @a.states.should == [:initialized]
+    end
   end
 
   it 'should transform to organizing state for present action' do
-    @a.process_event(:organize).should == [:organized]
-    @a.states.should == [:organized]
+    connect do |redis|
+      @a = MINT::AISingleChoiceElement.create(:name => "test")
+      @a.process_event(:organize).should == [:organized]
+      @a.states.should == [:organized]
+    end
   end
 
   it 'should call back after event has been processed' do
-    class CallbackContext
-      attr_accessor :called
+    connect do |redis|
+      @a = MINT::AISingleChoiceElement.create(:name => "test")
+      class CallbackContext
+        attr_accessor :called
 
-      def initialize
-        @called = false
-      end
-      def focus_next
-        @called = true
-      end
-      def sync_cio_to_displayed
-      end
-      def sync_cio_to_highlighted
-      end
-      def sync_cio_to_listed
+        def initialize
+          @called = false
+        end
+        def focus_next
+          @called = true
+        end
+        def sync_cio_to_displayed
+        end
+        def sync_cio_to_highlighted
+        end
+        def sync_cio_to_unchosen
+        end
+        def exists_next
+          true
+        end
+        def exists_prev
+          true
+        end
       end
-      def exists_next
-        true
-      end
-      def exists_prev
-        true
-      end
-    end
 
-    callback = CallbackContext.new
+      callback = CallbackContext.new
 
 
-    @a.process_event(:organize,callback).should == [:organized]
-    callback.called.should == false
+      @a.process_event(:organize,callback).should == [:organized]
+      callback.called.should == false
 
-    @a.process_event(:present,callback).should == [:defocused, :unchosen]
-    @a.states.should == [:defocused, :unchosen]
-    @a.new_states.should == [:defocused, :unchosen, :p_t, :presenting, :selection_H]
-    callback.called.should == false
+      @a.process_event(:present,callback).should == [:defocused, :unchosen]
+      @a.states.should == [:defocused, :unchosen]
+      @a.new_states.should == [:defocused, :unchosen, :p, :presenting, :choice, :c]
+      callback.called.should == false
 
-    @a.process_event(:focus,callback).should == [:focused, :unchosen]
-    @a.new_states.should == [:focused]
-    callback.called.should == false
+      @a.process_event(:focus,callback).should == [:focused, :unchosen]
+      @a.new_states.should == [:focused]
+      callback.called.should == false
 
-    @a.process_event(:next,callback).should == [:defocused, :unchosen]
-    @a.new_states.should == [:defocused]
-    callback.called.should == true
+      @a.process_event(:next,callback).should == [:defocused, :unchosen]
+      @a.new_states.should == [:defocused]
+      callback.called.should == true
+    end
   end
 
   it 'should recover state after save and reload' do
-    @a.process_event(:organize).should == [:organized]
-    @a.save!
-    b =  MINT::AIO.first(:name=>"test")
-    b.states.should == [:organized]
-    b.new_states.should == [:organized]
-    b.process_event(:present).should == [:defocused, :unchosen]
-    b.new_states.should == [:defocused, :unchosen, :p_t, :presenting, :selection_H]
-
+    connect do |redis|
+      @a = MINT::AISingleChoiceElement.create(:name => "test")
+      @a.process_event(:organize).should == [:organized]
+      @a.save!
+      b =  MINT::AIO.first(:name=>"test")
+      b.states.should == [:organized]
+      b.new_states.should == [:organized]
+      b.process_event(:present).should == [:defocused, :unchosen]
+      b.new_states.should == [:defocused, :unchosen, :p, :presenting, :choice, :c]
+    end
   end
 
   it 'should recover state after save and reload from inside parallel state' do
-    @a.process_event(:organize).should == [:organized]
-    @a.process_event(:present).should == [:defocused, :unchosen]
-    @a.process_event(:focus).should == [:focused, :unchosen]
-    @a.save!
-    b =  MINT::AIO.first(:name=>"test")
-    b.states.should ==[:focused, :unchosen]
-    b.process_event(:defocus).should == [:defocused, :unchosen]
-    #b.process_event(:choose).should == [:presented, :choosing]
+    connect do |redis|
+      @a = MINT::AISingleChoiceElement.create(:name => "test")
+      @a.process_event(:organize).should == [:organized]
+      @a.process_event(:present).should == [:defocused, :unchosen]
+      @a.process_event(:focus).should == [:focused, :unchosen]
+      @a.save!
+      b =  MINT::AIO.first(:name=>"test")
+      b.states.should ==[:focused, :unchosen]
+      b.process_event(:defocus).should == [:defocused, :unchosen]
+      #b.process_event(:choose).should == [:presented, :choosing]
+    end
   end
+
   it 'should support for query-based selection' do
-    @a.process_event(:organize).should == [:organized]
-    @a.process_event(:present).should == [:defocused, :unchosen]
-    @a.save!
-    b =  MINT::AIO.first(:states=>/unchosen/)
-    b.name.should == "test"
-    c =  MINT::AIO.first(:states=>/defocused/)
-    c.name.should == "test"
+    connect do |redis|
+      @a = MINT::AISingleChoiceElement.create(:name => "test")
+      @a.process_event(:organize).should == [:organized]
+      @a.process_event(:present).should == [:defocused, :unchosen]
+      @a.save!
+      b =  MINT::AIO.first(:states=>/unchosen/)
+      b.name.should == "test"
+      c =  MINT::AIO.first(:states=>/defocused/)
+      c.name.should == "test"
+    end
   end
+
   it 'should support for querying for superstates' do
-    @a.process_event(:organize).should == [:organized]
-    @a.process_event(:present).should == [:defocused, :unchosen]
-    @a.save!
-    puts @a.abstract_states
-    b =  MINT::AIO.first(:abstract_states=>/presenting/)
-    b.name.should == "test"
+    connect do |redis|
+      @a = MINT::AISingleChoiceElement.create(:name => "test")
+      @a.process_event(:organize).should == [:organized]
+      @a.process_event(:present).should == [:defocused, :unchosen]
+      @a.save!
+      puts @a.abstract_states
+      b =  MINT::AIO.first(:abstract_states=>/presenting/)
+      b.name.should == "test"
+    end
   end
+
   it "should save abstract states property upon initial element creation" do
-    @a = MINT::AISingleChoiceElement.create(:name => "test")
-    puts @a.abstract_states
+    connect do |redis|
+      @a = MINT::AISingleChoiceElement.create(:name => "test")
+      @a.abstract_states.should == "AISingleChoiceElement|root"
+    end
+  end
+
+  it "should retrieve the correct abstract states after entering parallel states" do
+    connect do |redis|
+      @a = MINT::AISingleChoiceElement.create(:name => "test")
+      @a.process_event(:organize).should == [:organized]
+      @a.process_event(:present).should == [:defocused, :unchosen]
+      @a.abstract_states.should == "AISingleChoiceElement|root|p|presenting|choice|c"
+    end
+  end
+
+  it "should retrieve the correct abstract states after leaving parallel states" do
+    connect do |redis|
+      @a = MINT::AISingleChoiceElement.create(:name => "test")
+      @a.process_event(:organize).should == [:organized]
+      @a.process_event(:present).should == [:defocused, :unchosen]
+      @a.process_event(:suspend).should == [:suspended]
+      @a.abstract_states.should == "AISingleChoiceElement|root"
+    end
+  end
+
+  it "should remove itself from parent choice if it enters dragging state (case: choice with just one element)" do
+    connect do |redis|
+      @a = MINT::AISingleChoiceElement.create(:name => "test",:parent=>"choice",:states=> [:focused, :chosen])
+      @c = MINT::AISingleChoice.create(:name => "choice",:children=>"test",:states=>[:defocused,:listing])
+
+      @a.process_event(:drag).should == [:focused,:dragging]
 
+      MINT::AISingleChoiceElement.first.parent.should == nil
+      MINT::AISingleChoice.first.children.to_a.empty?.should ==true
+
+    end
   end
+
+  it "should remove itself from parent choice if it enters dragging state (case: choice with several elements)" do
+    connect do |redis|
+      MINT::AISingleChoiceElement.create(:name => "A",:parent=>"choice",:states=> [:focused, :chosen])
+      @a = MINT::AISingleChoiceElement.create(:name => "B",:parent=>"choice",:states=> [:focused, :chosen])
+      MINT::AISingleChoiceElement.create(:name => "C",:parent=>"choice",:states=> [:focused, :chosen])
+
+      @c = MINT::AISingleChoice.create(:name => "choice",:children=>"A|B|C",:states=>[:defocused,:listing])
+
+      @a.process_event(:drag).should == [:focused,:dragging]
+
+      MINT::AISingleChoiceElement.get("aui","B").parent.should == nil
+      MINT::AISingleChoice.first.children.length.should == 2
+
+    end
+  end
+
+
 end