transaction-simple 1.3.0 → 1.4.0

data/test/test_all.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+#--
+# Transaction::Simple
+# Simple object transaction support for Ruby
+# http://rubyforge.org/projects/trans-simple/
+#   Version 1.4.0
+#
+# Licensed under a MIT-style licence. See Licence.txt in the main
+# distribution for full licensing information.
+#
+# Copyright (c) 2003 - 2007 Austin Ziegler
+#
+# $Id: test_all.rb 55 2007-02-03 23:29:34Z austin $
+#++
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0
+
+$stderr.puts "Checking for test cases:"
+
+Dir[File.join(File.dirname($0), 'test_*.rb')].each do |testcase|
+  next if File.basename(testcase) == File.basename(__FILE__)
+  $stderr.puts "\t#{testcase}"
+  load testcase
+end
+$stderr.puts " "

data/test/test_broken_graph.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+#--
+# Transaction::Simple
+# Simple object transaction support for Ruby
+# http://rubyforge.org/projects/trans-simple/
+#   Version 1.4.0
+#
+# Licensed under a MIT-style licence. See Licence.txt in the main
+# distribution for full licensing information.
+#
+# Copyright (c) 2003 - 2007 Austin Ziegler
+#
+# $Id: simple.rb,v 1.7 2005/06/12 19:48:17 austin Exp $
+#++
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0
+
+require 'transaction/simple'
+require 'test/unit'
+
+module Transaction::Simple::Test
+  class BrokenGraph < Test::Unit::TestCase #:nodoc:
+    class Child
+      attr_accessor :parent
+    end
+
+    class BrokenParent
+      include Transaction::Simple
+
+      attr_reader :children
+      def initialize
+        @children = []
+      end
+
+      def <<(child)
+        child.parent = self
+        @children << child
+      end
+    end
+
+    class FixedParent < BrokenParent
+      # Reconnect the restored children to me, instead of to the bogus me
+      # that was restored to them by Marshal::load.
+      def _post_transaction_rewind
+        @children.each { |child| child.parent = self }
+      end
+    end
+
+    def test_broken_graph
+      parent = BrokenParent.new
+      parent << Child.new
+      assert_equal(parent.object_id, parent.children[0].parent.object_id)
+      parent.start_transaction
+      parent << Child.new
+      assert_equal(parent.object_id, parent.children[1].parent.object_id)
+      parent.abort_transaction
+      assert_not_equal(parent.object_id, parent.children[0].parent.object_id)
+    end
+
+    def test_fixed_graph
+      parent = FixedParent.new
+      parent << Child.new
+      assert_equal(parent.object_id, parent.children[0].parent.object_id)
+      parent.start_transaction
+      parent << Child.new
+      assert_equal(parent.object_id, parent.children[1].parent.object_id)
+      parent.abort_transaction
+      assert_equal(parent.object_id, parent.children[0].parent.object_id)
+    end
+  end
+end

data/test/test_transaction_simple.rb

