ruby-bandwidth-iris 1.0.0

data/lib/bandwidth-iris/tn.rb

@@ -0,0 +1,41 @@
+module BandwidthIris
+  TN_PATH = 'tns'
+
+  class Tn
+    extend ClientWrapper
+    include ApiItem
+
+    def self.get(client, number)
+      data  = client.make_request(:get, "#{TN_PATH}/#{URI.escape(number)}")[0]
+      Tn.new(data, client)
+    end
+    wrap_client_arg :get
+
+
+    def self.list(client, query = nil)
+      list = client.make_request(:get, TN_PATH, query)[0][:telephone_numbers][:telephone_number]
+      return [] if !list
+      list = if list.is_a?(Array) then list else [list] end
+      list.map do |i|
+        Tn.new(i, client)
+      end
+    end
+    wrap_client_arg :list
+
+    def get_sites()
+      @client.make_request(:get, "#{TN_PATH}/#{URI.escape(telephone_number)}/sites")[0]
+    end
+
+    def get_sip_peers()
+      @client.make_request(:get, "#{TN_PATH}/#{URI.escape(telephone_number)}/sippeers")[0]
+    end
+
+    def get_rate_center()
+      @client.make_request(:get, "#{TN_PATH}/#{URI.escape(telephone_number)}/ratecenter")[0][:telephone_number_details]
+    end
+
+    def get_details()
+      @client.make_request(:get, "#{TN_PATH}/#{URI.escape(telephone_number)}/tndetails")[0][:telephone_number_details]
+    end
+  end
+end

data/lib/bandwidth-iris/tn_reservation.rb

@@ -0,0 +1,26 @@
+module BandwidthIris
+  TN_RESERVATION_PATH = 'tnreservation'
+
+  class TnReservation
+    extend ClientWrapper
+    include ApiItem
+
+
+    def self.get(client, id)
+      data  = client.make_request(:get, "#{client.concat_account_path(TN_RESERVATION_PATH)}/#{id}")[0][:reservation]
+      TnReservation.new(data, client)
+    end
+    wrap_client_arg :get
+
+    def self.create(client, item)
+      location = client.make_request(:post, client.concat_account_path(TN_RESERVATION_PATH), {:tn_reservation => item})[1][:location]
+      id = Client.get_id_from_location_header(location)
+      self.get(client, id)
+    end
+    wrap_client_arg :create
+
+    def delete()
+      @client.make_request(:delete,"#{@client.concat_account_path(TN_RESERVATION_PATH)}/#{id}")
+    end
+  end
+end

data/lib/bandwidth-iris/user.rb

@@ -0,0 +1,20 @@
+module BandwidthIris
+  USER_PATH = 'users'
+
+  class User
+    extend ClientWrapper
+    include ApiItem
+
+    def self.list(client)
+      list = client.make_request(:get, USER_PATH)[0][:users][:user]
+      return [] if !list
+      list = if list.is_a?(Array) then list else [list] end
+      list.map do |i|
+        User.new(i, client)
+      end
+    end
+    wrap_client_arg :list
+
+
+  end
+end

data/lib/bandwidth-iris/version.rb

@@ -0,0 +1,4 @@
+module BandwidthIris
+  # Version of this gem
+  VERSION = "1.0.0"
+end

data/lib/ruby-bandwidth-iris.rb

@@ -0,0 +1,29 @@
+require 'bandwidth-iris/api_item'
+require 'bandwidth-iris/errors'
+require 'bandwidth-iris/client'
+require 'bandwidth-iris/client_wrapper'
+
+require 'bandwidth-iris/account'
+require 'bandwidth-iris/available_number'
+require 'bandwidth-iris/available_npa_nxx'
+require 'bandwidth-iris/city'
+require 'bandwidth-iris/covered_rate_center'
+require 'bandwidth-iris/disconnect'
+require 'bandwidth-iris/dlda'
+require 'bandwidth-iris/import_to_account'
+require 'bandwidth-iris/in_service_number'
+require 'bandwidth-iris/lidb'
+require 'bandwidth-iris/lnp_checker'
+require 'bandwidth-iris/lsr_order'
+require 'bandwidth-iris/order'
+require 'bandwidth-iris/port_in'
+require 'bandwidth-iris/port_out'
+require 'bandwidth-iris/rate_center'
+require 'bandwidth-iris/sip_peer'
+require 'bandwidth-iris/site'
+require 'bandwidth-iris/subscription'
+require 'bandwidth-iris/tn'
+require 'bandwidth-iris/tn_reservation'
+require 'bandwidth-iris/user'
+
+require 'bandwidth-iris/version'

