anjlab-ruby-smpp 0.6.0

data/test/optional_parameter_test.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'test/unit'
+require 'smpp'
+
+class OptionalParameterTest < Test::Unit::TestCase
+  include Smpp
+
+  def test_symbol_accessor
+    op = OptionalParameter.new(0x2150, "abcd")
+    assert_equal "abcd", op[:value]
+    assert_equal 0x2150, op[:tag]
+  end
+
+  def test_bad_data_does_not_puke
+    assert_raise RuntimeError do
+      OptionalParameter.from_wire_data("")
+    end
+  end
+
+  def test_from_wire_data
+    data = "\041\120\000\002\001\177"
+    op, remaining_data = OptionalParameter.from_wire_data(data)
+    assert_not_nil op, "op should not be nil"
+    assert_equal 0x2150, op.tag
+    assert_equal "\001\177", op.value
+    assert_equal "", remaining_data
+  end
+
+end
+

data/test/pdu_parsing_test.rb

@@ -0,0 +1,111 @@
+require 'rubygems'
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__) + "../../lib/smpp")
+
+class PduParsingTest < Test::Unit::TestCase
+
+  def test_recieve_single_message
+    raw_data = <<-EOF
+    0000 003d 0000 0005 0000 0000 0000 0002
+    0001 0134 3437 3830 3330 3239 3833 3700
+    0101 3434 3738 3033 3032 3938 3337 0000
+    0000 0000 0000 0000 0454 6573 74
+    EOF
+
+    pdu = create_pdu(raw_data)
+    assert_equal Smpp::Pdu::DeliverSm, pdu.class
+    assert_equal "447803029837", pdu.source_addr
+    assert_equal "447803029837", pdu.destination_addr
+    assert_nil pdu.udh
+    assert_equal "Test", pdu.short_message
+  end
+
+  def test_recieve_part_one_of_multi_part_message
+    part_one_message = <<-EOF
+    0000 00d8 0000 0005 0000 0000 0000 0001
+    0001 0134 3437 3937 3334 3238 3634 3400
+    0101 3434 3739 3736 3232 3430 3137 0000
+    0000 0000 0000 0000 9f05 0003 b402 0154
+    6869 7320 6973 2061 206c 6f6e 6720 6d65
+    7373 6167 6520 746f 2074 6573 7420 7768
+    6574 6865 7220 6f72 206e 6f74 2077 6520
+    6765 7420 7468 6520 6865 6164 6572 2069
+    6e66 6f20 7669 6120 7468 6520 534d 5343
+    2074 6861 7420 7765 2077 6f75 6c64 2072
+    6571 7569 7265 2074 6f20 6265 2061 626c
+    6520 746f 2072 6563 6f6d 706f 7365 206c
+    6f6e 6720 6d65 7373 6167 6573 2069 6e20
+    6861 7368 626c 7565
+    EOF
+
+    pdu = create_pdu(part_one_message)
+    assert_equal Smpp::Pdu::DeliverSm, pdu.class
+    assert_equal "447973428644", pdu.source_addr
+    assert_equal "447976224017", pdu.destination_addr
+    assert_equal [5, 0, 3, 180, 2, 1], pdu.udh
+
+    assert_equal 2, pdu.total_parts, "Have total parts of the message"
+    assert_equal 1, pdu.part, "Correctly show the part"
+    assert_equal 180, pdu.message_id
+
+    assert_equal "This is a long message to test whether or not we get the header info via the SMSC that we would require to be able to recompose long messages in hashblue", pdu.short_message
+  end
+
+  def test_recieve_part_two_of_multi_part_message
+    part_one_message = <<-EOF
+    0000 0062 0000 0005 0000 0000 0000 0002
+    0001 0134 3437 3937 3334 3238 3634 3400
+    0101 3434 3739 3736 3232 3430 3137 0000
+    0000 0000 0000 0000 2905 0003 b402 0220
+    616e 6420 7072 6f76 6964 6520 6120 676f
+    6f64 2075 7365 7220 6578 7065 7269 656e
+    6365
+    EOF
+
+    pdu = create_pdu(part_one_message)
+    assert_equal Smpp::Pdu::DeliverSm, pdu.class
+    assert_equal "447973428644", pdu.source_addr
+    assert_equal "447976224017", pdu.destination_addr
+    assert_equal [5, 0, 3, 180, 2, 2], pdu.udh
+
+    assert_equal 2, pdu.total_parts, "Have total parts of the message"
+    assert_equal 2, pdu.part, "Correctly show the part"
+    assert_equal 180, pdu.message_id
+
+    assert_equal " and provide a good user experience", pdu.short_message
+  end
+
+  def test_submit_sm_response_clean
+    data = <<-EOF
+    0000 0028 8000 0004 0000 0000 4da8 ebed
+    3534 3131 342d 3034 3135 562d 3231 3230
+    452d 3039 4831 5100                    
+    EOF
+
+    pdu = create_pdu(data)
+    assert_equal Smpp::Pdu::SubmitSmResponse, pdu.class
+    assert_equal "54114-0415V-2120E-09H1Q", pdu.message_id
+  end
+
+  def test_submit_sm_response_with_optional_params
+    data = <<-EOF
+    0000 0031 8000 0004 0000 042e 4da8 e9a1
+    0021 5300 0201 7721 6700 1653 6f75 7263
+    6520 6164 6472 6573 7320 6465 6e69 6564
+    2e
+    EOF
+
+    pdu = create_pdu(data)
+    assert_equal Smpp::Pdu::SubmitSmResponse, pdu.class
+    assert_equal "", pdu.message_id
+    assert pdu.optional_parameters
+    assert_equal "Source address denied.", pdu.optional_parameter(0x2167)
+  end
+
+  protected
+  def create_pdu(raw_data)
+    hex_data = [raw_data.chomp.gsub(/\s/,"")].pack("H*")
+    Smpp::Pdu::Base.create(hex_data)
+  end
+
+end

