apotomo 0.1.1

data/test/unit/test_addressing.rb

@@ -0,0 +1,111 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+
+class AddressingTest < Test::Unit::TestCase
+  include Apotomo::UnitTestCase
+  
+  def test_url_fragment
+    frag = Apotomo::DeepLinkMethods::UrlFragment.new("tabs=first/mouse=eating")
+    
+    assert_equal "tabs=first/mouse=eating", frag.to_s
+    assert_equal "first",   frag[:tabs]
+    assert_equal "first",   frag['tabs']
+    assert_equal "eating",  frag[:mouse]
+    assert_equal "eating",  frag['mouse']
+    assert_equal nil,       frag[:non_existent]
+    
+    frag = Apotomo::DeepLinkMethods::UrlFragment.new(nil)
+    assert_equal nil,       frag[:non_existent]
+  end
+  
+  def test_url_fragment_accessor
+    assert_kind_of Apotomo::DeepLinkMethods::UrlFragment, mouse_mock.url_fragment
+  end
+  
+  def test_url_fragment_blank?
+    assert Apotomo::DeepLinkMethods::UrlFragment.new("").blank?
+  end
+  
+  
+  def test_responds_to_url_change?
+    m = mouse_mock
+    assert ! m.responds_to_url_change?
+    
+    m.respond_to_event :urlChange, :with => :eating
+    assert m.responds_to_url_change?, "should be true as an :urlChanged listener is attached."
+    
+    # test with explicit source:
+    m = mouse_mock
+    m.respond_to_event :urlChange, :with => :eating, :from => 'mouse'
+    assert m.responds_to_url_change?, "should be true as an :urlChanged listener is attached."
+  end
+  
+  def test_deep_link_addressing
+    t = mouse_mock('top', :upside) do
+      def local_fragment; "top=upside"; end
+    end
+    b = mouse_mock('bottom', :downside) do
+      def local_fragment; "bottom=downside"; end
+    end
+    
+    t.respond_to_event :urlChange, :with => :eating
+    b.respond_to_event :urlChange, :with => :eating
+    
+    t << b
+      b << j = cell(:mouse, :eating, 'jerry')
+    
+    
+    assert_equal "top=upside",  t.local_fragment
+    assert_equal "v",           t.url_fragment_for("v")
+    
+    assert_equal "bottom=downside",             b.local_fragment
+    assert_equal "top=upside/bottom=downside",  b.url_fragment_for
+    assert_equal "top=upside/v",                b.url_fragment_for('v')
+    
+    assert_equal nil, j.local_fragment
+    assert_equal "top=upside/bottom=downside",        j.url_fragment_for
+    assert_equal "top=upside/bottom=downside/jerry",  j.url_fragment_for('jerry')
+  end
+  
+  
+  def test_default_local_fragment
+    assert_equal nil, mouse_mock.local_fragment
+  end
+  
+  
+  def test_responds_to_url_change_for
+    m = mouse_mock do
+      def eating; render :nothing => :true; end
+    end
+    
+    assert ! m.responds_to_url_change_for?(""), "should return false by default"
+  end
+  
+  
+  def test_path
+    w= cell(:my_test, :some, 'root')
+    assert_equal w.path, 'root'
+    
+    w << a= cell(:my_test, :some, 'a')
+    
+    assert_equal a.path, 'root/a'
+  end
+  
+  
+  def test_find
+    root = widget("apotomo/stateful_widget", :widget_content, 'root')
+      root << a = widget("apotomo/stateful_widget", :widget_content, 'a')
+        a << aa = widget("apotomo/stateful_widget", :widget_content, 'a')
+    
+    assert_equal a, root.find_by_id("a")
+    assert_equal a, root.find_by_path("a")
+    assert_equal a, root.find_by_path(:a)
+    assert_equal aa, root.find_by_path("a a")
+  end
+  
+end
+
+class MyTestCell < Apotomo::StatefulWidget
+  
+
+end

data/test/unit/test_caching.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+
+class ApotomoCachingTest < Test::Unit::TestCase
+  include Apotomo::UnitTestCase
+  
+  def setup
+    super
+    @controller.session= {}
+    @cc = CachingCell.new('caching_cell', :start)
+    @cc.controller = @controller
+  end
+  
+  
+  def test_caching_with_instance_version_proc
+    unless ActionController::Base.cache_configured?
+      throw Exception.new "cache_configured? returned false. You may enable caching in your config/environments/test.rb to make this test pass."
+      return
+    end
+    c1 = @cc.invoke
+    c2 = @cc.invoke
+    assert_equal c1, c2
+    
+    @cc.dirty!
+    
+    c3 = @cc.invoke
+    assert c2 != c3
+  end
+  
+end
+
+
+class CachingCell < Apotomo::StatefulWidget
+  
+  cache :cached_state
+  
+  transition :in => :cached_state
+  
+  
+  def start
+    jump_to_state :cached_state
+  end
+  
+  def cached_state
+    @counter ||= 0
+    @counter += 1
+    "#{@counter}"
+    
+  end
+  
+  def not_cached_state
+    "i'm really static"
+  end
+end