data/ruby-bandwidth-iris.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bandwidth-iris/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby-bandwidth-iris"
+  spec.version       = BandwidthIris::VERSION
+  spec.authors       = ["Andrey Belchikov"]
+  spec.description   = "Gem for integrating to Bandwidth's Iris API"
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/bandwidthcom/ruby-bandwidth-iris"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_dependency "builder"
+  spec.add_dependency "faraday"
+  spec.add_dependency "nori"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "certified"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "yard"
+end

data/spec/bandwidth-iris/account_spec.rb

@@ -0,0 +1,19 @@
+describe BandwidthIris::Account do
+  client = nil
+
+  before :each do
+    client = Helper.get_client()
+  end
+
+  after :each do
+    client.stubs.verify_stubbed_calls()
+  end
+
+  describe '#get' do
+    it 'should return an account' do
+      client.stubs.get('/v1.0/accounts/accountId') {|env| [200, {}, Helper.xml['account']]}
+      item = Account.get(client)
+      expect(item[:account_id]).to eql(14)
+    end
+  end
+end

data/spec/bandwidth-iris/available_npa_nxx_spec.rb

@@ -0,0 +1,22 @@
+describe BandwidthIris::AvailableNpaNxx do
+  client = nil
+
+  before :each do
+    client = Helper.get_client()
+  end
+
+  after :each do
+    client.stubs.verify_stubbed_calls()
+  end
+
+  describe '#list' do
+    it 'should return data' do
+      client.stubs.get('/v1.0/accounts/accountId/availableNpaNxx?areaCode=919') {|env| [200, {}, Helper.xml['available_npa_nxx']]}
+      expect(AvailableNpaNxx.list(client, {:area_code => 919})).to eql([
+        { :city => "City1", :state => "State1", :npa => "Npa1", :nxx => "Nxx1", :quantity => 10 },
+        { :city => "City2", :state => "State2", :npa => "Npa2", :nxx => "Nxx2", :quantity => 20 }
+      ])
+    end
+  end
+
+end

data/spec/bandwidth-iris/available_number_spec.rb

@@ -0,0 +1,19 @@
+describe BandwidthIris::AvailableNumber do
+  client = nil
+
+  before :each do
+    client = Helper.get_client()
+  end
+
+  after :each do
+    client.stubs.verify_stubbed_calls()
+  end
+
+  describe '#list' do
+    it 'should return numbers' do
+      client.stubs.get('/v1.0/accounts/accountId/availableNumbers?areaCode=866&quantity=5') {|env| [200, {}, Helper.xml['available_numbers']]}
+      expect(AvailableNumber.list(client, {:area_code => 866, :quantity => 5}).length).to eql(2)
+    end
+  end
+
+end

data/spec/bandwidth-iris/city_spec.rb

@@ -0,0 +1,22 @@
+describe BandwidthIris::City do
+  client = nil
+
+  before :each do
+    client = Helper.get_client()
+  end
+
+  after :each do
+    client.stubs.verify_stubbed_calls()
+  end
+
+  describe '#list' do
+    it 'should return cities' do
+      client.stubs.get('/v1.0/cities?state=NC') {|env| [200, {}, Helper.xml['cities']]}
+      expect(City.list(client, {:state => 'NC'})).to eql([
+        { :rc_abbreviation => "SOUTHEPINS", :name => "ABERDEEN" },
+        { :rc_abbreviation => "JULIAN", :name => "ADVANCE" }
+      ])
+    end
+  end
+
+end

data/spec/bandwidth-iris/client_spec.rb