data/test/receiver_test.rb

@@ -0,0 +1,232 @@
+require 'rubygems'
+require 'test/unit'
+require 'smpp'
+
+class ReceiverTest < Test::Unit::TestCase
+
+  class RecordingDelegate
+    attr_reader :received_pdus, :received_delivery_report_pdus, :states
+    def initialize
+      @received_pdus, @received_delivery_report_pdus, @states = [], [], []
+    end
+    def mo_received(receiver, pdu)
+      @received_pdus << pdu
+    end
+    def delivery_report_received(receiver, pdu)
+      @received_delivery_report_pdus << pdu
+    end
+    def bound(receiver)
+      @states << :bound
+    end
+  end
+
+  class ExceptionRaisingDelegate < RecordingDelegate
+    def mo_received(receiver, pdu)
+      raise "exception in delegate"
+    end
+  end
+
+  def test_receiving_bind_receiver_response_with_ok_status_should_become_bound
+    receiver = build_receiver
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_ROK, 1)
+
+    receiver.process_pdu(bind_receiver_response)
+
+    assert receiver.bound?
+  end
+
+  def test_receiving_bind_receiver_response_with_ok_status_should_invoke_bound_on_delegate
+    delegate = RecordingDelegate.new
+    receiver = build_receiver(delegate)
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_ROK, 1)
+
+    receiver.process_pdu(bind_receiver_response)
+
+    assert_equal [:bound], delegate.states
+  end
+
+  def test_receiving_bind_receiver_response_with_ok_status_should_not_error_if_method_doesnt_exist_on_delegate
+    delegate = Object.new
+    receiver = build_receiver(delegate)
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_ROK, 1)
+
+    assert_nothing_raised { receiver.process_pdu(bind_receiver_response) }
+  end
+
+  def test_receiving_bind_receiver_response_with_error_status_should_not_become_bound
+    receiver = build_receiver
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_RBINDFAIL, 1)
+
+    receiver.process_pdu(bind_receiver_response)
+
+    assert receiver.unbound?
+  end
+
+  def test_receiving_bind_receiver_response_with_error_status_should_not_invoke_bound_on_delegate
+    delegate = RecordingDelegate.new
+    receiver = build_receiver(delegate)
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_RBINDFAIL, 1)
+
+    receiver.process_pdu(bind_receiver_response)
+
+    assert_equal [], delegate.states
+  end
+
+  def test_receiving_bind_receiver_response_with_error_status_should_close_connection
+    receiver = build_receiver
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_RBINDFAIL, 1)
+
+    receiver.process_pdu(bind_receiver_response)
+
+    assert_equal 1, receiver.close_connections
+  end
+
+  def test_receiving_deliver_sm_should_send_deliver_sm_response
+    delegate = RecordingDelegate.new
+    receiver = build_receiver(delegate)
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message")
+
+    receiver.process_pdu(deliver_sm)
+
+    first_sent_data = receiver.sent_data.first
+    assert_not_nil first_sent_data
+    actual_response = Smpp::Pdu::Base.create(first_sent_data)
+    expected_response = Smpp::Pdu::DeliverSmResponse.new(deliver_sm.sequence_number)
+    assert_equal expected_response.to_human, actual_response.to_human
+  end
+
+  def test_receiving_deliver_sm_should_send_error_response_if_delegate_raises_exception
+    delegate = ExceptionRaisingDelegate.new
+    receiver = build_receiver(delegate)
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message")
+
+    receiver.process_pdu(deliver_sm)
+
+    first_sent_data = receiver.sent_data.first
+    assert_not_nil first_sent_data
+    actual_response = Smpp::Pdu::Base.create(first_sent_data)
+    expected_response = Smpp::Pdu::DeliverSmResponse.new(deliver_sm.sequence_number, Smpp::Pdu::Base::ESME_RX_T_APPN)
+    assert_equal expected_response.to_human, actual_response.to_human
+  end
+
+  def test_receiving_deliver_sm_should_still_send_deliver_sm_response_when_no_delegate_is_provided
+    delegate = nil
+    receiver = build_receiver(delegate)
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message")
+
+    receiver.process_pdu(deliver_sm)
+
+    first_sent_data = receiver.sent_data.first
+    assert_not_nil first_sent_data
+    actual_response = Smpp::Pdu::Base.create(first_sent_data)
+    expected_response = Smpp::Pdu::DeliverSmResponse.new(deliver_sm.sequence_number)
+    assert_equal expected_response.to_human, actual_response.to_human
+  end
+
+  def test_receiving_deliver_sm_should_invoke_mo_received_on_delegate
+    delegate = RecordingDelegate.new
+    receiver = build_receiver(delegate)
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message")
+
+    receiver.process_pdu(deliver_sm)
+
+    first_received_pdu = delegate.received_pdus.first
+    assert_not_nil first_received_pdu
+    assert_equal deliver_sm.to_human, first_received_pdu.to_human
+  end
+
+  def test_receiving_deliver_sm_should_not_error_if_mo_received_method_doesnt_exist_on_delegate
+    delegate = Object.new
+    receiver = build_receiver(delegate)
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message")
+
+    assert_nothing_raised { receiver.process_pdu(deliver_sm) }
+  end
+
+  def test_receiving_deliver_sm_for_esm_class_4_should_invoke_delivery_report_received_on_delegate
+    delegate = RecordingDelegate.new
+    receiver = build_receiver(delegate)
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message", :esm_class => 4)
+
+    receiver.process_pdu(deliver_sm)
+
+    first_received_delivery_report_pdu = delegate.received_delivery_report_pdus.first
+    assert_not_nil first_received_delivery_report_pdu
+    assert_equal deliver_sm.to_human, first_received_delivery_report_pdu.to_human
+  end
+
+  def test_receiving_deliver_sm_should_not_error_if_received_delivery_report_method_doesnt_exist_on_delegate
+    delegate = Object.new
+    receiver = build_receiver(delegate)
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message", :esm_class => 4)
+
+    assert_nothing_raised { receiver.process_pdu(deliver_sm) }
+  end
+
+  private
+
+  def build_receiver(delegate = nil)
+    receiver = Smpp::Receiver.new(1, {}, delegate)
+    class << receiver
+      attr_reader :sent_data, :close_connections
+      def send_data(data)
+        @sent_data = (@sent_data || []) + [data]
+      end
+      def close_connection
+        @close_connections = (@close_connections || 0) + 1
+      end
+    end
+    receiver
+  end
+
+end
+
+require 'server'
+require 'delegate'
+
+class SmppTest < Test::Unit::TestCase
+  
+  def config
+    Server::config
+  end
+  
+  def test_transceiver_should_bind_and_unbind_then_stop
+    EventMachine.run {
+      EventMachine.start_server "localhost", 9000, Server::Unbind
+      EventMachine.connect "localhost", 9000, Smpp::Receiver, config, Delegate.new
+    }
+    # should not hang here: the server's response should have caused the client to terminate
+  end
+
+  def test_bind_receiver
+    pdu1 = Smpp::Pdu::BindReceiver.new(
+      config[:system_id],
+      config[:password],
+      config[:system_type],
+      config[:source_ton],
+      config[:source_npi],
+      config[:source_address_range]
+    )
+
+    pdu2 = Smpp::Pdu::Base.create(pdu1.data)
+
+    assert_instance_of(Smpp::Pdu::BindReceiver, pdu2)
+    assert_equal(pdu1.system_id, pdu2.system_id)
+    assert_equal(pdu1.password, pdu2.password)
+    assert_equal(pdu1.system_type, pdu2.system_type)
+    assert_equal(pdu1.addr_ton, pdu2.addr_ton)
+    assert_equal(pdu1.addr_npi, pdu2.addr_npi)
+    assert_equal(pdu1.address_range, pdu2.address_range)
+    assert_equal(pdu1.sequence_number, pdu2.sequence_number)
+    assert_equal(pdu1.command_status, pdu2.command_status)
+  end
+
+  def test_bind_receiver_response
+    pdu1 = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_ROK, config[:system_id])
+    pdu2 = Smpp::Pdu::Base.create(pdu1.data)
+    assert_instance_of(Smpp::Pdu::BindReceiverResponse, pdu2)
+    assert_equal(pdu1.system_id, pdu2.system_id)
+    assert_equal(pdu1.sequence_number, pdu2.sequence_number)
+    assert_equal(pdu1.command_status, pdu2.command_status)
+  end
+end

