xmlconv2 2.0.0

data/test/test_util/destination.rb

@@ -0,0 +1,197 @@
+#!/usr/bin/env ruby
+# TestDestination -- xmlconv2 -- 08.06.2004 -- hwyss@ywesee.com
+
+$: << File.dirname(__FILE__)
+$: << File.expand_path('..', File.dirname(__FILE__))
+$: << File.expand_path('../../src', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'util/destination'
+require 'mock'
+
+module XmlConv
+	module Util
+		class DestinationHttp < Destination
+			HTTP_CLASS = Mock.new('DestinationHttp::HTTP_CLASS')
+		end
+		class TestDestination < Test::Unit::TestCase
+			def setup
+				@destination = Destination.new
+			end
+			def test_attr_accessors
+				assert_respond_to(@destination, :path)
+				assert_respond_to(@destination, :path=)
+			end
+			def test_attr_readers
+				assert_respond_to(@destination, :uri)
+				assert_respond_to(@destination, :status)
+				assert_respond_to(@destination, :update_status)
+			end
+			def test_deliver
+				delivery = Mock.new('Delivery')
+				assert_raises(RuntimeError) { 
+					@destination.deliver(delivery)
+				}
+			end
+			def test_forget_credentials
+				assert_respond_to(@destination, :forget_credentials!)
+			end
+		end
+		class TestDestinationDir < Test::Unit::TestCase
+			def setup
+				@destination = DestinationDir.new
+				@target_dir = File.expand_path('data/destination', 
+					File.dirname(__FILE__))
+			end
+			def teardown
+				if(File.exist?(@target_dir))
+					FileUtils.rm_r(@target_dir)
+				end
+			end
+			def test_attr_readers
+				assert_respond_to(@destination, :filename)
+			end
+			def test_deliver
+				storage = Mock.new('Storage')
+				storage.__next(:transaction) { |block|
+					block.call
+				}
+				ODBA.storage = storage
+				cache = Mock.new('Cache')
+				ODBA.cache = cache
+				cache.__next(:store) { |obj|
+					assert_equal(@destination, obj)
+				}
+				delivery = Mock.new('Delivery')
+				delivery.__next(:filename) { 'test_file.dat' }
+				if(File.exist?(@target_dir))
+					FileUtils.rm_r(@target_dir)
+				end
+				@destination.path = @target_dir
+				@destination.deliver(delivery)
+				target_file = File.expand_path('test_file.dat', @target_dir)
+				assert(File.exist?(@target_dir), "Target Directory was not created")
+				assert(File.exist?(target_file), "Target File was not written")
+				assert_equal(delivery.to_s, File.read(target_file))
+				assert_equal('test_file.dat', @destination.filename)
+				assert_equal(:pending_pickup, @destination.status)
+				cache.__verify
+				delivery.__verify
+			ensure
+				ODBA.storage = nil
+				ODBA.cache = nil
+			end
+			def test_uri
+				@destination.path = '/foo/bar/baz'
+				assert_instance_of(URI::Generic, @destination.uri)
+				assert_equal("file:/foo/bar/baz", @destination.uri.to_s)
+				@destination.instance_variable_set('@filename', 'test_file.dat')
+				assert_equal("file:/foo/bar/baz/test_file.dat", @destination.uri.to_s)
+			end
+			def test_status
+				storage = Mock.new('Storage')
+				storage.__next(:transaction) { |block|
+					block.call
+				}
+				ODBA.storage = storage
+				cache = Mock.new('Cache')
+				ODBA.cache = cache
+				cache.__next(:store) { |obj|
+					assert_equal(@destination, obj)
+				}
+				assert_equal(:open, @destination.status)
+				@destination.update_status
+				assert_equal(:open, @destination.status)
+				@destination.instance_variable_set('@status', :pending_pickup)
+				@destination.instance_variable_set('@filename', 'no_such.file')
+				assert_equal(:pending_pickup, @destination.status)
+				@destination.update_status
+				assert_equal(:picked_up, @destination.status)
+				@destination.update_status
+				assert_equal(:picked_up, @destination.status)
+				cache.__verify
+			ensure
+				ODBA.storage = nil
+				ODBA.cache = nil
+			end
+			def test_status_comparable
+				assert_equal(0, @destination.status_comparable)
+				@destination.instance_variable_set('@status', :pending_pickup)
+				assert_equal(10, @destination.status_comparable)
+				@destination.instance_variable_set('@status', :picked_up)
+				assert_equal(20, @destination.status_comparable)
+			end
+		end
+		class TestDestinationHttp < Test::Unit::TestCase
+			class ToSMock < Mock
+				def to_s
+					true
+				end
+			end
+			def setup
+				@destination = DestinationHttp.new
+			end
+			def test_attr_accessors
+				assert_respond_to(@destination, :path)
+				assert_respond_to(@destination, :path=)
+				assert_respond_to(@destination, :uri)
+				assert_respond_to(@destination, :uri=)
+				assert_respond_to(@destination, :host)
+				assert_respond_to(@destination, :host=)
+			end
+			def test_path_writer
+				assert_equal('http:/', @destination.uri.to_s)
+				@destination.path = '/foo/bar'
+				assert_equal('http:/foo/bar', @destination.uri.to_s)
+			end
+			def test_host_writer
+				assert_equal('http:/', @destination.uri.to_s)
+				@destination.host = 'www.example.org'
+				assert_equal('http://www.example.org/', @destination.uri.to_s)
+			end
+			def test_uri_writer
+				uri = URI.parse('http://www.example.org/foo/bar')
+				assert_instance_of(URI::HTTP, @destination.uri)
+				assert_equal('http:/', @destination.uri.to_s)
+				@destination.uri = uri
+				assert_instance_of(URI::HTTP, @destination.uri)
+				assert_equal('http://www.example.org/foo/bar', @destination.uri.to_s)
+				@destination.uri = 'http://www.example.com/foo/bar'
+				assert_instance_of(URI::HTTP, @destination.uri)
+				assert_equal('http://www.example.com/foo/bar', @destination.uri.to_s)
+			end
+			def test_deliver
+				@destination.uri = 'http://testaccount:password@janico.ywesee.com:12345/test.rbx'
+				http_session = Mock.new('HttpSession')
+				delivery = ToSMock.new('Delivery')
+				response = Mock.new('Response')
+				response.__next(:message) { 'Status' }
+				delivery.__next(:to_s) { 'The Delivery' }
+				http_session.__next(:request) { |post_request, body| 
+					assert_instance_of(Net::HTTP::Post, post_request)
+					header = post_request.instance_variable_get('@header') 
+					assert_equal(['text/xml'], header['content-type'])
+					assert(header.include?('authorization'), "Authorization-Headers not sent")
+					assert_equal('The Delivery', body)
+					response
+				}
+				DestinationHttp::HTTP_CLASS.__next(:start) { |block, host, port| 
+					assert_equal('janico.ywesee.com', host)
+					assert_equal(12345, port)
+					block.call(http_session)
+				}
+				@destination.deliver(delivery)
+				assert_equal(:http_status, @destination.status)
+				# When the delivery is delivered, forget username and Password
+				uri = @destination.uri
+				assert_nil(uri.user)
+				assert_nil(uri.password)
+				assert_equal('http://janico.ywesee.com:12345/test.rbx', uri.to_s)
+				DestinationHttp::HTTP_CLASS.__verify
+				http_session.__verify
+				delivery.__verify
+				response.__verify
+			end
+		end
+	end
+end

data/test/test_util/invoicer.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# Util::TestInvoicer -- xmlconv2 -- 03.08.2006 -- hwyss@ywesee.com
+
+$: << File.dirname(__FILE__)
+$: << File.expand_path('../../src', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'util/invoicer'
+require 'flexmock'
+
+module XmlConv
+	module Util
+		class TestInvoicer < Test::Unit::TestCase
+      def setup
+        @invoicer = Invoicer.new
+      end
+      def test_group_by_partner
+        trans1 = FlexMock.new
+        trans1.mock_handle(:partner) { 'Group1' }
+        trans1.mock_handle(:model) { 'Model1' }
+        trans2 = FlexMock.new
+        trans2.mock_handle(:partner) { 'Group2' }
+        trans2.mock_handle(:model) { 'Model2' }
+        trans3 = FlexMock.new
+        trans3.mock_handle(:partner) { 'Group1' }
+        trans3.mock_handle(:model) { 'Model3' }
+        transactions = [trans1, trans2, trans3]
+        expected = {
+          'Group1'  => ['Model1', 'Model3'],
+          'Group2'  => ['Model2']
+        }
+        assert_equal(expected, @invoicer.group_by_partner(transactions))
+      end
+    end
+  end
+end

data/test/test_util/polling_manager.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+# Util::TestPollingManager -- xmlconv2 -- 29.06.2004 -- hwyss@ywesee.com
+
+$: << File.expand_path('..', File.dirname(__FILE__))
+$: << File.expand_path('../../src', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'util/polling_manager'
+require 'mock'
+
+module XmlConv
+	module Util
+		class PollingManager
+			CONFIG_PATH = File.expand_path('data/polling.yaml', 
+				File.dirname(__FILE__))
+		end
+		class TestPollingManager < Test::Unit::TestCase
+			def setup
+				@sys = Mock.new('System')
+				@polling = PollingManager.new(@sys)
+				@dir = File.expand_path('data/i2', 
+					File.dirname(__FILE__))
+				FileUtils.mkdir_p(@dir)
+				@file1 = File.expand_path('file1.txt', @dir)
+				File.open(@file1, 'w') { |fh| fh << "File 1\n" }
+			end
+			def teardown
+				FileUtils.rm_rf(@dir) 
+				@sys.__verify
+			end
+			def test_load_sources
+				File.open(PollingManager::CONFIG_PATH, 'w') { |fh|
+					fh << <<-EOS
+--- !ruby/object:XmlConv::Util::PollingMission
+reader: I2Bdd
+directory: "./test/test_util/data/i2"
+writer: BddXml
+destination: "http://example.com:12345"
+--- !ruby/object:XmlConv::Util::PollingMission
+directory: "./test/test_util/data/xml"
+destination: "http://user:pass@foo.bar.baz"
+writer: BddI2
+reader: XmlBdd
+				EOS
+				}
+				block = nil
+				block3 = Proc.new { |source| 
+					flunk "too many sources"
+				}
+				block2 = Proc.new { |source|
+					assert_instance_of(PollingMission, source)
+					assert_equal('XmlBdd', source.reader)
+					expected = File.expand_path('data/xml', File.dirname(__FILE__))
+					assert_equal(expected, source.directory)
+					assert_equal('BddI2', source.writer)
+					assert_equal('http://user:pass@foo.bar.baz', source.destination)
+					block = block3
+				}
+				block1 = Proc.new { |source|
+					assert_instance_of(PollingMission, source)
+					assert_equal('I2Bdd', source.reader)
+					expected = File.expand_path('data/i2', File.dirname(__FILE__))
+					assert_equal(expected, source.directory)
+					assert_equal('BddXml', source.writer)
+					assert_equal('http://example.com:12345', source.destination)
+					block = block2
+				}
+				block = block1
+				@polling.load_sources { |source|
+					block.call(source)
+				}
+			end
+			def test_file_paths
+				file2 = File.expand_path('file2.txt', @dir)
+				File.open(file2, 'w') { |fh| fh << "File 2\n" }
+				assert_equal([@file1, file2], @polling.file_paths(@dir).sort)
+			end
+			def test_poll
+				backup_dir = File.expand_path('../data', File.dirname(__FILE__))
+				source = Mock.new('Source')
+				source.__next(:directory) { @dir }
+				source.__next(:glob_pattern) { '*' }
+				source.__next(:reader) { 'Reader' }
+				source.__next(:writer) { 'Writer' }
+				source.__next(:destination) { 'http://foo.bar.baz:2345' }
+				source.__next(:debug_recipients) { }
+				source.__next(:error_recipients) { }
+				source.__next(:backup_dir) { backup_dir }
+				@sys.__next(:execute) { |transaction|
+					assert_instance_of(Util::Transaction, transaction)
+					assert_equal("File 1\n", transaction.input)
+					assert_equal('file:' << @file1, transaction.origin)
+					assert_equal('Reader', transaction.reader)
+					assert_equal('Writer', transaction.writer)
+					dest = transaction.destination
+					assert_instance_of(Util::DestinationHttp, dest)
+					assert_equal('http://foo.bar.baz:2345', dest.uri.to_s)
+				}
+				@polling.poll(source)
+				source.__verify
+			end
+			def test_destination
+				dest = @polling.destination('http://foo:bar@baz.com')
+				assert_instance_of(Util::DestinationHttp, dest)
+				assert_equal('baz.com', dest.host)
+				assert_instance_of(URI::HTTP, dest.uri)
+				assert_equal('http://foo:bar@baz.com', dest.uri.to_s)
+			end
+		end
+	end
+end

data/test/test_util/transaction.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+# Util::TestTransaction -- xmlconv2 -- 04.06.2004 -- hwyss@ywesee.com
+
+$: << File.dirname(__FILE__)
+$: << File.expand_path('../../src', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'util/transaction'
+require 'mock'
+
+module XmlConv
+	module Conversion
+		def const_get(symbol)
+			if(symbol.is_a?(Mock))
+				symbol
+			else
+				super
+			end
+		end
+		module_function :const_get
+	end
+	module Util
+		class Transaction
+			SMTP_HANDLER = Mock.new('SMTP-Handler')
+		end
+		class TestTransaction < Test::Unit::TestCase
+			def setup
+				@transaction = Util::Transaction.new
+			end
+			def test_attr_accessors
+				assert_respond_to(@transaction, :input)
+				assert_respond_to(@transaction, :input=)
+				assert_respond_to(@transaction, :reader)
+				assert_respond_to(@transaction, :reader=)
+				assert_respond_to(@transaction, :writer)
+				assert_respond_to(@transaction, :writer=)
+				assert_respond_to(@transaction, :transaction_id)
+				assert_respond_to(@transaction, :transaction_id=)
+				assert_respond_to(@transaction, :error)
+				assert_respond_to(@transaction, :error=)
+			end
+			def test_attr_readers
+				assert_respond_to(@transaction, :output)
+				assert_respond_to(@transaction, :model)
+				assert_respond_to(@transaction, :start_time)
+				assert_respond_to(@transaction, :commit_time)
+			end
+			def test_execute
+				src = Mock.new('source')
+				input = Mock.new('input')
+				reader = Mock.new('reader')
+				model = Mock.new('model')
+				writer = Mock.new('writer')
+				output = Mock.new('output')
+				destination = Mock.new('destination')
+				@transaction.input = src
+				@transaction.reader = reader
+				@transaction.writer = writer
+				@transaction.destination = destination
+				reader.__next(:parse) { |read_src|
+					assert_equal(src, read_src)
+					input	
+				}
+				reader.__next(:convert) { |read_input|
+					assert_equal(input, read_input)
+					model
+				}
+				writer.__next(:convert) { |write_input|
+					assert_equal(model, write_input)
+					output
+				}
+				destination.__next(:deliver) { |delivery|
+					assert_equal(output, delivery)
+				}
+				destination.__next(:forget_credentials!) { }
+				time1 = Time.now
+				result = @transaction.execute
+				time2 = Time.now
+				assert_equal(src, @transaction.input)
+				assert_equal(reader, @transaction.reader)
+				assert_equal(model, @transaction.model)
+				assert_equal(writer, @transaction.writer)
+				assert_equal(output.to_s, @transaction.output)
+				assert_equal(output.to_s, result)
+				assert_in_delta(time1, @transaction.start_time, 0.001)
+				assert_in_delta(time2, @transaction.commit_time, 0.001)
+				input.__verify
+				reader.__verify
+				model.__verify
+				writer.__verify
+				output.__verify
+				destination.__verify
+			end
+			def test_persistable
+				assert_kind_of(ODBA::Persistable, @transaction)
+			end
+			def test_dumpable
+				assert_nothing_raised { Marshal.dump(@transaction) }
+			end
+			def test_notify
+				@transaction.instance_variable_set('@start_time', Time.now)
+				@transaction.error_recipients = ['bar']
+				smtp = Transaction::SMTP_HANDLER
+				@transaction.notify
+				@transaction.debug_recipients = ['foo']
+				mail = Mock.new('MailSession')
+				mail.__next(:sendmail) { |encoded, from, recipients| 
+					assert_equal(['foo'], recipients)
+				
+				}
+				smtp.__next(:start) { |block, server|
+					block.call(mail)
+				}
+				@transaction.notify
+				@transaction.error = 'error!'
+				mail.__next(:sendmail) { |encoded, from, recipients| 
+					assert_equal(['foo', 'bar'], recipients)
+				
+				}
+				smtp.__next(:start) { |block, server|
+					block.call(mail)
+				}
+				@transaction.notify
+				smtp.__verify
+				mail.__verify
+			end
+		end
+	end
+end