bandwidth-sdk 11.0.0.pre.beta.1.1 → 11.0.0.pre.beta.2.0

data/spec/integration/messages_api_integration_spec.rb

@@ -1,14 +1,28 @@
-require 'spec_helper'
-require 'json'
-
 # Integration Tests for Bandwidth::MessagesApi
 describe 'MessagesApi Integration Tests' do
+  # message info
+  let(:mms_text) { 'ruby sdk test MMS' }
+  let(:sms_text) { 'ruby sdk test SMS' }
+  let(:mms_tag) { 'ruby sdk test MMS tag' }
+  let(:sms_tag) { 'ruby sdk test SMS tag' }
+  let(:media_url) { 'https://cdn2.thecatapi.com/images/MTY3ODIyMQ.jpg' }
+  let(:priority) { Bandwidth::PriorityEnum::HIGH }
+  let(:list_message_direction) { Bandwidth::ListMessageDirectionEnum::OUTBOUND }
+  
   before(:all) do
+    WebMock.allow_net_connect!
     Bandwidth.configure do |config|
       config.username = BW_USERNAME
       config.password = BW_PASSWORD
     end
-    @api_instance_msg = Bandwidth::MessagesApi.new()
+    @messaging_api_instance = Bandwidth::MessagesApi.new()
+
+    # expiration time
+    @expiration_time = (Time.now + 60).round.to_datetime.rfc3339
+  end
+
+  after(:all) do
+    WebMock.disable_net_connect!
   end
 
   # Create Message
@@ -18,49 +32,47 @@ describe 'MessagesApi Integration Tests' do
         application_id: BW_MESSAGING_APPLICATION_ID,
         to: [USER_NUMBER],
         from: BW_NUMBER,
-        text: "ruby sdk test MMS",
-        media: ["https://cdn2.thecatapi.com/images/MTY3ODIyMQ.jpg"],
-        tag: "ruby sdk test MMS tag"
+        text: mms_text,
+        media: [media_url],
+        tag: mms_tag
       )
 
-      response = @api_instance_msg.create_message_with_http_info(BW_ACCOUNT_ID, message_request)
+      data, status_code, headers = @messaging_api_instance.create_message_with_http_info(BW_ACCOUNT_ID, message_request)
 
-      expect(response[CODE]).to eq(202)
-      expect(response[DATA]).to be_instance_of(Bandwidth::Message)
-      expect(response[DATA].id.length).to eq(29)
-      expect(response[DATA].owner).to eq(BW_NUMBER)
-      expect(response[DATA].to).to eq([USER_NUMBER])
-      expect(response[DATA].from).to eq(BW_NUMBER)
-      expect(response[DATA].text).to eq(message_request.text)
-      expect(response[DATA].media).to eq(message_request.media)
-      expect(response[DATA].tag).to eq(message_request.tag)
+      expect(status_code).to eq(202)
+      expect(data).to be_instance_of(Bandwidth::Message)
+      expect(data.id.length).to eq(29)
+      expect(data.owner).to eq(BW_NUMBER)
+      expect(data.to).to eq([USER_NUMBER])
+      expect(data.from).to eq(BW_NUMBER)
+      expect(data.text).to eq(mms_text)
+      expect(data.media).to eq([media_url])
+      expect(data.tag).to eq(mms_tag)
     end
 
     it 'creates an sms message' do
-      expiration_time = Time.now + 60
-      expiration_time = expiration_time.round
       message_request = Bandwidth::MessageRequest.new(
         application_id: BW_MESSAGING_APPLICATION_ID,
         to: [USER_NUMBER],
         from: BW_NUMBER,
-        text: "ruby sdk test SMS",
-        tag: "ruby sdk test SMS tag",
-        priority: Bandwidth::PriorityEnum::HIGH,
-        expiration: expiration_time.to_datetime.rfc3339
+        text: sms_text,
+        tag: sms_tag,
+        priority: priority,
+        expiration: @expiration_time
       )
   
-      response = @api_instance_msg.create_message_with_http_info(BW_ACCOUNT_ID, message_request)
+      data, status_code, headers = @messaging_api_instance.create_message_with_http_info(BW_ACCOUNT_ID, message_request)
   