@@ -0,0 +1,125 @@
+describe BandwidthIris::Client do
+  describe '#initialize' do
+    it 'should create instance of Client' do
+      expect(Client.new()).to be_a(Client)
+      expect(Client.new('accountId', 'user', 'password')).to be_a(Client)
+      expect(Client.new('accountId', 'user', 'password', {})).to be_a(Client)
+      expect(Client.new({:account_id => 'accountId', :username => 'user', :password => 'password'})).to be_a(Client)
+    end
+  end
+
+  describe '#global_options' do
+    it 'should return and change @@global_options of Client' do
+      Client.global_options = {:account_id => 'accountId', :username => 'username', :password => 'password'}
+      expect(Client.global_options).to eql({:account_id => 'accountId', :username => 'username', :password => 'password'})
+    end
+  end
+
+  describe '#get_id_from_location_header' do
+    it 'should return last url path item as id' do
+      expect(Client.get_id_from_location_header('http://localhost/path1/path2/id')).to eql('id')
+    end
+    it 'should raise error if location is missing or nil' do
+      expect{Client.get_id_from_location_header('')}.to raise_error
+      expect{Client.get_id_from_location_header(nil)}.to raise_error
+    end
+  end
+
+  describe '#concat_account_path' do
+    client = nil
+    before :each do
+      client = Helper.get_client()
+    end
+
+    it 'should add user id to path' do
+      expect(client.concat_account_path('test')).to eql('/accounts/accountId/test')
+      expect(client.concat_account_path('/test1')).to eql('/accounts/accountId/test1')
+    end
+  end
+
+  describe '#create_connection' do
+    client = nil
+    before :each do
+      client = Helper.get_client()
+    end
+
+    it 'should create new faraday connection' do
+      connection = client.create_connection()
+      expect(connection).to be_a(Faraday::Connection)
+      expect(connection.headers['Authorization']).to eql("Basic #{Base64.strict_encode64('username:password')}")
+    end
+  end
+
+  describe '#make_request' do
+    client = nil
+    before :each do
+      client = Helper.get_client()
+    end
+
+    after :each do
+      client.stubs.verify_stubbed_calls()
+    end
+
+    it 'should make GET request and return xml  data' do
+      client.stubs.get('/v1.0/path1') { |env| [200, {}, '<Result><Test>data</Test></Result>'] }
+      client.stubs.get('/v1.0/path2?testField=10') { |env| [200, {'Location'=>'url'}, '<Root><TestValue>10</TestValue><DataArray>1</DataArray><DataArray>2</DataArray><BoolValue>true</BoolValue><BoolValue2>false</BoolValue2><DateTimeValue>2015-05-29T01:02:03Z</DateTimeValue></Root>'] }
+      expect(client.make_request(:get, '/path1')).to eql([{:test => 'data'}, {}])
+      expect(client.make_request(:get, '/path2', {:test_field => 10})).to eql([{:test_value => 10, :data_array => [1, 2], :bool_value => true, :bool_value2 => false, :date_time_value => DateTime.new(2015,5,29,1,2,3)}, {:location=>'url'}])
+    end
+
+    it 'should make POST request and return xml data' do
+      client.stubs.post('/v1.0/path1', '<?xml version="1.0" encoding="UTF-8"?><Request><TestField1>test</TestField1><TestField2>10</TestField2><TestField3>false</TestField3><TestFieldd4>2015-05-29T01:02:03+00:00</TestFieldd4></Request>')  { |env|  [200, {}, '<Response><Success>true</Success></Response>'] }
+      expect(client.make_request(:post, '/path1', {:request => {:test_field1 => "test", :test_field2 => 10, :test_field3 => false, :test_fieldd4 => DateTime.new(2015, 5, 29, 1,2,3)}})[0]).to eql(:success => true)
+    end
+
+    it 'should make PUT request and return xml data' do
+      client.stubs.put('/v1.0/path1', '<?xml version="1.0" encoding="UTF-8"?><Request><TestField1>test</TestField1></Request>')  { |env|  [200, {}, '<Response><Success>true</Success></Response>'] }
+      expect(client.make_request(:put, '/path1', {:request => {:test_field1 => "test"}})[0]).to eql(:success => true)
+    end
+
+    it 'should make DELETE request and return xml  data' do
+      client.stubs.delete('/v1.0/path1') { |env| [200, {}, '<Result><Test>data</Test></Result>'] }
+      expect(client.make_request(:delete, '/path1')).to eql([{:test => 'data'}, {}])
+    end
+
+    it 'should raise error if http status >= 400' do
+      client.stubs.get('/v1.0/path1') { |env| [400, {}, ''] }
+      expect{client.make_request(:get, '/path1')}.to raise_error(Errors::GenericError, "Http code 400")
+    end
+
+    it 'should fail if output contains ErrorCode and Description' do
+      client.stubs.get('/v1.0/path1') { |env| [200, {}, '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Response><Test><ErrorCode>400</ErrorCode><Description>Error</Description></Test></Response>'] }
+      expect{client.make_request(:get, '/path1')}.to raise_error(Errors::GenericError, "Error")
+    end
+
+    it 'should fail if output contains element Error with Code and Description' do
+      client.stubs.get('/v1.0/path1') { |env| [200, {}, '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Response><Test><Error><Code>400</Code><Description>Error</Description></Error></Test></Response>'] }
+      expect{client.make_request(:get, '/path1')}.to raise_error(Errors::GenericError, "Error")
+    end
+
+    it 'should fail if output contains elements Errors with Code and Description' do
+      client.stubs.get('/v1.0/path1') { |env| [200, {}, '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Response><Test><Errors><Code>400</Code><Description>Error</Description></Errors><Errors><Code>401</Code><Description>Error1</Description></Errors></Test></Response>'] }
+      expect{client.make_request(:get, '/path1')}.to raise_error(Errors::AgregateError)
+    end
+
+    it 'should fail if output contains elements Errors with Code and Description (for 1 element)' do
+      client.stubs.get('/v1.0/path1') { |env| [200, {}, '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Response><Test><Errors><Code>400</Code><Description>Error</Description></Errors></Test></Response>'] }
+      expect{client.make_request(:get, '/path1')}.to raise_error(Errors::AgregateError)
+    end
+
+    it 'should fail if output contains elements resultCode and resultMessage' do
+      client.stubs.get('/v1.0/path1') { |env| [200, {}, '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Response><Test><resultCode>400</resultCode><resultMessage>Error</resultMessage></Test></Response>'] }
+      expect{client.make_request(:get, '/path1')}.to raise_error(Errors::GenericError, "Error")
+    end
+
+    it 'should fail if output contains elements resultCode and resultMessage (more deep)' do
+      client.stubs.get('/v1.0/path1') { |env| [200, {}, '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Response><Tests><Test></Test><Test><resultCode>400</resultCode><resultMessage>Error</resultMessage></Test></Tests></Response>'] }
+      expect{client.make_request(:get, '/path1')}.to raise_error(Errors::GenericError, "Error")
+    end
+
+    it 'should not fail if resultCode == 0' do
+      client.stubs.get('/v1.0/path1') { |env| [200, {}, '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Response><Test><resultCode>0</resultCode><resultMessage>Completed</resultMessage></Test></Response>'] }
+     client.make_request(:get, '/path1')
+    end
+  end
+end