data/test/unit/test_jump_to_state.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+### DISCUSS: move some tests from PersistenceTest to this test file.
+
+
+class InterStateTest < ActionController::TestCase
+  include Apotomo::UnitTestCase  
+  
+  # do we really jump to the correct state?
+  # and: are all state ivars remembered while jumping?
+  def test_three_state_jumps
+    w = StateJumpCell.new('x', :one)
+    w.controller = @controller
+    
+    c = w.invoke  # :one -> :two -> :three
+    
+    assert_state w, :three
+    puts "brain dump:"
+    puts w.brain.inspect
+    
+    assert w.brain.include?("@var")
+    assert w.brain.include?("@one");
+    assert_equal "three,one", c
+  end
+  
+  
+  def test_brain_reset_when_invoking_a_start_state
+    w = StateJumpCell.new('x', :counter)
+    w.controller = @controller
+    
+    assert_equal "1", w.invoke
+    # another #invoke will flush brain:
+    assert_equal "1", w.invoke
+  end
+  
+  def test_brain_reset_when_jumping_to_a_start_state
+    w = StateJumpCell.new('x', :counter)
+    w.controller = @controller
+    w.instance_eval do
+      def back_to_start
+        jump_to_state :counter  # :counter is a start state.
+      end
+    end
+    
+    assert_equal "1", w.invoke
+    # if using #jump_to_state there should be NO brain flush:
+    assert_equal "2", w.invoke_state(:back_to_start)
+  end
+  
+  
+  def test_last_state
+    w = StateJumpCell.new('x', :four)
+    w.controller = @controller
+    c = w.invoke
+    assert_equal w.last_state, :four
+  end
+  
+end 
+
+
+class StateJumpCell < Apotomo::StatefulWidget
+  attr_reader :brain
+  def one
+    @var = "one"
+    @one = "one"
+    jump_to_state :two
+  end
+  
+  def two
+    @var = "two"
+    jump_to_state :three
+  end
+  
+  def three
+    @var = "three"
+    render :text => "#{@var},#{@one}"
+  end
+  
+  def four
+    render :text => ""
+  end
+  
+  def counter
+    @counter ||= 0
+    @counter += 1
+    render :text => @counter.to_s
+  end
+  
+end

data/test/unit/test_tab_panel.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+
+class TabPanelTest < Test::Unit::TestCase
+  include Apotomo::UnitTestCase
+  
+  def test_responds_to_url_change_for?
+    fragment =  Apotomo::DeepLinkMethods::UrlFragment
+    
+    w = tab_panel('mice', :is_url_listener => true)
+    w.current_child_id = 'jerry'
+    
+    assert ! w.responds_to_url_change_for?(fragment.new ""), "shouldn't respond to emtpy url"
+    assert ! w.responds_to_url_change_for?(fragment.new "cats=tom"), "shouldn't respond to foreign url"
+    assert ! w.responds_to_url_change_for?(fragment.new "mice=jerry")
+    assert ! w.responds_to_url_change_for?(fragment.new "mice="), "shouldn't respond to invalid url"
+    assert   w.responds_to_url_change_for?(fragment.new "mice=berry")
+  end
+  
+  def test_local_fragment
+    w = tab_panel('mice')
+    w.current_child_id = 'jerry'
+    
+    assert_equal "mice=jerry", w.local_fragment 
+  end
+  
+  def test_find_current_child_from_query
+    w = tab_panel('mice')
+      w << tab('jerry')
+      w << tab('berry')
+      w << tab('micky')
+    
+    w.controller = controller
+    
+    
+    # default child:
+    assert_equal 'jerry', w.find_current_child.name
+    ### FIXME: i hate the usage of global parameters:
+    controller.params = {'mice' => 'micky', :deep_link => 'mice=berry'}
+    
+    assert_equal 'micky', w.find_current_child.name, "didn't process the query string ?mice=micky"
+  end
+  
+  def test_find_current_child_from_fragment
+    w = tab_panel('mice', :is_url_listener => true)
+      w << tab('jerry')
+      w << tab('berry')
+      w << tab('micky')
+    
+    w.controller = controller
+    
+    ### FIXME: i hate the usage of global parameters:
+    controller.params = {'mice' => 'micky', :deep_link => 'mice=berry'}
+    
+    assert_equal 'berry', w.find_current_child.name, "didn't process the url fragment 'mice=berry'"
+  end
+  
+  def test_url_fragment_for_tab
+    w = tab_panel('mice', :is_url_listener => true)
+      w << j= tab('jerry')
+        j << c= tab_panel('jerrys_kids', :is_url_listener => true)
+          c << r= tab('jerry_jr')
+      w << b= tab('berry')
+    
+    w.current_child_id = 'jerry'
+    
+    assert_equal "mice=berry", w.url_fragment_for_tab(b)
+    assert_equal "mice=jerry", w.url_fragment_for_tab(j)
+    
+    assert_equal "mice=jerry/jerrys_kids=jerry_jr", c.url_fragment_for_tab(r)
+  end
+end