-      expect(response[CODE]).to eq(202)
-      expect(response[DATA]).to be_instance_of(Bandwidth::Message)
-      expect(response[DATA].id.length).to eq(29)
-      expect(response[DATA].owner).to eq(BW_NUMBER)
-      expect(response[DATA].to).to eq([USER_NUMBER])
-      expect(response[DATA].from).to eq(BW_NUMBER)
-      expect(response[DATA].text).to eq(message_request.text)
-      expect(response[DATA].tag).to eq(message_request.tag)
-      expect(response[DATA].priority).to eq(message_request.priority)
-      expect(response[DATA].expiration).to eq(expiration_time)
+      expect(status_code).to eq(202)
+      expect(data).to be_instance_of(Bandwidth::Message)
+      expect(data.id.length).to eq(29)
+      expect(data.owner).to eq(BW_NUMBER)
+      expect(data.to).to eq([USER_NUMBER])
+      expect(data.from).to eq(BW_NUMBER)
+      expect(data.text).to eq(sms_text)
+      expect(data.tag).to eq(sms_tag)
+      expect(data.priority).to eq(priority)
+      expect(data.expiration).to eq(Time.parse(@expiration_time))
     end
   end
 
@@ -68,17 +80,18 @@ describe 'MessagesApi Integration Tests' do
   describe 'list_messages' do
     it 'lists messages' do
       get_opts = {
-        :source_tn => BW_NUMBER,
-        :message_direction => "OUTBOUND"
+        source_tn: BW_NUMBER,
+        message_direction: list_message_direction
       }
-      response = @api_instance_msg.list_messages_with_http_info(BW_ACCOUNT_ID, get_opts)
+      data, status_code, headers = @messaging_api_instance.list_messages_with_http_info(BW_ACCOUNT_ID, get_opts)
 
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA]).to be_instance_of(Bandwidth::MessagesList)
-      expect(response[DATA].messages[0]).to be_instance_of(Bandwidth::ListMessageItem)
-      expect(response[DATA].messages[0].account_id).to eq(BW_ACCOUNT_ID)
-      expect(response[DATA].messages[0].message_direction).to eq("OUTBOUND")
-      expect(response[DATA].messages[0].source_tn).to eq(BW_NUMBER)
+      expect(status_code).to eq(200)
+      expect(data).to be_instance_of(Bandwidth::MessagesList)
+      expect(data.messages).to be_instance_of(Array)
+      expect(data.messages[0]).to be_instance_of(Bandwidth::ListMessageItem)
+      expect(data.messages[0].account_id).to eq(BW_ACCOUNT_ID)
+      expect(data.messages[0].message_direction).to eq(list_message_direction)
+      expect(data.messages[0].source_tn).to eq(BW_NUMBER)
     end
   end
 
@@ -87,13 +100,13 @@ describe 'MessagesApi Integration Tests' do
     it 'causes a 400 error' do
       body = Bandwidth::MessageRequest.new(
         application_id: BW_MESSAGING_APPLICATION_ID,
-        to: ["+1invalid"],
+        to: ['+1invalid'],
         from: BW_NUMBER,
-        text: "ruby sdk 400 test"
+        text: 'ruby sdk 400 test'
       )
 
       expect {
-        $response = @api_instance_msg.create_message_with_http_info(BW_ACCOUNT_ID, body)
+        @messaging_api_instance.create_message_with_http_info(BW_ACCOUNT_ID, body)
       }.to raise_error { |e|
         expect(e).to be_instance_of(Bandwidth::ApiError)
         expect(e.code).to eq(400)
@@ -102,19 +115,19 @@ describe 'MessagesApi Integration Tests' do
 
     it 'causes a 401 error' do
       Bandwidth.configure do |config|
-        config.username = 'bad_username'
-        config.password = 'bad_password'
+        config.username = UNAUTHORIZED_USERNAME
+        config.password = UNAUTHORIZED_PASSWORD
       end
 
       body = Bandwidth::MessageRequest.new(
         application_id: BW_MESSAGING_APPLICATION_ID,
         to: [USER_NUMBER],
         from: BW_NUMBER,
-        text: "ruby sdk 401 test"
+        text: 'ruby sdk 401 test'
       )
       
       expect {
-        $response = @api_instance_msg.create_message_with_http_info(BW_ACCOUNT_ID, body)
+        @messaging_api_instance.create_message_with_http_info(BW_ACCOUNT_ID, body)
       }.to raise_error { |e|
         expect(e).to be_instance_of(Bandwidth::ApiError)
         expect(e.code).to eq(401)

data/spec/integration/mfa_api_integration_spec.rb

@@ -1,14 +1,20 @@
-require 'spec_helper'
-require 'json'
-
 # Integration Tests for Bandwidth::MFAApi
 describe 'MFAApi Integration Tests' do
+  # mfa info
+  let(:message) { 'Your temporary {NAME} {SCOPE} code is: {CODE}' }
+  let(:digits) { 6 }
+  
   before(:all) do
+    WebMock.allow_net_connect!
     Bandwidth.configure do |config|
       config.username = BW_USERNAME
       config.password = BW_PASSWORD
     end
-    @api_instance_mfa = Bandwidth::MFAApi.new
+    @mfa_api_instance = Bandwidth::MFAApi.new
+  end
+
+  after(:all) do
+    WebMock.disable_net_connect!
   end
 
   # Messaging Authentication Code
@@ -18,14 +24,15 @@ describe 'MFAApi Integration Tests' do
         to: USER_NUMBER,
         from: BW_NUMBER,
         application_id: BW_MESSAGING_APPLICATION_ID,
-        message: "Your temporary {NAME} {SCOPE} code is: {CODE}",
-        digits: 6
+        message: message,
+        digits: digits
       )
-      response = @api_instance_mfa.generate_messaging_code_with_http_info(BW_ACCOUNT_ID, req_schema)
 
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA]).to be_instance_of(Bandwidth::MessagingCodeResponse)
-      expect(response[DATA].message_id.length).to eq(29)
+      data, status_code, headers = @mfa_api_instance.generate_messaging_code_with_http_info(BW_ACCOUNT_ID, req_schema)
+
+      expect(status_code).to eq(200)
+      expect(data).to be_instance_of(Bandwidth::MessagingCodeResponse)
+      expect(data.message_id.length).to eq(29)
     end
   end
 