data/spec/bandwidth-iris/covered_rate_center_spec.rb

@@ -0,0 +1,22 @@
+describe BandwidthIris::CoveredRateCenter do
+  client = nil
+
+  before :each do
+    client = Helper.get_client()
+  end
+
+  after :each do
+    client.stubs.verify_stubbed_calls()
+  end
+
+  describe '#list' do
+    it 'should return centers' do
+      client.stubs.get('/v1.0/coveredRateCenters') {|env| [200, {}, Helper.xml['covered_rate_centers']]}
+      list = CoveredRateCenter.list(client)
+      expect(list.length).to eql(1)
+      expect(list[0][:abbreviation]).to eql("ACME")
+      expect(list[0][:name]).to eql("ACME")
+    end
+  end
+
+end

data/spec/bandwidth-iris/disconnect_spec.rb

@@ -0,0 +1,52 @@
+describe BandwidthIris::Disconnect do
+  client = nil
+
+  before :each do
+    client = Helper.get_client()
+  end
+
+  after :each do
+    client.stubs.verify_stubbed_calls()
+  end
+
+  describe '#create' do
+    it 'should disconnect numbers' do
+      data = {
+        :disconnect_telephone_number_order => {
+          :name => 'test',
+          '_nameXmlElement' => 'name',
+          :disconnect_telephone_number_order_type => {
+            :telephone_number => ['111', '222']
+          }
+        }
+      }
+      client.stubs.post('/v1.0/accounts/accountId/disconnects', client.build_xml(data)) {|env| [200, {}, '']}
+      Disconnect.create(client, 'test', ['111', '222'])
+    end
+  end
+
+  describe '#get_notes' do
+    it 'should return notes' do
+      client.stubs.get('/v1.0/accounts/accountId/disconnects/1/notes') {|env| [200, {}, Helper.xml['notes']]}
+      order = Disconnect.new({:id => 1}, client)
+
+      list = order.get_notes()
+      expect(list[0][:id]).to eql(11299)
+      expect(list[0][:user_id]).to eql('customer')
+      expect(list[0][:description]).to eql('Test')
+    end
+  end
+
+  describe '#add_notes' do
+    it 'should add a note and return it' do
+      data = {:user_id => 'customer', :description => 'Test'}
+      client.stubs.post('/v1.0/accounts/accountId/disconnects/1/notes', client.build_xml({note: data})) {|env| [200, {:location => '/v1.0/accounts/FakeAccountId/disconnects/1/notes/11299'}, '']}
+      client.stubs.get('/v1.0/accounts/accountId/disconnects/1/notes') {|env| [200, {}, Helper.xml['notes']]}
+      order = Disconnect.new({:id => 1}, client)
+      item = order.add_notes(data)
+      expect(item[:id]).to eql(11299)
+      expect(item[:user_id]).to eql('customer')
+      expect(item[:description]).to eql('Test')
+    end
+  end
+end

