ferocia-rubywmq 2.0.2 → 2.1.1

data/lib/wmq/version.rb

@@ -1,3 +1,3 @@
 module WMQ #:nodoc
-  VERSION = "2.0.2"
+  VERSION = '2.1.1'
 end

data/rubywmq.gemspec

@@ -0,0 +1,44 @@
+$:.push File.expand_path('../lib', __FILE__)
+
+# Maintain your gem's version:
+require 'wmq/version'
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  # Exclude locally compiled files since they are platform specific
+  excludes      = [
+    /lib.wmq.constants\.rb/,
+    /lib.wmq.constants_admin\.rb/,
+    /ext.wmq_structs\.c/,
+    /ext.wmq_reason\.c/,
+    /ext.Makefile/,
+    /ext.*\.o/,
+    /ext.wmq\.so/,
+    /\.gem$/,
+    /\.log$/,
+    /nbproject/
+  ]
+  s.name        = 'ferocia-rubywmq'
+  s.version     = WMQ::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Reid Morrison']
+  s.email       = ['reidmo@gmail.com']
+  s.homepage    = 'https://github.com/reidmorrison/rubywmq'
+  s.summary     = 'Native Ruby interface into WebSphere MQ'
+  s.description = 'RubyWMQ is a high performance native Ruby interface into WebSphere MQ.'
+  s.files       = Dir.glob("./**/*").reject {|p| excludes.any? {|e| p[e] } }.map {|f| f.sub(/^\.\//, '')} + ['.document']
+  s.test_files  = Dir['test/**/*']
+  s.license     = 'Apache-2.0'
+  s.extensions << 'ext/extconf.rb'
+  s.requirements << 'WebSphere MQ v5.3, v6 or v7 Client or Server with Development Kit'
+  s.required_ruby_version = '>= 1.9'
+
+
+  s.post_install_message = <<-MESSAGE
+* ferocia-rubywmq builds against the WMQ libs, which aren't available for OS X.
+* The gem will still install, but the build will be skipped, producing a
+* non-functional gem, so you'll need stubs. (You can skip the build elsewhere by
+* setting the DISABLE_RUBYWMQ environment variable.)
+  MESSAGE
+end
+

data/test/queue_manager_test.rb

@@ -0,0 +1,334 @@
+require_relative 'test_helper'
+
+# Unit Test for RocketJob::Job
+class WMQTest < Minitest::Test
+  context WMQ do
+    setup do
+      @queue_manager = WMQ::QueueManager.new(q_mgr_name: 'TEST') #, connection_name: 'localhost(1414)')
+      @queue_manager.connect
+
+      # Create Queue and clear any messages from the queue
+      @in_queue = WMQ::Queue.new(
+        queue_manager:  @queue_manager,
+        mode:           :input,
+        dynamic_q_name: 'UNIT.TEST.*',
+        q_name:         'SYSTEM.DEFAULT.MODEL.QUEUE',
+        fail_if_exists: false
+      )
+      @in_queue.open
+      @in_queue.each { |message|}
+
+      # Open same queue for Output. Queue should be created by now
+      @out_queue = WMQ::Queue.new(
+        queue_manager: @queue_manager,
+        mode:          :output,
+        q_name:        @in_queue.name
+      )
+      @out_queue.open
+    end
+
+    teardown do
+      @out_queue.close if @out_queue
+      @in_queue.close if @in_queue
+      @queue_manager.disconnect if @queue_manager
+    end
+
+    context 'exceptions' do
+      should 'raise exceptions' do
+        assert_raises(TypeError) do
+          WMQ::QueueManager.new(1)
+        end
+        WMQ::QueueManager.new(exception_on_error: nil)
+        assert_raises(TypeError) do
+          WMQ::QueueManager.new(exception_on_error: 1)
+        end
+        assert_raises(TypeError) do
+          WMQ::QueueManager.new(q_mgr_name: 2).connect
+        end
+        assert_raises(WMQ::WMQException) do
+          WMQ::QueueManager.new(q_mgr_name: 'bad').connect
+        end
+      end
+    end
+
+    context 'queue manager' do
+      should 'exist' do
+        assert_equal Object, WMQ::QueueManager.superclass
+        assert_equal WMQ::QueueManager, @queue_manager.class
+      end
+
+      should 'open_queue' do
+        @queue_manager.open_queue(
+          mode:   :output,
+          q_name: {
+            q_name:     @in_queue.name,
+            q_mgr_name: @queue_manager.name
+          }
+        ) do |test_queue|
+          assert_equal(true, test_queue.put(data: 'Hello World'))
+          message = WMQ::Message.new
+          assert_equal(true, @in_queue.get(message: message))
+          assert_equal('Hello World', message.data)
+        end
+      end
+
+      should 'execute' do
+        array = @queue_manager.inquire_q(
+          q_name:          @in_queue.name,
+          q_type:          WMQ::MQQT_LOCAL,
+          current_q_depth: nil
+        )
+        assert_equal 1, array.size
+        assert_equal @in_queue.name, array[0][:q_name]
+
+        assert_equal true, @queue_manager.inquire_process(process_name: '*').size > 0
+        assert_raises WMQ::WMQException do
+          @queue_manager.inquire_q(q_name: 'BADQUEUENAME*')
+        end
+        assert_equal 1, @queue_manager.ping_q_mgr.size
+      end
+
+      should 'mqsc' do
+        array = @queue_manager.mqsc("dis ql(#{@in_queue.name})")
+        assert_equal 1, array.size
+        assert_equal true, array[0].include?("QUEUE(#{@in_queue.name})")
+      end
+
+      should 'put1' do
+        data = 'Some Test Data'
+        assert_equal true, @queue_manager.put(q_name: @in_queue.name, data: data)
+
+        message = WMQ::Message.new
+        assert_equal true, @in_queue.get(message: message)
+        assert_equal data, message.data
+      end
+
+    end
+
+    context 'Queue' do
+      should 'send and receive message' do
+        assert_equal @out_queue.put(data: 'Hello World'), true
+        message = WMQ::Message.new
+        assert_equal @in_queue.get(message: message), true
+        assert_equal message.data, 'Hello World'
+      end
+
+      should 'group messages' do
+        # Clear out queue of any messages
+        @in_queue.each { |message|}
+
+        msg                        = WMQ::Message.new
+        msg.data                   = 'First'
+        msg.descriptor[:msg_flags] = WMQ::MQMF_MSG_IN_GROUP
+        assert_equal(@out_queue.put(message: msg, options: WMQ::MQPMO_LOGICAL_ORDER), true)
+
+        msg.data = 'Second'
+        assert_equal(@out_queue.put(message: msg, options: WMQ::MQPMO_LOGICAL_ORDER), true)
+
+        msg.data                   = 'Last'
+        msg.descriptor[:msg_flags] = WMQ::MQMF_LAST_MSG_IN_GROUP
+        assert_equal(@out_queue.put(message: msg, options: WMQ::MQPMO_LOGICAL_ORDER), true)
+      end
+    end
+
+    context 'Message' do
+      should 'dynamic_buffer' do
+        test_sizes = [0, 1, 100, 101, 102, 500, 65534, 65535, 65536, 65537, 1*1024*1024, 4*1024*1024]
+        test_sizes.each do |size|
+          str = '0123456789ABCDEF' * (size/16) + '0123456789ABCDEF'[0, size%16]
+          assert_equal str.length, size
+          assert_equal @out_queue.put(data: str), true
+        end
+
+        # First test the browse mechanism
+        counter = 0
+        @queue_manager.open_queue(mode: :browse, q_name: @in_queue.name) do |browse_queue|
+          browse_queue.each do |message|
+            size = test_sizes[counter]
+            assert_equal(size, message.data.length)
+            str = '0123456789ABCDEF' * (size/16) + '0123456789ABCDEF'[0, size%16]
+            assert_equal(str, message.data)
+            counter = counter + 1
+          end
+        end
+        assert_equal(test_sizes.size, counter)
+
+        # Now retrieve the messages destructively
+        message = WMQ::Message.new
+        test_sizes.each do |size|
+          assert_equal(true, @in_queue.get(message: message, match: WMQ::MQMO_NONE))
+          assert_equal(size, message.data.length)
+          str = '0123456789ABCDEF' * (size/16) + '0123456789ABCDEF'[0, size%16]
+          assert_equal(str, message.data)
+        end
+      end
+
+      should 'dead letter header' do
+        # TODO: Something has changed with DLH since MQ V6
+        skip
+        dlh = {
+          header_type:     :dead_letter_header,
+          reason:          WMQ::MQRC_UNKNOWN_REMOTE_Q_MGR,
+          dest_q_name:     'ORIGINAL_QUEUE_NAME',
+          dest_q_mgr_name: 'BAD_Q_MGR',
+          put_appl_name:   'TestApp.exe',
+        }
+
+        verify_header(dlh, WMQ::MQFMT_DEAD_LETTER_HEADER)
+      end
+
+      should 'cics' do
+        cics = {
+          header_type:     :cics,
+          reason:          WMQ::MQRC_UNKNOWN_REMOTE_Q_MGR,
+          facility:        'TOKEN123',
+          reply_to_format: WMQ::MQFMT_STRING
+        }
+        verify_header(cics, WMQ::MQFMT_NONE)
+      end
+
+      should 'ims' do
+        ims = {
+          header_type:     :ims,
+          l_term_override: 'LTERM',
+          reply_to_format: WMQ::MQFMT_STRING
+        }
+        verify_header(ims, WMQ::MQFMT_STRING)
+      end
+
+      should 'transmission_header' do
+        xqh = {
+          header_type:       :xmit_q_header,
+          remote_q_name:     'SOME_REMOTE_QUEUE',
+          remote_q_mgr_name: 'SOME_REMOTE_Q_MGR',
+          msg_type:          WMQ::MQMT_REQUEST,
+          msg_id:            'my message Id'
+        }
+        verify_header(xqh, WMQ::MQFMT_STRING)
+      end
+
+      should 'rf_header' do
+        rfh = {
+          header_type: :rf_header,
+          name_value:  {
+            ' name   s'  => '  v a "l" u e 1  ',
+            'n a m e 2 ' => 'v a l u e  2',
+            ''           => ['"', '""', '"""', '""""', ''],
+            'name3'      => ['"value3"', '', '"', ' value 43"']
+          }
+        }
+        verify_header(rfh, WMQ::MQFMT_STRING)
+      end
+
+      should 'rf_header_2' do
+        rfh2 = {
+          header_type: :rf_header_2,
+          xml:         [
+                         '<hello>to the world</hello>',
+                         '<another>xml like string</another>'
+                       ],
+        }
+        verify_header(rfh2, WMQ::MQFMT_STRING)
+      end
+
+      should 'multiple_headers' do
+        headers = [
+          {header_type: :rf_header_2,
+            xml:        [
+                          '<hello>to the world</hello>',
+                          '<another>xml like string</another>'],
+          },
+
+          {
+            header_type: :rf_header,
+            name_value:  {
+              ' name   s'  => '  v a l u e 1  ',
+              'n a m e 2 ' => 'v a l u e  2',
+              'name3'      => ['value3', '', 'value 43']
+            }
+          },
+
+          {
+            header_type:     :ims,
+            l_term_override: 'LTERM',
+            reply_to_format: WMQ::MQFMT_STRING
+          },
+
+          {
+            header_type: :rf_header,
+            name_value:  {
+              ' name   s'  => '  v a l u e 1  ',
+              'n a m e 2 ' => 'v a l u e  2',
+              'name3'      => ['value3', '', 'value 43']
+            }
+          },
+
+          {
+            header_type:     :cics,
+            reason:          WMQ::MQRC_UNKNOWN_REMOTE_Q_MGR,
+            facility:        'TOKEN123',
+            reply_to_format: WMQ::MQFMT_STRING
+          },
+
+          {
+            header_type: :rf_header_2,
+            xml:         ['<hello>to the world</hello>', '<another>xml like string</another>'],
+          },
+
+          {
+            header_type:       :xmit_q_header,
+            remote_q_name:     'SOME_REMOTE_QUEUE',
+            remote_q_mgr_name: 'SOME_REMOTE_Q_MGR',
+            msg_type:          WMQ::MQMT_REQUEST,
+            msg_id:            'my message Id'
+          },
+        ]
+        verify_multiple_headers(headers, WMQ::MQFMT_STRING)
+      end
+
+      should 'xmit_q_header' do
+        headers = [
+          {
+            header_type:       :xmit_q_header,
+            remote_q_name:     'SOME_REMOTE_QUEUE',
+            remote_q_mgr_name: 'SOME_REMOTE_Q_MGR',
+            msg_type:          WMQ::MQMT_REQUEST,
+            msg_id:            'my message Id'},
+
+          {
+            header_type:     :ims,
+            l_term_override: 'LTERM',
+            reply_to_format: WMQ::MQFMT_STRING
+          },
+        ]
+        verify_multiple_headers(headers, WMQ::MQFMT_STRING)
+      end
+    end
+  end
+
+  def verify_header(header, format)
+    verify_multiple_headers([header], format)
+  end
+
+  def verify_multiple_headers(headers, format)
+    data                        = 'Some Test Data'
+    message                     = WMQ::Message.new
+    message.data                = data
+    message.descriptor[:format] = format
+    message.headers             = headers
+    #assert_equal(true,@queue_manager.put(q_name: @in_queue.name, message: message))
+    assert_equal(true, @out_queue.put(message: message))
+
+    message = WMQ::Message.new
+    assert_equal true, @in_queue.get(message: message)
+    assert_equal data, message.data
+    assert_equal headers.size, message.headers.size
+    count = 0
+    headers.each do |header|
+      reply_header = message.headers[count]
+      header.each_pair { |key, value| assert_equal(value, reply_header[key]) }
+      count = count + 1
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'yaml'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'minitest/stub_any_instance'
+require 'shoulda/context'
+require 'wmq'
+require 'awesome_print'
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+# SemanticLogger.add_appender('test.log', &SemanticLogger::Appender::Base.colorized_formatter)
+# SemanticLogger.default_level = :debug

metadata

@@ -1,33 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ferocia-rubywmq
 version: !ruby/object:Gem::Version
-  version: 2.0.2
-  prerelease: 
+  version: 2.1.1
 platform: ruby
 authors:
 - Reid Morrison
-- Edwin Fine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-06 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: shoulda
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2020-09-08 00:00:00.000000000 Z
+dependencies: []
 description: RubyWMQ is a high performance native Ruby interface into WebSphere MQ.
 email:
 - reidmo@gmail.com
@@ -36,6 +18,9 @@ extensions:
 - ext/extconf.rb
 extra_rdoc_files: []
 files:
+- ".document"
+- Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -82,33 +67,37 @@ files:
 - lib/wmq/message.rb
 - lib/wmq/queue_manager.rb
 - lib/wmq/version.rb
-- tests/test.rb
-- .document
+- rubywmq.gemspec
+- test/queue_manager_test.rb
+- test/test_helper.rb
 homepage: https://github.com/reidmorrison/rubywmq
 licenses:
-- Apache License V2.0
-post_install_message: 
+- Apache-2.0
+metadata: {}
+post_install_message: |
+  * ferocia-rubywmq builds against the WMQ libs, which aren't available for OS X.
+  * The gem will still install, but the build will be skipped, producing a
+  * non-functional gem, so you'll need stubs. (You can skip the build elsewhere by
+  * setting the DISABLE_RUBYWMQ environment variable.)
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.4
+      version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
 - WebSphere MQ v5.3, v6 or v7 Client or Server with Development Kit
-rubyforge_project: rubywmq
-rubygems_version: 1.8.23
+rubygems_version: 3.1.4
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Native Ruby interface into WebSphere MQ
 test_files:
-- tests/test.rb
+- test/queue_manager_test.rb
+- test/test_helper.rb