p2ruby 0.1.0

data/spec/encoding_spec.rb

@@ -0,0 +1,15 @@
+# encoding: CP1251
+require 'rspec'
+
+describe 'RSpec' do
+  it 'correctly outputs Windows Cyrillics' do
+    pending 'RSpec does NOT output Windows Cyrillics, unless `chcp 1251` is run in console'
+    Encoding.default_internal, Encoding.default_external = ['cp1251'] * 2
+    lit = "������� �������������� ����� �������� ���� ������ ������ ������� �����"
+    puts "Source encoding: #{__ENCODING__}"
+    puts "Def ext/int encoding: #{Encoding.default_external}/#{Encoding.default_internal}"
+    puts "String literal: #{lit} - encoding: #{lit.encoding}"
+
+    lit.should == :miserable_failure
+  end
+end

data/spec/p2ruby/application_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe P2::Application, "singleton app object" do
+  after(:all) { P2::Application.reset CLIENT_INI }
+  subject { P2::Application.instance CLIENT_INI }
+
+  it 'wraps P2ClientGate.P2Application OLE class' do
+    subject.ole_type.name.should == 'IP2Application'
+    show_ole
+  end
+
+  its(:clsid) { should == '{08A95064-05C2-4EF4-8B5D-D6211C2C9880}' }
+  its(:progid) { should == 'P2ClientGate.P2Application.1' }
+  its(:opts) { should have_key :ini }
+  its(:ini) { should == CLIENT_INI }
+  its(:ole) { should be_a WIN32OLE }
+  its(:ParserType) { should == 2 } # �	1 � Plaza; �	2 � Plaza-II (default)
+
+  it 'is a Singleton' do
+    a1 = P2::Application.instance
+    a2 = P2::Application.instance
+    a1.object_id.should == a2.object_id
+  end
+
+  context '.reset' do
+
+    it 'resets Application singleton' do
+      a1 = P2::Application.instance
+      P2::Application.reset CLIENT_INI1
+      a2 = P2::Application.instance
+      a1.object_id.should_not == a2.object_id
+    end
+  end
+end

data/spec/p2ruby/connection_spec.rb