data/spec/bandwidth-iris/dlda_spec.rb

@@ -0,0 +1,47 @@
+describe BandwidthIris::Dlda do
+  client = nil
+
+  before :each do
+    client = Helper.get_client()
+  end
+
+  after :each do
+    client.stubs.verify_stubbed_calls()
+  end
+
+  describe '#list' do
+    it 'should return orders' do
+      client.stubs.get('/v1.0/accounts/accountId/dldas') {|env| [200, {}, Helper.xml['dldas']]}
+      list = Dlda.list(client)
+      expect(list.length).to eql(3)
+    end
+  end
+
+  describe '#get' do
+    it 'should return an order' do
+      client.stubs.get('/v1.0/accounts/accountId/dldas/1') {|env| [200, {}, Helper.xml['dlda']]}
+      item = Dlda.get(client, 1)
+      expect(item[:id]).to eql('ea9e90c2-77a4-4f82-ac47-e1c5bb1311f4')
+    end
+  end
+
+  describe '#create' do
+    it 'should create a subscription' do
+      data = {}
+      client.stubs.post('/v1.0/accounts/accountId/dldas', client.build_xml({:dlda_order => data})) {|env| [201, {'Location' => '/v1.0/accounts/accountId/dldas/1'}, '']}
+      client.stubs.get('/v1.0/accounts/accountId/dldas/1') {|env| [200, {}, Helper.xml['dlda']]}
+      item = Dlda.create(client, data)
+      expect(item[:id]).to eql('ea9e90c2-77a4-4f82-ac47-e1c5bb1311f4')
+    end
+  end
+
+  describe '#get_history' do
+    it 'should return history' do
+      client.stubs.get('/v1.0/accounts/accountId/dldas/1/history') {|env| [200, {}, Helper.xml['order_history']]}
+      item = Dlda.new({:id => 1}, client)
+      list = item.get_history()
+      expect(list.length > 0).to eql(true)
+    end
+  end
+
+end

data/spec/bandwidth-iris/import_to_account_spec.rb

@@ -0,0 +1,36 @@
+describe BandwidthIris::ImportToAccount do
+  client = nil
+
+  before :each do
+    client = Helper.get_client()
+  end
+
+  after :each do
+    client.stubs.verify_stubbed_calls()
+  end
+
+  describe '#get_notes' do
+    it 'should return notes' do
+      client.stubs.get('/v1.0/accounts/accountId/importToAccounts/1/notes') {|env| [200, {}, Helper.xml['notes']]}
+      order = ImportToAccount.new({:id => 1}, client)
+
+      list = order.get_notes()
+      expect(list[0][:id]).to eql(11299)
+      expect(list[0][:user_id]).to eql('customer')
+      expect(list[0][:description]).to eql('Test')
+    end
+  end
+
+  describe '#add_notes' do
+    it 'should add a note and return it' do
+      data = {:user_id => 'customer', :description => 'Test'}
+      client.stubs.post('/v1.0/accounts/accountId/importToAccounts/1/notes', client.build_xml({note: data})) {|env| [200, {:location => '/v1.0/accounts/FakeAccountId/importToAccounts/1/notes/11299'}, '']}
+      client.stubs.get('/v1.0/accounts/accountId/importToAccounts/1/notes') {|env| [200, {}, Helper.xml['notes']]}
+      order = ImportToAccount.new({:id => 1}, client)
+      item = order.add_notes(data)
+      expect(item[:id]).to eql(11299)
+      expect(item[:user_id]).to eql('customer')
+      expect(item[:description]).to eql('Test')
+    end
+  end
+end