data/test/responsive_delegate.rb

@@ -0,0 +1,53 @@
+#TODO This should be made prettier with mocha
+class ResponsiveDelegate
+  attr_reader :seq, :event_counter
+
+  def initialize
+    @seq = 0
+    @event_counter = nil
+  end
+  def seq
+    @seq += 1
+  end
+  def count_function
+    func = caller(1)[0].split("`")[1].split("'")[0].to_sym
+    @event_counter = {} unless @event_counter.is_a?(Hash)
+    @event_counter[func] = 0 if @event_counter[func].nil?
+    @event_counter[func]+=1
+  end
+
+  def mo_received(transceiver, pdu)
+    count_function
+    puts "** mo_received"
+  end
+
+  def delivery_report_received(transceiver, pdu)
+    count_function
+    puts "** delivery_report_received"
+  end
+
+  def message_accepted(transceiver, mt_message_id, pdu)
+    count_function
+    puts "** message_sent"
+    #sending messages from delegate to escape making a fake message sender - not nice :(
+    $tx.send_mt(self.seq, 1, 2, "short_message @ message_accepted")
+  end
+
+  def message_rejected(transceiver, mt_message_id, pdu)
+    count_function
+    puts "** message_rejected"
+    $tx.send_mt(self.seq, 1, 2, "short_message @ message_rejected")
+  end
+
+  def bound(transceiver)
+    count_function
+    puts "** bound"
+    $tx.send_mt(self.seq, 1, 2, "short_message @ bound")
+  end
+
+  def unbound(transceiver)
+    count_function
+    puts "** unbound"
+    EventMachine::stop_event_loop
+  end
+end