@@ -0,0 +1,293 @@
+# encoding: utf-8
+require 'spec_helper'
+
+def random_name
+  "APP-#{rand 10000}"
+end
+
+shared_examples_for 'new connection' do
+
+  its(:clsid) { should == '{CCD42082-33E0-49EA-AED3-9FE39978EB56}' }
+  its(:progid) { should == 'P2ClientGate.P2Connection.1' }
+  its(:opts) { should be_a Hash }
+  its(:ole) { should be_a WIN32OLE }
+  its(:Status) { should == P2::CS_CONNECTION_DISCONNECTED }
+  its(:status_text) { should == 'Connection Disconnected' }
+
+  it 'raises on NodeName access' do
+    expect { subject.NodeName }.to raise_error /Couldn't get MQ node name/
+#      its(:NodeName) { should == "??" }
+  end
+
+  it 'is possible to set settable properties' do
+    # Notes: �������� AppName, NodeName, Host, Port, Password � Timeout ������ ����
+    # ������ �� ������� ������ ������ Connect. � ������ ��������� ������ ������� ���
+    # ����, ����� ��������� �������� � ���� ���������� �������� ���������������� �����
+    # ������� Disconnect � Connect. ��������� �������������� ������� (LoginStr) ������
+    # ���� ������ �� ������� ������ ������ Login.
+    subject.AppName ='REASSIGNED'
+    subject.Host ='REASSIGNED_HOST'
+    subject.Port =1313
+    subject.LoginStr ='REASSIGNED_STRING'
+    subject.Timeout =13
+    subject.Password ='REASSIGNED_PASS'
+
+    subject.AppName.should == 'REASSIGNED'
+    subject.Name.should == 'REASSIGNED'
+    subject.name.should == 'REASSIGNED'
+    subject.Host.should == 'REASSIGNED_HOST'
+    subject.Port.should == 1313
+    subject.LoginStr.should =='REASSIGNED_STRING'
+    subject.Timeout.should == 13
+    #    subject.Password.should == 'REASSIGNED_PASS' # - No accessor for Password!
+  end
+
+  it 'is possible to set/access AppName property through aliases' do
+    subject.Name ='Set through Name'
+    subject.AppName.should == 'Set through Name'
+    subject.Name.should == 'Set through Name'
+    subject.name.should == 'Set through Name'
+
+    subject.name ='Now set through name'
+    subject.AppName.should == 'Now set through name'
+    subject.Name.should == 'Now set through name'
+    subject.name.should == 'Now set through name'
+  end
+
+  it 'is not connected right away' do
+    subject.should_not be_connected
+  end
+end
+
+describe P2::Connection do
+  before(:all) do
+    start_router
+    P2::Application.reset CLIENT_INI
+  end
+  after(:all) { stop_router }
+
+  describe '.new' do
+    context 'with options' do
+      subject { P2::Connection.new :ini => CLIENT_INI,
+                                   :app_name => random_name,
+                                   :host => "localhost",
+                                   :port => 3333,
+                                   :timeout => 500,
+                                   :login_str => "Blah" }
+
+      it 'wraps P2ClientGate.P2Connection OLE class' do
+        subject.ole_type.name.should == 'IP2Connection'
+        show_ole
+      end
+
+      its(:AppName) { should =~ /APP-./ }
+      its(:Host) { should == "localhost" }
+      its(:Port) { should == 3333 }
+      its(:Timeout) { should == 500 }
+      its(:LoginStr) { should == "Blah" }
+
+      # Alias properties
+      its(:Name) { should =~ /APP-./ }
+      its(:name) { should =~ /APP-./ }
+
+      it_behaves_like 'new connection'
+    end
+
+    context 'by default' do
+      # Ini file is still necessary if Application instance does not exist yet. Otherwise
+      # Connection#new will SEGFAULT looking for default "P2ClientGate.ini" in current dir
+      subject { P2::Connection.new }
+
+      its(:AppName) { should == '' }
+      its(:Host) { should == '' }
+      its(:Port) { should == 3000 }
+      its(:Timeout) { should == 1000 }
+      its(:LoginStr) { should == '' }
+      it_behaves_like 'new connection'
+    end
+  end
+
+  describe '#Connect()', 'creates local connection to Router' do
+    context 'with correct connection parameters' do
+      it 'connects successfully' do
+        @conn = P2::Connection.new :app_name => random_name,
+                                   :host => "127.0.0.1", :port => 4001
+        @conn.Connect().should == P2::P2ERR_OK
+        @conn.NodeName.should =~ Regexp.new(ROUTER_LOGIN)
+        @conn.should be_connected
+        @conn.status_text.should == "Connection Connected, Router Connected"
+      end
+    end
+
+    context 'with wrong connection parameters' do
+      it 'fails to connect' do
+        @conn = P2::Connection.new :app_name => random_name, :timeout => 200,
+                                   :host => "127.0.0.1", :port => 1313
+        expect { @conn.Connect() }.to raise_error /Couldn't connect to MQ/
+        @conn.should_not be_connected
+        @conn.status_text.should == "Connection Disconnected"
+      end
+    end
+  end
+
+  describe '#Disconnect()', 'drops local connection to Router' do
+    context 'when connected to Router' do
+      before do
+        @conn = P2::Connection.new :app_name => random_name,
+                                   :host => "127.0.0.1", :port => 4001
+        @conn.Connect()
+        @conn.should be_connected
+      end
+
+      it 'disconnects from Router successfully' do
+        @conn.Disconnect()
+        expect { @conn.NodeName }.to raise_error /Couldn't get MQ node name/
+        @conn.should_not be_connected
+        @conn.status_text.should == "Connection Disconnected"
+      end
+    end
+
+    context 'when NOT connected to Router' do
+      it 'it`s noop' do
+        @conn = P2::Connection.new :app_name => random_name,
+                                   :host => "127.0.0.1", :port => 1313
+        @conn.Disconnect()
+        @conn.should_not be_connected
+      end
+    end
+  end
+
+  describe '#Connect2 '
+  #  Connect2 ( [in] BSTR connStr, [out, retval] ULONG* errClass);
+  #  �������� ���������� ���������� ���������� � ��������. ���������� � ������ Connect.
+
+  describe '#ProcessMessage'
+  #  ProcessMessage ( [out] ULONG* cookie,  [in] ULONG pollTimeout);
+  #  ����� � ��������� ���������, � ��� ����� � ��������������.
+  #  ���������
+  #  �	pollTimeout � ������� � �������������, � ������� �������� ��������� ��������� ���������;
+  #  �	cookie � ���������� ������������� ����������.
+
+  describe '#ProcessMessage2'
+  #  ProcessMessage2 ( [in] ULONG pollTimeout, [out, retval] ULONG* cookie);
+  #  ����� � ��������� ���������. ������� � ���������� � ������ Connection.ProcessMessage,
+  #  ��� ��� ��� �� �������� � ������������������ ������ (JScript) �������� ���������
+  #  ������ ������� (cookie).
+
+  describe '#RegisterReceiver'
+  #  RegisterReceiver ( [in] IP2MessageReceiver* newReceiver, [out,retval] ULONG* cookie);
+  #  ����������� ����������.
+  #  ���������
+  #  �	newReceiver � ��������� �� ��������� ��������� ������;
+  #  �	cookie � ���������� ������������� ����������. ������������ ��� ����, ����� �����
+  #     ���� �������� ��������, � ����� ������ �� ���� � ������ Connection.ProcessMessage
+  #     ������������ ���������� ���������.
+
+  describe '#UnRegisterReceiver'
+  #  UnRegisterReceiver ([in] ULONG cookie);
+  #  ������ ����������� ����������.
+
+  describe '#ResolveService' do
+    #  ResolveService ( [in] BSTR service, [out,retval] BSTR* address);
+    #  ��������� ������� ������ ���������� �� ����� �������, ������� ��� �������������.
+    #  ���������
+    #  �	service � ��� �������;
+    #  �	address � ������ ����� ����������.
+
+    before(:all) do
+      @conn = P2::Connection.new :app_name => random_name,
+                                 :host => "127.0.0.1", :port => 4001
+      @conn.Connect()
+      @conn.should be_connected
+      @conn.should be_logged
+    end
+
+    it 'returns full server address, given a service name' do
+      @conn.ResolveService('FORTS_OPTINFO_REPL').should == "FINTER_FORTS3.inter_info"
+      @conn.ResolveService('FORTS_FUTINFO_REPL').should == "FINTER_FORTS3.inter_info"
+      @conn.ResolveService('FORTS_POS_REPL').should == "FINTER_FORTS3.inter_pos"
+      @conn.ResolveService('FORTS_FUTCOMMON_REPL').should== "FINTER_FORTS3.inter_futcommon"
+      @conn.ResolveService('FORTS_OPTCOMMON_REPL').should== "FINTER_FORTS3.inter_optcommon"
+      @conn.ResolveService('FORTS_VOLAT_REPL').should == "FINTER_FORTS3.inter_vmv"
+      @conn.ResolveService('FORTS_VM_REPL').should == "FINTER_FORTS3.inter_vmv"
+      # Order placement:
+      @conn.ResolveService("FORTS_SRV").should == "FINTER_FORTS3.Dispatcher"
+    end
+  end
+
+  #	�������������� ����������� ����������. �������� ������� �� ������ Login ��������,
+  # ��� ������������������ ���������� ���� ������� �� ������. ��� ����, ����� ������,
+  # ������� �� ����������� ��������������, ������� �������� � ������������ �����������
+  # � ��������� ����������.
+  context 'When router is authenticated via ini file' do
+  end
+  context 'When router is authenticated explicitely - via Login()' do
+  end
+
+  describe '#Logout(void)', 'drops Router connection to uplink (RTS)' do
+    context 'when Router is connected' do
+      before(:all) do
+        @conn = P2::Connection.new :app_name => random_name,
+                                   :host => "127.0.0.1", :port => 4001
+        @conn.Connect()
+        @conn.should be_connected
+        @conn.Logout()
+      end
+
+      it 'keeps local connection to Router' do
+        @conn.should be_connected
+      end
+
+      it 'only sends an ASYNC request to disconnect Router from uplink' do
+        @conn.should be_logged # Need to wait for Server to react to logout
+      end
+    end
+  end #Logout()
+
+  describe '#events' do
+    before(:each) do
+      @conn = P2::Connection.new :app_name => random_name,
+                                 :host => "127.0.0.1", :port => 4001
+      @conn.Connect()
+      @events = @conn.events
+      @event_fired = false
+    end
+
+    it 'provides access to (IP2ConnectionEvent interface) events' do
+      @events.should be_kind_of WIN32OLE_EVENT
+    end
+
+    it 'allows setting callbacks for IP2ConnectionEvent interface events' do
+      @events.on_event do |event_name, ole, status|
+        @event_fired = true
+        p "EVENT: #{event_name}, #{ole}, #{status}"
+        event_name.should == "ConnectionStatusChanged"
+        ole.ole_type.name.should == "IP2Connection"
+        status.should be_kind_of Fixnum
+      end
+
+      @conn.ProcessMessage2(100) # Grabs messages/events from queue
+      @event_fired.should == true
+    end
+
+    it 'allows setting explicit handler for IP2ConnectionEvent events' do
+      class TestHandler
+        attr_accessor :event_fired
+
+        def onConnectionStatusChanged(ole, status)
+          puts "StatusTextChanged"
+          @event_fired = true
+          p "HANDLER EVENT (ConnectionStatusChanged): #{ole}, #{status}"
+          ole.ole_type.name.should == "IP2Connection"
+          status.is_a?(Fixnum).should == true # We are inside Handler class, no #be_kind_of
+        end
+      end
+
+      @events.handler = TestHandler.new
+      @conn.ProcessMessage2(100) # Grabs messages/events from queue
+
+      @events.handler.should be_a TestHandler
+      @events.handler.event_fired.should == true
+    end
+  end #events
+end

