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

opensips-mi 0.0.5 → 0.0.10

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

@@ -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