@@ -0,0 +1,311 @@
+#!/usr/bin/env ruby
+#--
+# Transaction::Simple
+# Simple object transaction support for Ruby
+# http://rubyforge.org/projects/trans-simple/
+#   Version 1.4.0
+#
+# Licensed under a MIT-style licence. See Licence.txt in the main
+# distribution for full licensing information.
+#
+# Copyright (c) 2003 - 2007 Austin Ziegler
+#
+# $Id: test_transaction_simple.rb 50 2007-02-03 20:26:19Z austin $
+#++
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0
+
+require 'transaction/simple'
+require 'test/unit'
+
+module Transaction::Simple::Test
+  class TransactionSimple < Test::Unit::TestCase #:nodoc:
+    VALUE = "Now is the time for all good men to come to the aid of their country."
+
+    class Value
+      def initialize
+        @value = VALUE.dup
+      end
+
+      def method_missing(meth, *args, &block)
+        @value.__send__(meth, *args, &block)
+      end
+
+      def ==(other)
+        other == @value
+      end
+
+      def to_str
+        @value
+      end
+    end
+
+    def setup
+      @value = Value.new
+      @value.extend(Transaction::Simple)
+    end
+
+    def test_extended
+      assert_respond_to(@value, :start_transaction)
+    end
+
+    def test_started
+      assert_equal(false, @value.transaction_open?)
+      assert_nothing_raised { @value.start_transaction }
+      assert_equal(true, @value.transaction_open?)
+    end
+
+    def test_rewind
+      assert_equal(false, @value.transaction_open?)
+      assert_raises(Transaction::TransactionError) { @value.rewind_transaction }
+      assert_nothing_raised { @value.start_transaction }
+      assert_equal(true, @value.transaction_open?)
+      assert_nothing_raised { @value.gsub!(/men/, 'women') }
+      assert_not_equal(VALUE, @value)
+      assert_nothing_raised { @value.rewind_transaction }
+      assert_equal(true, @value.transaction_open?)
+      assert_equal(VALUE, @value)
+    end
+
+    def test_abort
+      assert_equal(false, @value.transaction_open?)
+      assert_raises(Transaction::TransactionError) { @value.abort_transaction }
+      assert_nothing_raised { @value.start_transaction }
+      assert_equal(true, @value.transaction_open?)
+      assert_nothing_raised { @value.gsub!(/men/, 'women') }
+      assert_not_equal(VALUE, @value)
+      assert_nothing_raised { @value.abort_transaction }
+      assert_equal(false, @value.transaction_open?)
+      assert_equal(VALUE, @value)
+    end
+
+    def test_commit
+      assert_equal(false, @value.transaction_open?)
+      assert_raises(Transaction::TransactionError) { @value.commit_transaction }
+      assert_nothing_raised { @value.start_transaction }
+      assert_equal(true, @value.transaction_open?)
+      assert_nothing_raised { @value.gsub!(/men/, 'women') }
+      assert_not_equal(VALUE, @value)
+      assert_equal(true, @value.transaction_open?)
+      assert_nothing_raised { @value.commit_transaction }
+      assert_equal(false, @value.transaction_open?)
+      assert_not_equal(VALUE, @value)
+    end
+
+    def test_multilevel
+      assert_equal(false, @value.transaction_open?)
+      assert_nothing_raised { @value.start_transaction }
+      assert_equal(true, @value.transaction_open?)
+      assert_nothing_raised { @value.gsub!(/men/, 'women') }
+      assert_equal(VALUE.gsub(/men/, 'women'), @value)
+      assert_equal(true, @value.transaction_open?)
+      assert_nothing_raised { @value.start_transaction }
+      assert_nothing_raised { @value.gsub!(/country/, 'nation-state') }
+      assert_nothing_raised { @value.commit_transaction }
+      assert_equal(VALUE.gsub(/men/, 'women').gsub(/country/, 'nation-state'), @value)
+      assert_equal(true, @value.transaction_open?)
+      assert_nothing_raised { @value.abort_transaction }
+      assert_equal(VALUE, @value)
+    end
+
+    def test_multilevel_named
+      assert_equal(false, @value.transaction_open?)
+      assert_raises(Transaction::TransactionError) { @value.transaction_name }
+      assert_nothing_raised { @value.start_transaction(:first) } # 1
+      assert_raises(Transaction::TransactionError) { @value.start_transaction(:first) }
+      assert_equal(true, @value.transaction_open?)
+      assert_equal(true, @value.transaction_open?(:first))
+      assert_equal(:first, @value.transaction_name)
+      assert_nothing_raised { @value.start_transaction } # 2
+      assert_not_equal(:first, @value.transaction_name)
+      assert_equal(nil, @value.transaction_name)
+      assert_raises(Transaction::TransactionError) { @value.abort_transaction(:second) }
+      assert_nothing_raised { @value.abort_transaction(:first) }
+      assert_equal(false, @value.transaction_open?)
+      assert_nothing_raised do
+        @value.start_transaction(:first)
+        @value.gsub!(/men/, 'women')
+        @value.start_transaction(:second)
+        @value.gsub!(/women/, 'people')
+        @value.start_transaction
+        @value.gsub!(/people/, 'sentients')
+      end
+      assert_nothing_raised { @value.abort_transaction(:second) }
+      assert_equal(true, @value.transaction_open?(:first))
+      assert_equal(VALUE.gsub(/men/, 'women'), @value)
+      assert_nothing_raised do
+        @value.start_transaction(:second)
+        @value.gsub!(/women/, 'people')
+        @value.start_transaction
+        @value.gsub!(/people/, 'sentients')
+      end
+      assert_raises(Transaction::TransactionError) { @value.rewind_transaction(:foo) }
+      assert_nothing_raised { @value.rewind_transaction(:second) }
+      assert_equal(VALUE.gsub(/men/, 'women'), @value)
+      assert_nothing_raised do
+        @value.gsub!(/women/, 'people')
+        @value.start_transaction
+        @value.gsub!(/people/, 'sentients')
+      end
+      assert_raises(Transaction::TransactionError) { @value.commit_transaction(:foo) }
+      assert_nothing_raised { @value.commit_transaction(:first) }
+      assert_equal(VALUE.gsub(/men/, 'sentients'), @value)
+      assert_equal(false, @value.transaction_open?)
+    end
+
+    def test_block
+      Transaction::Simple.start(@value) do |tv|
+        assert_equal(true, tv.transaction_open?)
+        assert_nothing_raised { tv.gsub!(/men/, 'women') }
+        assert_equal(VALUE.gsub(/men/, 'women'), tv)
+        tv.abort_transaction
+        flunk("Failed to abort the transaction.")
+      end
+      assert_equal(false, @value.transaction_open?)
+      assert_equal(VALUE, @value)
+
+      @value = VALUE.dup
+      Transaction::Simple.start(@value) do |tv|
+        assert_equal(true, tv.transaction_open?)
+        assert_nothing_raised { tv.gsub!(/men/, 'women') }
+        assert_equal(VALUE.gsub(/men/, 'women'), tv)
+        tv.commit_transaction
+        flunk("Failed to commit the transaction.")
+      end
+      assert_equal(false, @value.transaction_open?)
+      assert_equal(VALUE.gsub(/men/, 'women'), @value)
+    end
+
+    def test_named_block
+      Transaction::Simple.start_named(:first, @value) do |tv|
+        assert_equal(true, tv.transaction_open?)
+        assert_equal(true, tv.transaction_open?(:first))
+        assert_nothing_raised { tv.gsub!(/men/, 'women') }
+        assert_equal(VALUE.gsub(/men/, 'women'), tv)
+        tv.abort_transaction
+        flunk("Failed to abort the transaction.")
+      end
+      assert_equal(false, @value.transaction_open?)
+      assert_equal(false, @value.transaction_open?(:first))
+      assert_equal(VALUE, @value)
+
+      @value = VALUE.dup
+      Transaction::Simple.start_named(:first, @value) do |tv|
+        assert_equal(true, tv.transaction_open?)
+        assert_equal(true, tv.transaction_open?(:first))
+        assert_nothing_raised { tv.gsub!(/men/, 'women') }
+        assert_equal(VALUE.gsub(/men/, 'women'), tv)
+        tv.commit_transaction
+        flunk("Failed to commit the transaction.")
+      end
+      assert_equal(false, @value.transaction_open?)
+      assert_equal(false, @value.transaction_open?(:first))
+      assert_equal(VALUE.gsub(/men/, 'women'), @value)
+    end
+
+    def test_named_block_error
+      @value.start_transaction(:first)
+      Transaction::Simple.start_named(:second, @value) do |tv|
+        assert_equal(true, tv.transaction_open?)
+        assert_equal(true, tv.transaction_open?(:first))
+        assert_equal(true, tv.transaction_open?(:second))
+        assert_nothing_raised { tv.gsub!(/men/, 'women') }
+        assert_equal(VALUE.gsub(/men/, 'women'), tv)
+        assert_raises(Transaction::TransactionError) do
+          tv.abort_transaction(:first)
+        end
+      end
+      assert_equal(true, @value.transaction_open?)
+      assert_equal(true, @value.transaction_open?(:first))
+      assert_equal(false, @value.transaction_open?(:second))
+      assert_equal(VALUE.gsub(/men/, 'women'), @value)
+      assert_nothing_raised { @value.abort_transaction(:first) }
+      assert_equal(VALUE, @value)
+
+      @value.start_transaction(:first)
+      Transaction::Simple.start_named(:second, @value) do |tv|
+        assert_equal(true, tv.transaction_open?)
+        assert_equal(true, tv.transaction_open?(:first))
+        assert_equal(true, tv.transaction_open?(:second))
+        assert_nothing_raised { tv.gsub!(/men/, 'women') }
+        assert_equal(VALUE.gsub(/men/, 'women'), tv)
+        assert_raises(Transaction::TransactionError) do
+          tv.commit_transaction(:first)
+        end
+      end
+      assert_equal(true, @value.transaction_open?)
+      assert_equal(true, @value.transaction_open?(:first))
+      assert_equal(false, @value.transaction_open?(:second))
+      assert_equal(VALUE.gsub(/men/, 'women'), @value)
+      assert_nothing_raised { @value.abort_transaction(:first) }
+      assert_equal(VALUE, @value)
+    end
+
+    def test_multivar_block
+      a = VALUE.dup
+      b = a.dup
+
+      Transaction::Simple.start(a, b) do |ta, tb|
+        assert_equal(true, ta.transaction_open?)
+        assert_equal(true, tb.transaction_open?)
+        ta.abort_transaction
+        flunk("Failed to abort the transaction.")
+      end
+      assert_equal(false, a.transaction_open?)
+      assert_equal(false, b.transaction_open?)
+
+      Transaction::Simple.start(a, b) do |ta, tb|
+        assert_equal(true, ta.transaction_open?)
+        assert_equal(true, tb.transaction_open?)
+        ta.commit_transaction
+        flunk("Failed to commit the transaction.")
+      end
+      assert_equal(false, a.transaction_open?)
+      assert_equal(false, b.transaction_open?)
+    end
+
+    def test_multilevel_block
+      Transaction::Simple.start_named(:outer, @value) do |tv0|
+        assert_equal(1, tv0.instance_variable_get(:@__transaction_level__))
+        assert_equal(true, tv0.transaction_open?(:outer))
+        Transaction::Simple.start_named(:inner, tv0) do |tv1|
+          assert_equal(2, tv0.instance_variable_get(:@__transaction_level__))
+          assert_equal(true, tv1.transaction_open?(:inner))
+          tv1.abort_transaction
+          flunk("Failed to abort the transaction.")
+        end
+        assert_equal(false, tv0.transaction_open?(:inner))
+        assert_equal(true, tv0.transaction_open?(:outer))
+
+        tv0.commit_transaction
+        flunk("Failed to commit the transaction.")
+      end
+      assert_equal(false, @value.transaction_open?(:inner))
+      assert_equal(false, @value.transaction_open?(:outer))
+    end
+
+    def test_array
+      assert_nothing_raised do
+        @orig = ["first", "second", "third"]
+        @value = ["first", "second", "third"]
+        @value.extend(Transaction::Simple)
+      end
+      assert_equal(@orig, @value)
+      assert_nothing_raised { @value.start_transaction }
+      assert_equal(true, @value.transaction_open?)
+      assert_nothing_raised { @value[1].gsub!(/second/, "fourth") }
+      assert_not_equal(@orig, @value)
+      assert_nothing_raised { @value.abort_transaction }
+      assert_equal(@orig, @value)
+    end
+
+    def test_instance_var
+      @value = VALUE.dup
+      @value.extend(Transaction::Simple)
+      @value.start_transaction
+      assert_equal(true, @value.transaction_open?)
+      @value.instance_variable_set("@foo", "bar")
+      @value.rewind_transaction
+      assert_equal(false, @value.instance_variables.include?("@foo"))
+    end
+  end
+end