data/spec/p2ruby/data_stream_spec.rb

@@ -0,0 +1,218 @@
+# encoding: utf-8
+require 'spec_helper'
+
+def baseless_opts
+  {:stream_name => 'RTS_INDEX_REPL',
+   :type => P2::RT_COMBINED_DYNAMIC}
+end
+
+describe P2::DataStream do
+  before(:all) do
+    start_router
+    P2::Application.reset CLIENT_INI
+    @conn = P2::Connection.new :app_name => 'DSTest',
+                               :host => "127.0.0.1", :port => 4001
+    @conn.Connect
+    @conn.should be_connected
+    @conn.should be_logged
+    # Disconnected connection, for comparison
+    @disconn = P2::Connection.new :app_name => 'DSTestDisconnected',
+                                  :host => "127.0.0.1", :port => 4001
+  end
+
+  after(:all) { stop_router }
+
+  context 'initializing Baseless' do
+    subject { P2::DataStream.new baseless_opts }
+    describe '.new' do
+      it 'wraps P2ClientGate.P2DataStream OLE class' do
+        subject.ole_type.name.should == 'IP2DataStream'
+        show_ole
+      end
+
+      its(:clsid) { should == '{914893CB-0864-4FBB-856A-92C3A1D970F8}' }
+      its(:progid) { should == 'P2ClientGate.P2DataStream.1' }
+      its(:opts) { should be_a Hash }
+      its(:ole) { should be_a WIN32OLE }
+      its(:StreamName) { should == 'RTS_INDEX_REPL' }
+      its(:Type) { should == P2::RT_COMBINED_DYNAMIC }
+      its(:State) { should == P2::DS_STATE_CLOSE }
+      its(:TableSet) { should == nil }
+      its(:DBConnString) { should == '' }
+      its(:state_text) { should == 'Data Stream Closed' }
+
+    end
+
+    it 'is possible to set settable properties' do
+      subject.Type = P2::RT_LOCAL
+      subject.DBConnString = 'Blah'
+      subject.StreamName = 'BLAH_REPL'
+
+      subject.Type.should == P2::RT_LOCAL
+      subject.DBConnString.should == 'Blah'
+      subject.StreamName.should == 'BLAH_REPL'
+    end
+
+    it 'is possible to set either wrapped or unwrapped TableSet' do
+      subject.TableSet = P2::TableSet.new :ini => TABLESET_INI, :life_num => 1313
+      subject.TableSet.LifeNum.should == 1313
+
+      subject.TableSet = (P2::TableSet.new :ini => TABLESET_INI, :life_num => 131313).ole
+      subject.TableSet.LifeNum.should == 131313
+    end
+
+    it 'is possible to set/access StreamName property through aliases' do
+      subject.Name ='Set through Name'
+      subject.StreamName.should == 'Set through Name'
+      subject.Name.should == 'Set through Name'
+      subject.name.should == 'Set through Name'
+
+      subject.name ='Now set through name'
+      subject.StreamName.should == 'Now set through name'
+      subject.Name.should == 'Now set through name'
+      subject.name.should == 'Now set through name'
+    end
+
+    it 'should not be open initially' do
+      subject.should_not be_open
+      subject.should_not be_opened
+    end
+  end
+
+  context 'when initialized Baseless' do
+    subject { P2::DataStream.new baseless_opts }
+    describe '#Open()' do
+      it 'opens replication data stream via connection' do
+        subject.Open(@conn)
+        subject.should be_open
+      end
+
+      it 'opens replication data stream via raw connection ole' do
+        subject.Open(@conn.ole)
+        subject.should be_open
+      end
+
+      it 'fails to open data stream via disconnected connection?!' do
+        @disconn.should_not be_connected
+        expect { subject.Open(@disconn) }.to raise_error /Couldn't open baseless repl datastream/
+        subject.should_not be_open
+      end
+
+      it 'fails to open data stream if arg is not a connection' do
+        expect { subject.Open(subject) }.to raise_error /Type mismatch/
+        expect { subject.Open(1313) }.to raise_error /not valid value/
+        subject.should_not be_open
+      end
+    end
+
+    describe '#Close()' do
+      it 'closes opened replication data stream' do
+        # --- before
+        subject.Open(@conn)
+        subject.should be_open
+
+        # --- example
+        subject.Close()
+        subject.should_not be_open
+      end
+
+      it 'does not raise errors closing unopened stream' do
+        # --- before
+        subject.should_not be_open
+
+        # --- example
+        subject.Close()
+        subject.should_not be_open
+      end
+    end
+
+    context 'testing stream state' do
+      describe 'unopened data stream' do
+
+        it 'is not open' do
+          subject.open?.should == false
+          subject.opened?.should == false
+        end
+
+        it 'is closed' do
+          subject.closed?.should == true
+        end
+
+        it 'is not error' do
+          subject.error?.should == false
+        end
+      end
+
+      describe 'opened data stream' do
+        before { subject.Open(@conn) }
+        it 'is open' do
+          subject.open?.should == true
+          subject.opened?.should == true
+        end
+
+        it 'is not closed' do
+          subject.closed?.should == false
+        end
+
+        it 'is not error' do
+          subject.error?.should == false
+        end
+      end
+
+      describe 'data stream in error' # how?
+    end
+  end # when initialized Baseless
+
+  describe '#events' do
+    before do
+      @ds = P2::DataStream.new baseless_opts
+      @events = @ds.events
+      @events_fired = 0
+    end
+
+    it 'provides access to (IP2ConnectionEvent interface) events' do
+      @events.should be_kind_of WIN32OLE_EVENT
+    end
+
+    it 'allows setting callbacks for IP2ConnectionEvent interface events' do
+      @events.on_event do |event_name, ole, state|
+        @events_fired += 1
+        p "EVENT: #{event_name}, #{ole}, #{state}"
+        event_name.should == "StreamStateChanged"
+        ole.ole_type.name.should == "IP2DataStream"
+        state.should be_kind_of Fixnum
+      end
+
+      @ds.Open(@conn)
+      @ds.Close()
+#      @conn.ProcessMessage2(100) # Grabs messages/events from queue
+      @events_fired.should == 2
+    end
+
+    it 'allows setting explicit handler for IP2ConnectionEvent events' do
+      class TestHandler
+        attr_accessor :events_fired
+
+        def onStreamStateChanged(ole, status)
+          @events_fired = (@events_fired || 0) + 1
+          p "HANDLER EVENT (StreamStateChanged): #{ole}, #{status}"
+          ole.ole_type.name.should == "IP2DataStream"
+          status.is_a?(Fixnum).should == true # We are inside Handler class, no #be_kind_of
+        end
+      end
+
+      @events.handler = TestHandler.new
+      @events.handler.should be_a TestHandler
+
+      @ds.Open(@conn)
+      @ds.Close()
+#      @conn.ProcessMessage2(100) # Grabs messages/events from queue
+      @events.handler.events_fired.should == 2
+    end
+  end #events
+
+  context 'when baseless data stream is open' do
+    subject { P2::DataStream.new(baseless_opts).tap { |ds| ds.Open @conn } }
+
+  end # when baseless data stream is open
+end