data/test/server.rb

@@ -0,0 +1,56 @@
+# a server which immediately requests the client to unbind
+module Server
+  def self.config
+    {
+      :host => 'localhost',
+      :port => 2775,
+      :system_id => 'foo',
+      :password => 'bar',
+      :system_type => '',
+      :source_ton  => 0,
+      :source_npi => 1,
+      :destination_ton => 1,
+      :destination_npi => 1,
+      :source_address_range => '',
+      :destination_address_range => ''
+    }
+  end
+
+  module Unbind
+    def receive_data(data)
+      send_data Smpp::Pdu::Unbind.new.data
+    end
+  end
+
+  module SubmitSmResponse
+    def receive_data(data)
+      # problem: our Pdu's should have factory methods for "both ways"; ie. when created
+      # by client, and when created from wire data.
+      send_data Smpp::Pdu::SubmitSmResponse.new(1, 2, "100").data
+    end
+  end
+
+  module SubmitSmResponseWithErrorStatus
+    attr_reader :state #state=nil => bind => state=bound => send =>state=sent => unbind => state=unbound
+    def receive_data(data)
+      if @state.nil?
+        @state = 'bound'
+        pdu = Smpp::Pdu::Base.create(data)
+        response_pdu = Smpp::Pdu::BindTransceiverResponse.new(pdu.sequence_number,Smpp::Pdu::Base::ESME_ROK,Server::config[:system_id])
+        send_data response_pdu.data
+      elsif @state == 'bound'
+        @state = 'sent'
+        pdu = Smpp::Pdu::Base.create(data)
+        pdu.to_human
+        send_data Smpp::Pdu::SubmitSmResponse.new(pdu.sequence_number, Smpp::Pdu::Base::ESME_RINVDSTADR, pdu.body).data
+        #send_data Smpp::Pdu::SubmitSmResponse.new(1, 2, "100").data
+      elsif @state == 'sent'
+        @state = 'unbound'
+        send_data Smpp::Pdu::Unbind.new.data
+      else
+        raise "unexpected state"
+      end
+    end
+  end
+
+end