smoke and unit tests for api

Author: ckoegel

spec/smoke/multi_channel_api_spec.rb

@@ -1,4 +1,4 @@
-# Unit tests for Bandwidth::MultiChannelApi
+# Integration tests for Bandwidth::MultiChannelApi
 describe 'MultiChannelApi' do
   before(:all) do
     Bandwidth.configure do |config|

spec/smoke/phone_number_lookup_api_spec.rb

@@ -1,91 +1,86 @@
-# Integration Tests for Bandwidth::PhoneNumberLookupApi
-describe 'PhoneNumberLookupApi Integration Tests' do
+# Integration tests for Bandwidth::PhoneNumberLookupApi
+describe 'PhoneNumberLookupApi' do
+  let(:phone_numbers) { [BW_NUMBER, USER_NUMBER] }
+
   before(:all) do
     Bandwidth.configure do |config|
       config.username = BW_USERNAME
       config.password = BW_PASSWORD
     end
-    @api_instance_tnlookup = Bandwidth::PhoneNumberLookupApi.new
-
-    # lookup info
-    $lookup_request_id = ''
+    @api_instance = Bandwidth::PhoneNumberLookupApi.new
+  end
+  describe 'test an instance of PhoneNumberLookupApi' do
+    it 'should create an instance of PhoneNumberLookupApi' do
+      expect(@api_instance).to be_instance_of(Bandwidth::PhoneNumberLookupApi)
+    end
   end
 