data/test/test_transaction_simple_group.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+#--
+# Transaction::Simple
+# Simple object transaction support for Ruby
+# http://rubyforge.org/projects/trans-simple/
+#   Version 1.4.0
+#
+# Licensed under a MIT-style licence. See Licence.txt in the main
+# distribution for full licensing information.
+#
+# Copyright (c) 2003 - 2007 Austin Ziegler
+#
+# $Id: test_transaction_simple_group.rb 48 2007-02-03 16:00:11Z austin $
+#++
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0
+
+require 'transaction/simple/group'
+require 'test/unit'
+
+module Transaction::Simple::Test
+  class Group < Test::Unit::TestCase #:nodoc:
+    VALUE1  = "Hello, you."
+    VALUE2  = "And you, too."
+
+    def setup
+      @x = VALUE1.dup
+      @y = VALUE2.dup
+    end
+
+    def test_group
+      group = Transaction::Simple::Group.new(@x, @y)
+
+      assert_nothing_raised { group.start_transaction(:first) }
+      assert_equal(true, group.transaction_open?(:first))
+      assert_equal(true, @x.transaction_open?(:first))
+      assert_equal(true, @y.transaction_open?(:first))
+
+      assert_equal("Hello, world.", @x.gsub!(/you/, "world"))
+      assert_equal("And me, too.", @y.gsub!(/you/, "me"))
+
+      assert_nothing_raised { group.start_transaction(:second) }
+      assert_equal("Hello, HAL.", @x.gsub!(/world/, "HAL"))
+      assert_equal("And Dave, too.", @y.gsub!(/me/, "Dave"))
+
+      assert_nothing_raised { group.rewind_transaction(:second) }
+      assert_equal("Hello, world.", @x)
+      assert_equal("And me, too.", @y)
+
+      assert_equal("Hello, HAL.", @x.gsub!(/world/, "HAL"))
+      assert_equal("And Dave, too.", @y.gsub!(/me/, "Dave"))
+
+      assert_nothing_raised { group.commit_transaction(:second) }
+      assert_equal("Hello, HAL.", @x)
+      assert_equal("And Dave, too.", @y)
+
+      assert_nothing_raised { group.abort_transaction(:first) }
+      assert_equal("Hello, you.", @x)
+      assert_equal("And you, too.", @y)
+    end
+  end
+end