@@ -36,14 +43,15 @@ describe 'MFAApi Integration Tests' do
         to: USER_NUMBER,
         from: BW_NUMBER,
         application_id: BW_VOICE_APPLICATION_ID,
-        message: "Your temporary {NAME} {SCOPE} code is: {CODE}",
-        digits: 6
+        message: message,
+        digits: digits
       )
-      response = @api_instance_mfa.generate_voice_code_with_http_info(BW_ACCOUNT_ID, req_schema)
 
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA]).to be_instance_of(Bandwidth::VoiceCodeResponse)
-      expect(response[DATA].call_id.length).to eq(47)
+      data, status_code, headers = @mfa_api_instance.generate_voice_code_with_http_info(BW_ACCOUNT_ID, req_schema)
+
+      expect(status_code).to eq(200)
+      expect(data).to be_instance_of(Bandwidth::VoiceCodeResponse)
+      expect(data.call_id.length).to eq(47)
     end
   end
 
@@ -51,16 +59,17 @@ describe 'MFAApi Integration Tests' do
   describe 'verify_code' do
     it 'verifies mfa code' do
       req_schema = Bandwidth::VerifyCodeRequest.new(
-        to: "+1000" + rand(1...10000000).to_s,
-        scope: "2FA",
+        to: '+1000' + rand(1...10000000).to_s,
+        scope: '2FA',
         expiration_time_in_minutes: 3,
-        code: "12345"
+        code: '12345'
       )
-      response = @api_instance_mfa.verify_code_with_http_info(BW_ACCOUNT_ID, req_schema)
 
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA]).to be_instance_of(Bandwidth::VerifyCodeResponse)
-      expect(response[DATA].valid).to be_instance_of(FalseClass)
+      data, status_code, headers = @mfa_api_instance.verify_code_with_http_info(BW_ACCOUNT_ID, req_schema)
+
+      expect(status_code).to eq(200)
+      expect(data).to be_instance_of(Bandwidth::VerifyCodeResponse)
+      expect(data.valid).to be false
     end
   end
 