-  # Create Lookup
-  describe 'create_lookup' do
-    it 'creates a tn lookup request' do
-      tn_body = Bandwidth::LookupRequest.new(
-        tns: [BW_NUMBER]
+  # Create Asynchronous Bulk Number Lookup
+  describe 'create_get_async_bulk_lookup test' do
+    it 'should work' do
+      request = Bandwidth::AsyncLookupRequest.new(
+        phone_numbers: phone_numbers,
       )
-      data, status_code = @api_instance_tnlookup.create_lookup_with_http_info(BW_ACCOUNT_ID, tn_body)
 
-      expect(status_code).to eq(202)
-      expect(data).to be_instance_of(Bandwidth::CreateLookupResponse)
-      expect(data.request_id.length).to eq(36)
-      expect(data.status).to be_instance_of(String)
+      create_data, create_status_code = @api_instance.create_async_bulk_lookup_with_http_info(BW_ACCOUNT_ID, request)
 
-      $lookup_request_id  = data.request_id
-      sleep(1)
-    end
-  end
+      expect(create_status_code).to eq(202)
+      expect(create_data).to be_instance_of(Bandwidth::CreateAsyncBulkLookupResponse)
+      expect(create_data.links[0]).to be_instance_of(Bandwidth::LinkSchema)
+      expect(create_data.links[0].rel).to be_instance_of(String)
+      expect(create_data.links[0].href).to be_instance_of(String)
+      expect(create_data.links[0].method).to be_instance_of(String)
+      expect(create_data.data).to be_instance_of(Bandwidth::CreateAsyncBulkLookupResponseData)
+      expect(create_data.data.request_id).to be_instance_of(String)
+      expect(create_data.data.status).to be_one_of(Bandwidth::InProgressLookupStatusEnum.all_vars)
+      expect(create_data.errors).to be_instance_of(Array)
 
-  # Get Lookup Status
-  describe 'get_lookup_status' do
-    it 'gets lookup status' do
-      data, status_code = @api_instance_tnlookup.get_lookup_status_with_http_info(BW_ACCOUNT_ID, $lookup_request_id)
+      request_id = create_data.data.request_id
+      sleep(10)
 
-      expect(status_code).to eq(200)
-      expect(data).to be_instance_of(Bandwidth::LookupStatus)
-      expect(data.request_id).to eq($lookup_request_id)
-      expect(data.status).to be_instance_of(String)
-      expect(data.result).to be_instance_of(Array)
-      expect(data.result[0].response_code).to be_instance_of(Integer)
-      expect(data.result[0].e_164_format).to eq(BW_NUMBER)
+      get_data, get_status_code = @api_instance.get_async_bulk_lookup_with_http_info(BW_ACCOUNT_ID, request_id)
+      expect(get_status_code).to equal_to(200)
+      expect(get_data).to be_instance_of(Bandwidth::GetAsyncBulkLookupResponse)
+      expect(get_data.links[0]).to be_instance_of(Bandwidth::LinkSchema)
+      expect(get_data.links[0].rel).to be_instance_of(String)
+      expect(get_data.links[0].href).to be_instance_of(String)
+      expect(get_data.links[0].method).to be_instance_of(String)
+      expect(get_data.data.request_id).to eq(request_id)
+      expect(get_data.data.status).to eq(Bandwidth::InProgressLookupStatusEnum::COMPLETE)
+      expect(get_data.data.results).to be_instance_of(Array)
+      expect(get_data.data.results[0]).to be_instance_of(Bandwidth::LookupResult)
+      expect(get_data.data.results[0].phone_number).to be_instance_of(String)
+      expect(get_data.data.results[0].line_type).to be_one_of(Bandwidth::LineTypeEnum.all_vars)
+      expect(get_data.data.results[0].messaging_provider).to be_instance_of(String)
+      expect(get_data.data.results[0].voice_provider).to be_instance_of(String)
+      expect(get_data.data.results[0].country_code_a3).to be_instance_of(String)
     end
   end
 
-  # HTTP 4XX Errors
-  describe 'http error' do
-    it 'causes a 400 error' do
-      tn_body_bad = Bandwidth::LookupRequest.new(
-        tns: ['+1invalid']
+  # Create Synchronous Number Lookup
+  describe 'create_sync_lookup test' do
+    it 'should work' do
+      request = Bandwidth::SyncLookupRequest.new(
+        phone_numbers: phone_numbers,
       )
 
-      expect {
-        @api_instance_tnlookup.create_lookup_with_http_info(BW_ACCOUNT_ID, tn_body_bad)
-      }.to raise_error { |e|
-        expect(e).to be_instance_of(Bandwidth::ApiError)
-        expect(e.code).to eq(400)
-      }
-    end
-    
-    it 'causes a 404 error' do
-      req_id_dne = '12345678-abcd-cdef-9876-12345678abcd'
-
-      expect {
-        @api_instance_tnlookup.get_lookup_status_with_http_info(BW_ACCOUNT_ID, req_id_dne)
-      }.to raise_error { |e|
-        expect(e).to be_instance_of(Bandwidth::ApiError)
-        expect(e.code).to eq(404)
-      }
-    end
-
-    it 'causes a 401 error' do
-      Bandwidth.configure do |config|
-        config.username = UNAUTHORIZED_USERNAME
-        config.password = UNAUTHORIZED_PASSWORD
-      end
-
-      tn_body = Bandwidth::LookupRequest.new(
-        tns: [BW_NUMBER]
-      )
+      data, status_code = @api_instance.create_sync_lookup_with_http_info(BW_ACCOUNT_ID, request)
 
-      expect {
-        @api_instance_tnlookup.create_lookup_with_http_info(BW_ACCOUNT_ID, tn_body)
-      }.to raise_error { |e|
-        expect(e).to be_instance_of(Bandwidth::ApiError)
-        expect(e.code).to eq(401)
-      }
+      expect(status_code).to equal_to(200)
+      expect(data).to be_instance_of(Bandwidth::CreateSyncLookupResponse)
+      expect(data.links[0]).to be_instance_of(Bandwidth::LinkSchema)
+      expect(data.links[0].rel).to be_instance_of(String)
+      expect(data.links[0].href).to be_instance_of(String)
+      expect(data.links[0].method).to be_instance_of(String)
+      expect(data.data.request_id).to be_instance_of(String)
+      expect(data.data.status).to eq(Bandwidth::CompletedLookupStatusEnum::COMPLETE)
+      expect(data.data.results).to be_instance_of(Array)
+      expect(data.data.results[0]).to be_instance_of(Bandwidth::LookupResult)
+      expect(data.data.results[0].phone_number).to be_instance_of(String)
+      expect(data.data.results[0].line_type).to be_one_of(Bandwidth::LineTypeEnum.all_vars)
+      expect(data.data.results[0].messaging_provider).to be_instance_of(String)
+      expect(data.data.results[0].voice_provider).to be_instance_of(String)
+      expect(data.data.results[0].country_code_a3).to be_instance_of(String)
     end
   end
 end

spec/unit/api/phone_number_lookup_api_spec.rb

@@ -1,6 +1,7 @@
 # Unit tests for Bandwidth::PhoneNumberLookupApi
 describe 'PhoneNumberLookupApi' do
-  let(:request_id) { '21e6d818-eaa9-4ca9-b1d8-d6085f5c79d4' } 
+  let(:phone_numbers) { [BW_NUMBER, USER_NUMBER] }
+  let(:request_id) { '123e4567-e89b-12d3-a456-426614174000' }
 
   before(:all) do
     Bandwidth.configure do |config|
@@ -10,77 +11,91 @@
       config.ignore_operation_servers = true
       config.host = '127.0.0.1:4010'
     end
-    @phone_number_lookup_api_instance = Bandwidth::PhoneNumberLookupApi.new
+    @api_instance = Bandwidth::PhoneNumberLookupApi.new
   end
-
   describe 'test an instance of PhoneNumberLookupApi' do
     it 'should create an instance of PhoneNumberLookupApi' do
-      expect(@phone_number_lookup_api_instance).to be_instance_of(Bandwidth::PhoneNumberLookupApi)
+      expect(@api_instance).to be_instance_of(Bandwidth::PhoneNumberLookupApi)
     end
   end
 
-  # Create Lookup
-  describe 'create_lookup' do
-    it 'creates a tn lookup request' do
-      tn_body = Bandwidth::LookupRequest.new(
-        tns: [BW_NUMBER]
+  # Create Asynchronous Bulk Number Lookup
+  describe 'create_async_bulk_lookup test' do
+    it 'should work' do
+      request = Bandwidth::AsyncLookupRequest.new(
+        phone_numbers: phone_numbers,
       )
-      data, status_code = @phone_number_lookup_api_instance.create_lookup_with_http_info(BW_ACCOUNT_ID, tn_body)
 
-      expect(status_code).to eq(202)
-      expect(data).to be_instance_of(Bandwidth::CreateLookupResponse)
-      expect(data.request_id.length).to eq(36)
-      expect(data.status).to be_one_of(Bandwidth::LookupStatusEnum.all_vars)
-    end
-
-    it 'causes an ArgumentError for a missing account_id' do
-      expect {
-        @phone_number_lookup_api_instance.create_lookup(nil, {})
-      }.to raise_error(ArgumentError)
-    end
+      data, status_code = @api_instance.create_async_bulk_lookup_with_http_info(BW_ACCOUNT_ID, request)
 
-    it 'causes an ArgumentError for a missing lookup_request' do
-      expect {
-        @phone_number_lookup_api_instance.create_lookup(BW_ACCOUNT_ID, nil)
-      }.to raise_error(ArgumentError)
+      expect(status_code).to eq(202)
+      expect(data).to be_instance_of(Bandwidth::CreateAsyncBulkLookupResponse)
+      expect(data.links[0]).to be_instance_of(Bandwidth::LinkSchema)
+      expect(data.links[0].rel).to be_instance_of(String)
+      expect(data.links[0].href).to be_instance_of(String)
+      expect(data.links[0].method).to be_instance_of(String)
+      expect(data.data).to be_instance_of(Bandwidth::CreateAsyncBulkLookupResponseData)
+      expect(data.data.request_id).to be_instance_of(String)
+      expect(data.data.status).to eq(Bandwidth::InProgressLookupStatusEnum::IN_PROGRESS)
+      expect(data.errors).to be_instance_of(Array)
     end
   end
 
-  # Get Lookup Status
-  describe 'get_lookup_status' do
-    it 'gets lookup status' do
-      data, status_code = @phone_number_lookup_api_instance.get_lookup_status_with_http_info(
-        BW_ACCOUNT_ID, request_id, { header_params: { 'Prefer' => 'example=lookupMultipleNumbersPartialCompleteExample' } })
+  # Create Synchronous Number Lookup
+  describe 'create_sync_lookup test' do
+    it 'should work' do
+      request = Bandwidth::SyncLookupRequest.new(
+        phone_numbers: phone_numbers,
+      )
 
-      expect(status_code).to eq(200)
-      expect(data).to be_instance_of(Bandwidth::LookupStatus)
-      expect(data.request_id.length).to eq(36)
-      expect(data.status).to be_one_of(Bandwidth::LookupStatusEnum.all_vars)
-      expect(data.result).to be_instance_of(Array)
-      expect(data.result[0]).to be_instance_of(Bandwidth::LookupResult)
-      expect(data.result[0].response_code).to be_instance_of(Integer)
-      expect(data.result[0].message).to be_instance_of(String)
-      expect(data.result[0].e_164_format.length).to eq(12)
-      expect(data.result[0].formatted.length).to eq(14)
-      expect(data.result[0].country).to be_instance_of(String)
-      expect(data.result[0].line_type).to be_instance_of(String)
-      expect(data.result[0].line_provider).to be_instance_of(String)
-      expect(data.result[0].mobile_country_code).to be_instance_of(String)
-      expect(data.result[0].mobile_network_code).to be_instance_of(String)
-      expect(data.failed_telephone_numbers).to be_instance_of(Array)
-      expect(data.failed_telephone_numbers[0]).to be_instance_of(String)
-    end
+      data, status_code = @api_instance.create_sync_lookup_with_http_info(BW_ACCOUNT_ID, request)
 
-    it 'causes an ArgumentError for a missing account_id' do
-      expect {
-        @phone_number_lookup_api_instance.get_lookup_status(nil, '')
-      }.to raise_error(ArgumentError)
+      expect(status_code).to equal_to(200)
+      expect(data).to be_instance_of(Bandwidth::CreateSyncLookupResponse)
+      expect(data.links[0]).to be_instance_of(Bandwidth::LinkSchema)
+      expect(data.links[0].rel).to be_instance_of(String)
+      expect(data.links[0].href).to be_instance_of(String)
+      expect(data.links[0].method).to be_instance_of(String)
+      expect(data.data.request_id).to be_instance_of(String)
+      expect(data.data.status).to eq(Bandwidth::CompletedLookupStatusEnum::COMPLETE)
+      expect(data.data.results).to be_instance_of(Array)
+      expect(data.data.results[0]).to be_instance_of(Bandwidth::LookupResult)
+      expect(data.data.results[0].phone_number).to be_instance_of(String)
+      expect(data.data.results[0].line_type).to eq(Bandwidth::LineTypeEnum::MOBILE)
+      expect(data.data.results[0].messaging_provider).to be_instance_of(String)
+      expect(data.data.results[0].voice_provider).to be_instance_of(String)
+      expect(data.data.results[0].country_code_a3).to be_instance_of(String)
+      expect(data.data.results[0].latest_message_delivery_status).to eq(Bandwidth::LatestMessageDeliveryStatusEnum::ACTIVE)
+      expect(data.data.results[0].initial_message_delivery_status_date).to be_instance_of(Date)
+      expect(data.data.results[0].latest_message_delivery_status_date).to be_instance_of(Date)
+      expect(data.errors).to be_instance_of(Array)
     end
+  end
+
+  # Get Asynchronous Bulk Number Lookup
+  describe 'get_async_bulk_lookup test' do
+    it 'should work' do
+      data, status_code = @api_instance.get_async_bulk_lookup_with_http_info(BW_ACCOUNT_ID, request_id)
 
-    it 'causes an ArgumentError for a missing request_id' do
-      expect {
-        @phone_number_lookup_api_instance.get_lookup_status(BW_ACCOUNT_ID, nil)
-      }.to raise_error(ArgumentError)
+      expect(status_code).to equal_to(200)
+      expect(data).to be_instance_of(Bandwidth::GetAsyncBulkLookupResponse)
+      expect(data.links[0]).to be_instance_of(Bandwidth::LinkSchema)
+      expect(data.links[0].rel).to be_instance_of(String)
+      expect(data.links[0].href).to be_instance_of(String)
+      expect(data.links[0].method).to be_instance_of(String)
+      expect(data.data.request_id).to be_instance_of(String)
+      expect(data.data.status).to eq(Bandwidth::InProgressLookupStatusEnum::COMPLETE)
+      expect(data.data.results).to be_instance_of(Array)
+      expect(data.data.results[0]).to be_instance_of(Bandwidth::LookupResult)
+      expect(data.data.results[0].phone_number).to be_instance_of(String)
+      expect(data.data.results[0].line_type).to eq(Bandwidth::LineTypeEnum::MOBILE)
+      expect(data.data.results[0].messaging_provider).to be_instance_of(String)
+      expect(data.data.results[0].voice_provider).to be_instance_of(String)
+      expect(data.data.results[0].country_code_a3).to be_instance_of(String)
+      expect(data.data.results[0].latest_message_delivery_status).to eq(Bandwidth::LatestMessageDeliveryStatusEnum::ACTIVE)
+      expect(data.data.results[0].initial_message_delivery_status_date).to be_instance_of(Date)
+      expect(data.data.results[0].latest_message_delivery_status_date).to be_instance_of(Date)
+      expect(data.errors).to be_instance_of(Array)
     end
   end
 end