RubyGems - opensips-mi - Versions diffs - 0.0.5 → 0.0.10 - Mend

opensips-mi 0.0.5 → 0.0.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

checksums.yaml +6 -14
data/.gitignore +1 -0
data/.rspec +1 -0
data/.travis.yml +1 -1
data/Gemfile +4 -6
data/README.md +4 -1
data/Rakefile +3 -7
data/lib/opensips/mi/command.rb +4 -9
data/lib/opensips/mi/response.rb +65 -36
data/lib/opensips/mi/transport/datagram.rb +14 -2
data/lib/opensips/mi/transport/fifo.rb +4 -4
data/lib/opensips/mi/version.rb +1 -1
data/opensips-mi.gemspec +17 -15
data/spec/command_spec.rb +4 -0
data/{test → spec}/fixtures/dlg_list +0 -0
data/{test → spec}/fixtures/ul_dump +0 -0
data/spec/response_spec.rb +117 -0
data/spec/spec_helper.rb +112 -0
data/spec/transport_spec.rb +119 -0
metadata +54 -40
data/test/helper.rb +0 -89
data/test/test_command.rb +0 -118
data/test/test_response.rb +0 -124
data/test/test_transport.rb +0 -209

data/test/test_command.rb DELETED

@@ -1,118 +0,0 @@
-require 'helper'
-include Opensips::MI
-describe Command, "commands for transport classes" do
-  before do
-  end
-  after do
-  end
-  describe "missing methods" do
-    it "must raise if parameter is not Array" do
-      mi = init_class_fifo
-      mi.expects(:command).with('which').returns(mock(:rawdata => ['meth1', 'meth2']))
-      proc {
-        mi.unknown_command
-      }.must_raise NoMethodError
-    end
-    it "must send command" do
-      mi = init_class_fifo
-      mi.expects(:command).with('which').returns(Opensips::MI::Response.new(response_data_cmd_which))
-      mi.expects(:command).with('ul_sync',[]).returns(Opensips::MI::Response.new(["200 OK",""]))
-      mi.ul_sync.code.must_equal 200
-    end
-    it "must raise when missing basic mandatory headers" do
-      mi = init_class_fifo
-      ret = proc {
-        mi.uac_dlg  "NOTIFY",
-                    "sip:alice@wanderland.com",
-                    {"From" => "<sip:opensips@sipproxy.com>"}
-      }.must_raise ArgumentError
-      ret.message.must_match(/header To/)
-    end
-    it "must raise when missing body mandatory headers" do
-      mi = init_class_fifo
-      ret = proc {
-        mi.uac_dlg  "NOTIFY",
-                    "sip:alice@wanderland.com",
-                    {"From" => "<sip:opensips>", "To" => "<sip:bob>", "content-type" => "xml"},
-                    ?., ?., "<body>Hello</body>"
-      }.must_raise ArgumentError
-      ret.message.must_match(/header Content-length/)
-    end
-    it "must have good parameters" do
-      mi = init_class_fifo
-      mi.expects(:command).with('t_uac_dlg', [
-                                "NOTIFY",
-                                "sip:alice@wanderland.com",
-                                ".",
-                                ".",
-                                %Q/"From: <sip:opensips@sipproxy.com>\r\nTo: <sip:alice@wanderland.com>\r\n"/
-                               ])
-      mi.uac_dlg  "NOTIFY",
-                  "sip:alice@wanderland.com",
-                  {
-                    "From"  => "<sip:opensips@sipproxy.com>",
-                    "To"    => "<sip:alice@wanderland.com>"
-                  }
-    end
-    it "must raise when invalid event" do
-      mi = init_class_fifo
-      event = :unknown_event
-      res = proc {
-        mi.event_notify "sip:alice@proxy.com", event
-      }.must_raise ArgumentError
-      res.message.must_match(/#{event.to_s}/)
-    end
-    it "must send notify event" do
-      mi = init_class_fifo
-      tag = "123456"
-      uri = "sip:alice@wanderland.com"
-      SecureRandom.stubs(:hex).returns(tag)
-      mi.expects(:uac_dlg).with("NOTIFY",
-                                uri,
-                                {
-                                  "To"    => "<#{uri}>",
-                                  "From"  => "<#{uri}>;tag=#{tag}",
-                                  "Event" => "check-sync"
-                                }
-                               )
-      mi.event_notify uri, :polycom_check_cfg
-    end
-    it "must send MWI notify" do
-      mi = init_class_fifo
-      tag = "123456"
-      uri = "sip:alice@wanderland.com"
-      new_vm = 5
-      old_vm = 3
-      SecureRandom.stubs(:hex).returns(tag)
-      mi.expects(:uac_dlg).with("NOTIFY",
-                                uri,
-                                {
-                                  'To' => "<#{uri}>",
-                                  'From' => "<#{uri}>;tag=#{tag}",
-                                  'Event' => 'message-summary',
-                                  'Subscription-State' => 'active',
-                                  'Content-Type' => 'application/simple-message-summary',
-                                  'Content-Length' => 86,
-                                  'nl' => '',
-                                  'Messages-Waiting' => 'yes',
-                                  'Message-Account' => 'sip:*97@asterisk.com',
-                                  'Voice-Message' => "#{new_vm}/#{old_vm} (0/0)"
-                                })
-      mi.mwi_update uri, 'sip:*97@asterisk.com', new_vm, old_vm
-    end
-  end
-end

data/test/test_response.rb DELETED

@@ -1,124 +0,0 @@
-require 'helper'
-include Opensips::MI
-describe Response, "response class" do
-  before do
-    @which = response_data_cmd_which
-    @data_ok  = ["200 it is OK", "data", ""]
-    @data_nok = ["500 command 'unknown' not available"]
-  end
-  after do
-  end
-  describe "processing response" do
-    it "must raise if parameter is not Array" do
-      proc {
-        Response.new "String"
-      }.must_raise InvalidResponseData
-    end
-    it "must raise if response data id empty array" do
-      proc {
-        Response.new Array[]
-      }.must_raise EmptyResponseData
-    end
-    it "must return Response class" do
-      r = Response.new(@data_ok)
-      r.must_be_instance_of Response
-    end
-    it "must raise if invalid response data" do
-      proc {
-        Response.new(["invalid param","343",222])
-      }.must_raise InvalidResponseData
-    end
-    it "must parse successfull response" do
-      r = Response.new(@data_ok)
-      r.success.must_equal true
-      r.code.must_equal 200
-      r.message.must_equal "it is OK"
-    end
-    it "must parse unsuccessfull response" do
-      r = Response.new(@data_nok)
-      r.success.must_equal false
-      r.code.must_equal 500
-      r.message.must_equal "command 'unknown' not available"
-    end
-    it "parse ul dump response" do
-      res = Response.new(response_uldump)
-      ul = res.ul_dump
-      ul.result["7962"].wont_equal nil
-      ul.result["7962"]['Callid'].must_equal "5e7a1e47da91c41c"
-    end
-    it "process uptime response" do
-      res = Response.new [
-        "200 OK",
-        "Now:: Fri Apr 12 22:04:27 2013",
-        "Up since:: Thu Apr 11 21:43:01 2013",
-        "Up time:: 87686 [sec]",
-        ""
-      ]
-      response = res.uptime
-      response.result.uptime.must_equal 87686
-      response.result.since.thursday?.must_equal true
-      response.result.since.hour.must_equal 21
-      response.result.since.mon.must_equal 4
-    end
-    it "must fetch cache value" do
-      res = Response.new [
-        "200 OK",
-        "userdid = [18005552211]",
-        ""
-      ]
-      response = res.cache_fetch
-      response.result.userdid.must_equal "18005552211"
-    end
-    it "must return userloc contacts" do
-      response = Response.new response_contacts
-      res = response.ul_show_contact.result
-      res.must_be_instance_of Array
-      res.size.must_equal 2
-      res.first[:socket].must_equal "<udp:10.130.8.21:5060>"
-      res.last[:expires].must_equal "3593"
-    end
-    it "must process dialogs list" do
-      response = Response.new response_dlg_list
-      res = response.dlg_list.result
-      res.size.must_equal 1
-      res["3212:2099935485"][:callid].must_equal "1854719653"
-    end
-    it "must process dr_gw_status response in hash" do
-      response = Response.new response_dr_gw_status_list
-      drgws = response.dr_gw_status
-      drgws.result.size.must_equal 8
-      drgws.result["pstn4"][:ipaddr].must_equal "199.18.12.104"
-      drgws.result["pstn3"][:port].must_equal "5060"
-      drgws.result["gw1"][:enabled].must_equal false
-      drgws.result["gw4"][:enabled].must_equal true
-    end
-    it "must return raw data if dr_gw_status is run with arguments" do
-      response = Response.new response_dr_gw_status_single
-      drgws = response.dr_gw_status
-      drgws.enabled.must_equal true
-    end
-    it "result must be empty if command send to dr_gw_status" do
-      response = Response.new response_dr_gw_status_cmd
-      drgws = response.dr_gw_status
-      drgws.result.must_equal nil
-      drgws.success.must_equal true
-    end
-  end
-end

data/test/test_transport.rb DELETED

@@ -1,209 +0,0 @@
-require 'helper'
-describe Opensips::MI::Transport, "testing MI transport layers" do
-  before do
-    @fifo_params = {:fifo_name => '/tmp/opensips_fifo'}
-  end
-  after do
-  end
-  # Fifo
-  describe "test fifo transport layer" do
-    it "must retrun fifo class instance" do
-      File.stubs(:exists?).once.returns(true)
-      File.stubs(:pipe?).twice.returns(true)
-      Kernel.stubs(:system).returns(true)
-      Opensips::MI.connect(:fifo,@fifo_params).must_be_instance_of Opensips::MI::Transport::Fifo
-    end
-    it "must raise when using unknown transport method" do
-      proc {
-        Opensips::MI.connect(:unknown_transport_method,{})
-      }.must_raise NameError
-    end
-    it "must raise when no fifo_nameInstanceOf.new parameter passed" do
-      proc {
-        Opensips::MI.connect :fifo, {}
-      }.must_raise ArgumentError
-    end
-    it "must raise when fifo_name file not exists" do
-      File.stubs(:exists?).once.returns(false)
-      proc {
-        Opensips::MI.connect :fifo, :fifo_name => '/file/not/exists'
-      }.must_raise ArgumentError
-    end
-    it "must raise when fifo_name file is not pipe" do
-      File.stubs(:exists?).once.returns(true)
-      File.stubs(:pipe?).once.returns(false)
-      proc {
-        Opensips::MI.connect :fifo, :fifo_name => '/tmp/opensips_fifo'
-      }.must_raise ArgumentError
-    end
-    it "must raise if fifo reply directory not exists" do
-      Dir.stubs(:exists?).once.returns false
-      proc {
-        Opensips::MI.connect :fifo, :fifo_name => '/tmp/opensips_fifo',
-                                    :reply_dir => '/tmp'
-      }.must_raise ArgumentError
-    end
-    it "must set attributes for class instance" do
-      Dir.stubs(:exists?).once.returns(true)
-      File.stubs(:exists?).once.returns(true)
-      File.stubs(:pipe?).once.returns(true)
-      directory = '/tmp/opensips/fifo'
-      fifo_name = '/tmp/opensips_fifo'
-      replayfifo= 'fifo_reply_file_name'
-      fifo = Opensips::MI::Transport::Fifo.new  :fifo_name  => fifo_name,
-                                                :reply_dir  => directory,
-                                                :reply_fifo => replayfifo
-      fifo.reply_dir.must_equal directory
-      fifo.fifo_name.must_equal fifo_name
-      fifo.reply_dir.must_equal directory
-    end
-    it "must create temporary fifo reply file" do
-      fifo = init_class_fifo
-      Kernel.stubs(:system).returns(true)
-      File.stubs(:pipe?).returns(true)
-      fifo.open
-    end
-    it "must raise if can not create reply fifo" do
-      fifo = init_class_fifo
-      Kernel.stubs(:system).returns(true)
-      File.stubs(:pipe?).returns(false)
-      proc { fifo.open }.must_raise SystemCallError
-    end
-    it "must send command to fifo" do
-      File.stubs(:exists?).returns(true)
-      File.stubs(:pipe?).returns(true)
-      IO.stubs(:sysopen).returns(5)
-      io_obj = mock()
-      io_obj.expects(:close).twice()
-      io_obj.expects(:syswrite)
-      io_obj.expects(:gets).returns(nil)
-      IO.stubs(:open).twice().returns(io_obj)
-      Opensips::MI::Response.expects(:new).returns(true)
-      fifo = Opensips::MI.connect(:fifo,@fifo_params)
-      fifo.command('which')
-    end
-  end
-  # Datagram
-  describe "test datagram transport layer" do
-    it "must raise if empty host" do
-      proc {
-        Opensips::MI.connect :datagram, {}
-      }.must_raise ArgumentError
-    end
-    it "must raise if empty port" do
-      proc {
-        Opensips::MI.connect :datagram, {:host => "10.10.10.10"}
-      }.must_raise ArgumentError
-    end
-    it "must raise if invalid host" do
-      host = "256.0.0.300"
-      res = proc {
-        Opensips::MI.connect :datagram, {:host => host, :port => 8088}
-      }.must_raise SocketError
-      res.message.must_match(/#{host}/)
-    end
-    it "must raise if invalid port" do
-      proc {
-        Opensips::MI.connect :datagram, {:host => "10.0.0.1", :port => (2**16 + 1)}
-      }.must_raise SocketError
-      proc {
-        Opensips::MI.connect :datagram, {:host => "10.0.0.1", :port => 0}
-      }.must_raise SocketError
-    end
-    it "must connect to socket" do
-      UDPSocket.expects(:new).returns(mock(:connect => true))
-      res = Opensips::MI.connect :datagram,
-                                 :host => "192.168.122.128",
-                                 :port => 8809
-      res.respond_to?(:uac_dlg).must_equal true
-    end
-    it "must send valid command to socket" do
-      cmd = 'command'
-      params = ["aaa","bbb","ccc"]
-      sock = mock('UDPSocket')
-      sock.stubs(:connect)
-      sock.stubs(:send).with([":#{cmd}:", *params].join(?\n) + ?\n, 0)
-      sock.stubs(:recvfrom).returns( response_data_cmd_which )
-      UDPSocket.expects(:new).returns(sock)
-      res = Opensips::MI.connect :datagram,
-                                 :host => "192.168.122.128",
-                                 :port => 8809
-      res.command(cmd, params).code.must_equal 200
-    end
-  end
-  # XMLRPC
-  describe "test xmlrpc transport layer" do
-    it "must raise if empty host" do
-      proc {
-        Opensips::MI.connect :xmlrpc, {}
-      }.must_raise ArgumentError
-    end
-    it "must raise if empty port" do
-      proc {
-        Opensips::MI.connect :xmlrpc, {:host => "10.10.10.10"}
-      }.must_raise ArgumentError
-    end
-    it "must raise if invalid host" do
-      host = "256.0.0.300"
-      res = proc {
-        Opensips::MI.connect :xmlrpc, {:host => host, :port => 8088}
-      }.must_raise SocketError
-      res.message.must_match(/#{host}/)
-    end
-    it "must raise if invalid port" do
-      proc {
-        Opensips::MI.connect :xmlrpc, {:host => "10.0.0.1", :port => (2**16 + 1)}
-      }.must_raise SocketError
-      proc {
-        Opensips::MI.connect :xmlrpc, {:host => "10.0.0.1", :port => 0}
-      }.must_raise SocketError
-    end
-    it "must connect to xmlrpc server" do
-      host = "192.168.122.128"
-      port = 8080
-      rpc = mock('XMLRPC::Client')
-      rpc.stubs(:new_from_uri).
-        with("http://#{host}:#{port}/#{Opensips::MI::Transport::Xmlrpc::RPCSEG}",nil,3)
-      res = Opensips::MI.connect :xmlrpc,
-                                 :host => host,
-                                 :port => port
-      res.respond_to?(:uac_dlg).must_equal true
-      params = ["aaa","bbb"]
-      cmd    = "command"
-      rpc.stubs(:call).with(cmd, *params).returns( response_data_cmd_which )
-      res.command(cmd, params) #.must_be_instance_of Opensips::MI::Response
-    end
-  end
-end