@@ -70,13 +79,13 @@ describe 'MFAApi Integration Tests' do
       req_schema = Bandwidth::CodeRequest.new(
         to: USER_NUMBER,
         from: BW_NUMBER,
-        application_id: "not_an_application_id",
-        message: "Your temporary {NAME} {SCOPE} code is: {CODE}",
-        digits: 6
+        application_id: 'not_an_application_id',
+        message: message,
+        digits: digits
       )
 
       expect {
-        response = @api_instance_mfa.generate_messaging_code_with_http_info(BW_ACCOUNT_ID, req_schema)
+        @mfa_api_instance.generate_messaging_code_with_http_info(BW_ACCOUNT_ID, req_schema)
       }.to raise_error { |e|
         expect(e).to be_instance_of(Bandwidth::ApiError)
         expect(e.code).to eq(400)
@@ -85,25 +94,24 @@ describe 'MFAApi Integration Tests' do
 
     it 'causes a 403 error' do
       Bandwidth.configure do |config|
-        config.username = 'bad_username'
-        config.password = 'bad_password'
+        config.username = UNAUTHORIZED_USERNAME
+        config.password = UNAUTHORIZED_PASSWORD
       end
 
       req_schema = Bandwidth::CodeRequest.new(
         to: USER_NUMBER,
         from: BW_NUMBER,
         application_id: BW_MESSAGING_APPLICATION_ID,
-        message: "Your temporary {NAME} {SCOPE} code is: {CODE}",
-        digits: 6
+        message: message,
+        digits: digits
       )
       
       expect {
-        response = @api_instance_mfa.generate_messaging_code_with_http_info(BW_ACCOUNT_ID, req_schema)
+        @mfa_api_instance.generate_messaging_code_with_http_info(BW_ACCOUNT_ID, req_schema)
       }.to raise_error { |e|
         expect(e).to be_instance_of(Bandwidth::ApiError)
         expect(e.code).to eq(403)
       }
     end
   end
-
 end

data/spec/integration/phone_number_lookup_api_integration_spec.rb

@@ -1,15 +1,19 @@
-require 'spec_helper'
-require 'json'
-
 # Integration Tests for Bandwidth::PhoneNumberLookupApi
 describe 'PhoneNumberLookupApi Integration Tests' do
   before(:all) do
+    WebMock.allow_net_connect!
     Bandwidth.configure do |config|
       config.username = BW_USERNAME
       config.password = BW_PASSWORD
     end
     @api_instance_tnlookup = Bandwidth::PhoneNumberLookupApi.new
-    $lookup_request_id = ""
+
+    # lookup info
+    $lookup_request_id = ''
+  end
+
+  after(:all) do
+    WebMock.disable_net_connect!
   end
 
   # Create Lookup
@@ -18,14 +22,14 @@ describe 'PhoneNumberLookupApi Integration Tests' do
       tn_body = Bandwidth::LookupRequest.new(
         tns: [BW_NUMBER]
       )
-      response = @api_instance_tnlookup.create_lookup_with_http_info(BW_ACCOUNT_ID, tn_body)
+      data, status_code, headers = @api_instance_tnlookup.create_lookup_with_http_info(BW_ACCOUNT_ID, tn_body)
 
-      expect(response[CODE]).to eq(202)
-      expect(response[DATA]).to be_instance_of(Bandwidth::CreateLookupResponse)
-      expect(response[DATA].request_id.length).to eq(36)
-      expect(response[DATA].status).to be_instance_of(String)
+      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)
 
-      $lookup_request_id  = response[DATA].request_id
+      $lookup_request_id  = data.request_id
       sleep(1)
     end
   end
@@ -33,14 +37,15 @@ describe 'PhoneNumberLookupApi Integration Tests' do
   # Get Lookup Status
   describe 'get_lookup_status' do
     it 'gets lookup status' do
-      response = @api_instance_tnlookup.get_lookup_status_with_http_info(BW_ACCOUNT_ID, $lookup_request_id)
+      data, status_code, headers = @api_instance_tnlookup.get_lookup_status_with_http_info(BW_ACCOUNT_ID, $lookup_request_id)
 
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA]).to be_instance_of(Bandwidth::LookupStatus)
-      expect(response[DATA].request_id).to eq($lookup_request_id)
-      expect(response[DATA].status).to be_instance_of(String)
-      expect(response[DATA].result[0].response_code).to be_instance_of(Integer)
-      expect(response[DATA].result[0].e_164_format).to eq(BW_NUMBER)
+      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)
     end
   end
 
@@ -48,7 +53,7 @@ describe 'PhoneNumberLookupApi Integration Tests' do
   describe 'http error' do
     it 'causes a 400 error' do
       tn_body_bad = Bandwidth::LookupRequest.new(
-        tns: ["+1invalid"]
+        tns: ['+1invalid']
       )
 
       expect {
@@ -60,7 +65,7 @@ describe 'PhoneNumberLookupApi Integration Tests' do
     end
     
     it 'causes a 404 error' do
-      req_id_dne = "12345678-abcd-cdef-9876-12345678abcd"
+      req_id_dne = '12345678-abcd-cdef-9876-12345678abcd'
 
       expect {
         @api_instance_tnlookup.get_lookup_status_with_http_info(BW_ACCOUNT_ID, req_id_dne)
@@ -72,8 +77,8 @@ describe 'PhoneNumberLookupApi Integration Tests' do
 
     it 'causes a 401 error' do
       Bandwidth.configure do |config|
-        config.username = 'bad_username'
-        config.password = 'bad_password'
+        config.username = UNAUTHORIZED_USERNAME
+        config.password = UNAUTHORIZED_PASSWORD
       end
 
       tn_body = Bandwidth::LookupRequest.new(
@@ -88,5 +93,4 @@ describe 'PhoneNumberLookupApi Integration Tests' do
       }
     end
   end
-
 end