data/test/unit/test_widget_shortcuts.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+
+# fixture:
+module My
+  class TestCell < Apotomo::StatefulWidget
+    def a_state
+      "a_state"
+    end
+  end
+  
+  class TestWidget < Apotomo::StatefulWidget
+    def a_state
+      "a_state"
+    end
+  end
+end
+
+class MyTestWidgetTree < Apotomo::WidgetTree  
+  def draw(root)
+    root << widget('apotomo/stateful_widget', :widget_content, 'widget_one')
+    root << cell(:my_test, :a_state, 'my_test_cell')
+    root << switch('my_switch') << widget('apotomo/stateful_widget', :widget_content, :child_widget)
+    root << section('my_section')
+    root << widget('apotomo/stateful_widget', :widget_content, :widget_three)
+    #root  ### FIXME! find a way to return nothing by default.
+  end
+end
+
+
+class WidgetShortcutsTest < Test::Unit::TestCase
+  include Apotomo::UnitTestCase
+  
+  
+  def test_cell
+    assert_kind_of My::TestCell, cell("my/test", :a_state, 'my_test_cell')
+  end
+  
+  def test_widget
+    w = widget("my/test_widget", :a_state, 'my_test_cell')
+    assert_kind_of My::TestWidget, w
+    assert_equal "my_test_cell", w.name
+  end
+  
+end

data/test/unit/transition_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), *%w[.. test_helper])
+
+class TransitionTest < Test::Unit::TestCase
+  context "Calling #next_state_for" do
+    setup do
+      @mum = Object.new
+      @mum.class.instance_eval do
+          include Apotomo::Transition
+      end
+    end
+    
+    should "return nil when no transition is defined" do
+      assert_not @mum.send(:next_state_for, :snuggle)
+    end
+    
+    should "return the defined next state" do
+      @mum.class.instance_eval do
+        transition :from => :snuggle, :to => :sleep
+      end
+      
+      assert_equal :sleep, @mum.send(:next_state_for, :snuggle)
+    end
+    
+    should "return the state that was defined last" do
+      @mum.class.instance_eval do
+        transition :from => :snuggle, :to => :sleep
+        transition :from => :snuggle, :to => :snore
+      end
+      
+      assert_equal :snore, @mum.send(:next_state_for, :snuggle)
+    end
+  end
+end

data/test/unit/widget_shortcuts_test.rb

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), *%w[.. test_helper])
+
+class MumWidget < MouseCell; end
+
+class WidgetShortcutsTest < Test::Unit::TestCase
+  context "#cell" do
+    should "create a MouseCell instance for backward-compatibility" do
+      assert_kind_of MouseCell, cell(:mouse, :eating, 'mum')
+    end
+  end
+  
+  context "#widget" do
+    context "with all arguments" do
+      setup do
+        @mum = widget(:mum_widget, 'mum', :eating)
+      end
+      
+      should "create a MumWidget instance" do
+        assert_kind_of MumWidget, @mum
+        assert_equal :eating, @mum.instance_variable_get(:@start_state)
+        assert_equal 'mum', @mum.name
+      end
+    end
+    
+    context "with id only" do
+      setup do
+        @mum = widget(:mum_widget, 'mum')
+      end
+      
+      should "create a MumWidget instance with :display start state" do
+        assert_kind_of MumWidget, @mum
+        assert_equal :display, @mum.instance_variable_get(:@start_state)
+        assert_equal 'mum', @mum.name
+      end
+    end
+    
+    should "yield itself" do
+      @mum = widget(:mum_widget, :snuggle, 'mum') do |mum|
+        assert_kind_of MumWidget, mum
+        mum << widget(:mum_widget, 'kid', :sleep)
+      end
+      assert_equal 2, @mum.size
+      assert_kind_of MumWidget, @mum['kid']
+    end
+  end
+  
+  context "#container" do
+    setup do
+      @family = container('family')
+    end
+    
+    should "create a ContainerWidget instance" do
+      assert_kind_of ::Apotomo::ContainerWidget, @family
+      assert_equal 'family', @family.name
+    end
+    
+    should "yield itself" do
+      @container = container(:family) do |family|
+        family << widget(:mum_widget, 'mum')
+      end
+      assert_equal 2, @container.size
+    end
+    
+    should "be aliased to #section for backward-compatibility" do
+      assert_kind_of ::Apotomo::ContainerWidget, section('family')
+    end
+  end
+end