data/spec/bandwidth-iris/in_service_number_spec.rb

@@ -0,0 +1,33 @@
+describe BandwidthIris::InServiceNumber do
+  client = nil
+
+  before :each do
+    client = Helper.get_client()
+  end
+
+  after :each do
+    client.stubs.verify_stubbed_calls()
+  end
+
+  describe '#list' do
+    it 'should return numbers' do
+      client.stubs.get('/v1.0/accounts/accountId/inserviceNumbers') {|env| [200, {}, Helper.xml['in_service_numbers']]}
+      list = InServiceNumber.list(client)
+      expect(list.length).to eql(15)
+    end
+  end
+  describe '#get' do
+    it 'should return a number' do
+      client.stubs.get('/v1.0/accounts/accountId/inserviceNumbers/12345') {|env| [200, {}, '']}
+      InServiceNumber.get(client, '12345')
+    end
+  end
+  describe '#totals' do
+    it 'should return totals' do
+      client.stubs.get('/v1.0/accounts/accountId/inserviceNumbers/totals') {|env| [200, {}, Helper.xml['in_service_numbers_totals']]}
+      r = InServiceNumber.totals(client)
+      expect(r[:count]).to eql(3)
+    end
+  end
+
+end

data/spec/bandwidth-iris/lidb_spec.rb

@@ -0,0 +1,44 @@
+describe BandwidthIris::Lidb do
+  client = nil
+
+  before :each do
+    client = Helper.get_client()
+  end
+
+  after :each do
+    client.stubs.verify_stubbed_calls()
+  end
+
+  describe '#list' do
+    it 'should return orders' do
+      client.stubs.get('/v1.0/accounts/accountId/lidbs') {|env| [200, {}, Helper.xml['lidbs']]}
+      Lidb.list(client)
+    end
+  end
+
+  describe '#get' do
+    it 'should return an order' do
+      client.stubs.get('/v1.0/accounts/accountId/lidbs/1') {|env| [200, {}, Helper.xml['lidb']]}
+      Lidb.get(client, 1)
+    end
+  end
+
+  describe '#create' do
+    it 'should create a subscription' do
+      data = {
+        :customer_order_id =>"A Test order",
+        :lidb_tn_groups => {
+          :lidb_tn_group => {
+            :telephone_numbers => ["8048030097", "8045030098"],
+            :subscriber_information =>"Joes Grarage",
+            :use_type => "RESIDENTIAL",
+            :visibility => "PUBLIC"
+          }
+        }
+      }
+      client.stubs.post('/v1.0/accounts/accountId/lidbs', client.build_xml({:lidb_order => data})) {|env| [201, {'Location' => '/v1.0/accounts/accountId/lidbs/1'}, '']}
+      client.stubs.get('/v1.0/accounts/accountId/lidbs/1') {|env| [200, {}, Helper.xml['lidb']]}
+      Lidb.create(client, data)
+    end
+  end
+end

data/spec/bandwidth-iris/lnp_checker_spec.rb

@@ -0,0 +1,24 @@
+describe BandwidthIris::LnpChecker do
+  client = nil
+
+  before :each do
+    client = Helper.get_client()
+  end
+
+  after :each do
+    client.stubs.verify_stubbed_calls()
+  end
+
+  describe '#check' do
+    it 'should check numbers' do
+      numbers = ['1111', '2222']
+      data = {:number_portability_request => {:tn_list => {:tn => numbers}}}
+      client.stubs.post('/v1.0/accounts/accountId/lnpchecker?fullCheck=true', client.build_xml(data)) {|env| [200, {}, Helper.xml['lnp_check']]}
+      result = LnpChecker.check(client, numbers, true)
+      expect(result[:supported_rate_centers][:rate_center_group][:rate_center]).to eql("Center1")
+      expect(result[:supported_rate_centers][:rate_center_group][:city]).to eql("City1")
+      expect(result[:supported_rate_centers][:rate_center_group][:state]).to eql("State1")
+    end
+  end
+
+end