spec/transition_spec.rb in edge-state-machine-0.0.3 vs spec/transition_spec.rb in edge-state-machine-0.9.0

@@ -1,100 +1,100 @@
 require 'spec_helper'
 
 describe EdgeStateMachine::Transition do
-  it "should set from, to, and opts attr readers" do
-    opts = {:from => "foo", :to => "bar", :guard => "g"}
+  it 'should set from, to, and opts attr readers' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
     st = EdgeStateMachine::Transition.new(opts)
 
     st.from.should == [opts[:from]].flatten
     st.to.should == [opts[:to]].flatten
   end
 
-  it "should pass equality check if from and to are the same" do
-    opts = {:from => "foo", :to => "bar", :guard => "g"}
+  it 'should pass equality check if from and to are the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
     st = EdgeStateMachine::Transition.new(opts)
     obj = EdgeStateMachine::Transition.new(opts)
     obj.should == st
   end
 
-  it "should fail equality check if from are not the same" do
-    opts = {:from => "foo", :to => "bar", :guard => "g"}
+  it 'should fail equality check if from are not the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
     st = EdgeStateMachine::Transition.new(opts)
-    obj = EdgeStateMachine::Transition.new(opts.merge({:from => "blah"}))
+    obj = EdgeStateMachine::Transition.new(opts.merge({:from => 'blah'}))
     obj.should_not == st
   end
 
-  it "should fail equality check if to are not the same" do
-    opts = {:from => "foo", :to => "bar", :guard => "g"}
+  it 'should fail equality check if to are not the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
     st = EdgeStateMachine::Transition.new(opts)
-    obj = EdgeStateMachine::Transition.new(opts.merge({:to => "blah"}))
+    obj = EdgeStateMachine::Transition.new(opts.merge({:to => 'blah'}))
     obj.should_not == st
   end
 
-  describe "state transition guard check" do
-    it "should return true of there is no guard" do
-      opts = {:from => "foo", :to => "bar"}
+  describe 'state transition guard check' do
+    it 'should return true of there is no guard' do
+      opts = {:from => 'foo', :to => 'bar'}
       st = EdgeStateMachine::Transition.new(opts)
       st.possible?(nil).should == true
     end
 
-    it "should call the method on the object if guard is a symbol" do
-      opts = {:from => "foo", :to => "bar", :guard => :test_guard}
+    it 'should call the method on the object if guard is a symbol' do
+      opts = {:from => 'foo', :to => 'bar', :guard => :test_guard}
       st = EdgeStateMachine::Transition.new(opts)
 
       obj = mock
       obj.should_receive(:test_guard)
 
       st.find_next_state(obj)
     end
 
-    it "should call the method on the object if guard is a string" do
-      opts = {:from => "foo", :to => "bar", :guard => "test_guard"}
+    it 'should call the method on the object if guard is a string' do
+      opts = {:from => 'foo', :to => 'bar', :guard => 'test_guard'}
       st = EdgeStateMachine::Transition.new(opts)
 
       obj = mock
       obj.should_receive(:test_guard)
 
       st.find_next_state(obj)
     end
 
-    it "should call the proc passing the object if the guard is a proc" do
-      opts = {:from => "foo", :to => "bar", :guard => Proc.new {|o| o.test_guard}}
+    it 'should call the proc passing the object if the guard is a proc' do
+      opts = {:from => 'foo', :to => 'bar', :guard => Proc.new {|o| o.test_guard}}
       st = EdgeStateMachine::Transition.new(opts)
 
       obj = mock
       obj.should_receive(:test_guard)
 
       st.find_next_state(obj)
     end
   end
 
-  describe "on transition execution" do
-    it "should call the method on the object if on_transition is a symbol" do
-      opts = {:from => "foo", :to => "bar", :on_transition => :test_on_transition}
+  describe 'on transition execution' do
+    it 'should call the method on the object if on_transition is a symbol' do
+      opts = {:from => 'foo', :to => 'bar', :on_transition => :test_on_transition}
       st = EdgeStateMachine::Transition.new(opts)
       obj = mock
       obj.should_receive(:test_on_transition)
       st.execute(obj)
     end
 
-    it "should call the method on the object if on_transition is a string" do
+    it 'should call the method on the object if on_transition is a string' do
       opts = {:from => 'foo', :to => 'bar', :on_transition => 'test_on_transition'}
       st = EdgeStateMachine::Transition.new(opts)
       obj = mock
       obj.should_receive(:test_on_transition)
       st.execute(obj)
     end
 
-    it "should call the method on the object if on_transition is a proc" do
+    it 'should call the method on the object if on_transition is a proc' do
       opts = {:from => 'foo', :to => 'bar', :on_transition => Proc.new {|o| o.test_on_transition}}
       st = EdgeStateMachine::Transition.new(opts)
       obj = mock
       obj.should_receive(:test_on_transition)
       st.execute(obj)
     end
 
-    it "should call all the methods/procs if on_transition is an array" do
+    it 'should call all the methods/procs if on_transition is an array' do
       opts = { :from => 'foo',
                 :to => 'bar',
                 :on_transition => [Proc.new {|o| o.test_on_transition}, :test_on_transition, 'test_on_transition']}
       st = EdgeStateMachine::Transition.new(opts)
       obj = mock