data/spec/p2ruby/library_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe P2::Library do
+
+  context 'at initialization' do
+    it 'works only with pre-registered STA P2ClientGate typelib' do
+      libs = WIN32OLE_TYPELIB.typelibs
+      p2libs = libs.select { |t| t.name=~/P2ClientGate/ }
+      print 'Registered P2ClientGate libs: '
+      p p2libs.map &:guid
+      p2sta = p2libs.find { |t| t.name !~ /MTA/ }
+      p2sta.should_not be_nil
+      print 'P2ClientGate (STA) OLE types: '
+      p2sta.ole_types.map { |k| p [k.name, k.progid, k.guid, k.implemented_ole_types] }
+    end
+
+    it 'wraps STA P2ClientGate typelib' do
+      lib = P2::Library.new
+      lib.name.should =~ /P2ClientGate/
+      lib.name.should_not =~ /MTA/
+    end
+  end # initialization
+
+  describe '.default' do
+    it 'points to (initialized) STA P2ClientGate OLE typelib singleton' do
+      P2::Library.default.should be_an_instance_of P2::Library
+    end
+  end
+
+  context 'when initialized' do
+    let(:lib) { P2::Library.default }
+
+    describe '#find' do
+      it 'returns progid needed to create OLE type with a given name' do
+        lib.find("P2Application").should == "P2ClientGate.P2Application.1"
+        lib.find("App").should == "P2ClientGate.P2Application.1"
+      end
+    end
+
+  end # when initialized
+end

