apotomo 1.0.5 → 1.1.0.rc1

data/test/unit/stateful_widget_test.rb

@@ -1,58 +0,0 @@
-require 'test_helper'
-
-class StatefulWidgetTest < Test::Unit::TestCase
-  include Apotomo::TestCaseMethods::TestController
-  
-  context "The StatefulWidget" do
-    setup do
-      @mum = Apotomo::StatefulWidget.new(parent_controller, 'mum', :squeak)
-    end
-    
-    should "accept an id as first option" do
-      assert_equal 'mum', @mum.name
-    end
-    
-    should "accept a start state as second option" do
-      assert_equal :squeak, @mum.instance_variable_get('@start_state')
-    end
-    
-    should "respond to #version" do
-      assert_equal 0, mouse_mock.version
-    end
-    
-    should "have a version setter" do
-      @mum = mouse_mock
-      @mum.version = 1
-      assert_equal 1, @mum.version
-    end
-  end
-  
-  context "mum having a family" do
-    setup do
-      mum_and_kid!
-      @mum << @berry = mouse_mock('berry')
-        @berry << @pet = mouse_mock('pet')
-    end
-    
-    context "responding to #render_children" do
-      should "return an OrderedHash for the rendered kids" do
-        kids = @mum.render_children
-        assert_kind_of ::ActiveSupport::OrderedHash, kids
-        assert_equal 2, kids.size
-      end
-      
-      should "return an OrderedHash even if there are no kids" do
-        kids = @kid.render_children
-        assert_kind_of ::ActiveSupport::OrderedHash, kids
-        assert_equal 0, kids.size
-      end
-      
-      should "return an empty OrderedHash when all kids are invisible" do
-        @pet.visible = false
-        kids = @berry.render_children
-        assert_kind_of ::ActiveSupport::OrderedHash, kids
-        assert_equal 0, kids.size
-      end
-    end
-  end
-end

data/test/unit/test_addressing.rb

@@ -1,110 +0,0 @@
-require '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_jump_to_state.rb

@@ -1,89 +0,0 @@
-require '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

@@ -1,71 +0,0 @@
-require '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/transition_test.rb

@@ -1,34 +0,0 @@
-require '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)
-      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