data/spec/p2ruby/message_factory_spec.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe P2::MessageFactory do
+  before(:all) { P2::Application.reset CLIENT_INI }
+  subject { P2::MessageFactory.new :ini => MESSAGE_INI }
+
+  it 'wraps P2ClientGate.P2BLMessageFactory OLE class' do
+    subject.ole_type.name.should == 'IP2BLMessageFactory'
+    show_ole
+  end
+
+  its(:clsid) { should == '{501786DA-CA02-45C1-B815-1C58C383265D}' }
+  its(:progid) { should == 'P2ClientGate.P2BLMessageFactory.1' }
+  its(:opts) { should have_key :ini }
+  its(:ole) { should be_a WIN32OLE }
+
+  describe '#Init()', 'is implicitly called by #new'
+  # Init ( BSTR structFile, BSTR signFile); - ������������� �������.
+  # ���������
+  # �	structFile � ini-����, ���������� ����� ���������.
+  # �	signFile � �� ������������.
+
+  describe '#CreateMessageByName()', 'creates raw (unwrapped) OLE message objects' do
+    # CreateMessageByName ( [in] BSTR msgName, [out,retval] IP2BLMessage** newMsg);
+    # �������� ��������� �� �����.
+    # ���������
+    # �	msgName � ��� ��������� (��� ������� ��).
+    it 'creates raw OLE message objects according to scheme' do
+      msg = subject.CreateMessageByName("FutAddOrder")
+      msg.should be_a WIN32OLE # raw (unwrapped) OLE object!
+      msg.ole_type.name.should == 'IP2BLMessage'
+    end
+  end
+
+  describe '#message', 'creates P2::Message according to scheme' do
+    # This is a P2 object wrapper for CreateMessageByName
+
+    it 'creates P2::Message wrapper given message opts' do
+      msg = subject.message :name => "FutAddOrder", :dest_addr => 'Blah'
+      msg.should be_a P2::Message
+      msg.DestAddr.should == "Blah"
+      p msg.Id
+    end
+
+    it 'creates P2::Message wrapper given a name and opts' do
+      msg = subject.message "FutAddOrder", :dest_addr => 'Blah'
+      msg.should be_a P2::Message
+      msg.DestAddr.should == "Blah"
+    end
+
+    it 'creates P2::Message wrapper given a name WITHOUT opts' do
+      msg = subject.message "FutAddOrder"
+      msg.should be_a P2::Message
+    end
+
+    it 'fails to create P2::Message wrapper given wrong number of args' do
+      [[], ["One", "two", {}], ['one', 'two', 'three']].each do |args|
+        expect { msg = subject.message *args }.to raise_error ArgumentError
+      end
+    end
+
+    it 'fails to create P2::Message wrapper given wrong message name' do
+      expect { msg = subject.message 'Impossible' }.
+          to raise_error /Couldn't create BL message by name/
+    end
+  end
+end
+