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

data/spec/integration/calls_api_integration_spec.rb

@@ -1,29 +1,45 @@
-require 'spec_helper'
-require 'json'
 require_relative '../call_utils'
 
 # Integration Tests for Bandwidth::CallsApi
 describe 'CallsApi Integration Tests' do
+  # call info
+  let(:answer_method) { Bandwidth::CallbackMethodEnum::POST }
+  let(:answer_url) { BASE_CALLBACK_URL + '/callbacks/answer' }
+  let(:answer_fallback_method) { Bandwidth::CallbackMethodEnum::POST }
+  let(:disconnect_method) { Bandwidth::CallbackMethodEnum::GET }
+  let(:disconnect_url) { BASE_CALLBACK_URL + '/callbacks/disconnect' }
+  let(:priority) { 5 }
+  let(:direction) { Bandwidth::CallDirectionEnum::OUTBOUND }
+  let(:call_timeout) { 30.0 }
+  let(:callback_timeout) { 15.0 }
+  
   before(:all) do
+    WebMock.allow_net_connect!
     Bandwidth.configure do |config|
       config.username = BW_USERNAME
       config.password = BW_PASSWORD
     end
-    @api_instance_calls = Bandwidth::CallsApi.new
-    $call_info_id = ""
+    @calls_api_instance = Bandwidth::CallsApi.new
+    
+    # call id
+    $call_info_id = ''
+  end
+
+  after(:all) do
+    WebMock.disable_net_connect!
   end
 
   # Create Call
   describe 'create_call' do
     it 'creates a call with amd' do
       amd_config = Bandwidth::MachineDetectionConfiguration.new(
-        mode: "async",
+        mode: 'async',
         detection_timeout: 5.0,
         silence_timeout: 5.0,
         speech_threshold: 5.0,
         speech_end_threshold: 5.0,
         delay_result: true,
-        callback_url: BASE_CALLBACK_URL + "/machineDetection",
+        callback_url: BASE_CALLBACK_URL + '/machineDetection',
         callback_method: Bandwidth::CallbackMethodEnum::POST
       )
 
@@ -31,35 +47,34 @@ describe 'CallsApi Integration Tests' do
         application_id: BW_VOICE_APPLICATION_ID,
         to: USER_NUMBER,
         from: BW_NUMBER,
-        answer_url: BASE_CALLBACK_URL + "/callbacks/answer",
-        answer_method: "POST",
-        disconnect_url: BASE_CALLBACK_URL + "/callbacks/disconnect",
-        disconnect_method: "GET",
+        answer_url: answer_url,
+        answer_method: answer_method,
+        disconnect_url: disconnect_url,
+        disconnect_method: disconnect_method,
         machine_detection: amd_config,
-        call_timeout: 30.0,
-        callback_timeout: 15.0
+        call_timeout: call_timeout,
+        callback_timeout: callback_timeout
       )
 
-      response = @api_instance_calls.create_call_with_http_info(BW_ACCOUNT_ID, call_body)
-      sleep(SLEEP_TIME_S)
-
-      expect(response[CODE]).to eq(201)
-      expect(response[DATA]).to be_instance_of(Bandwidth::CreateCallResponse)
-      expect(response[DATA].call_id.length).to eq(47)
-      expect(response[DATA].account_id).to eq(BW_ACCOUNT_ID)
-      expect(response[DATA].application_id).to eq(BW_VOICE_APPLICATION_ID)
-      expect(response[DATA].to).to eq(USER_NUMBER)
-      expect(response[DATA].from).to eq(BW_NUMBER)
-      expect(response[DATA].call_id)
-      expect(response[DATA].call_timeout).to eq(30.0)
-      expect(response[DATA].callback_timeout).to eq(15.0)
-      expect(response[DATA].enqueued_time).to be_instance_of(Time)
-      expect(response[DATA].answer_method).to eq(Bandwidth::CallbackMethodEnum::POST)
-      expect(response[DATA].disconnect_method).to eq("GET")
-      expect(response[DATA].answer_url).to eq(BASE_CALLBACK_URL + "/callbacks/answer")
-      expect(response[DATA].disconnect_url).to eq(BASE_CALLBACK_URL + "/callbacks/disconnect")
-
-      $call_info_id = response[DATA].call_id
+      data, status_code, headers = @calls_api_instance.create_call_with_http_info(BW_ACCOUNT_ID, call_body)
+
+      expect(status_code).to eq(201)
+      expect(data).to be_instance_of(Bandwidth::CreateCallResponse)
+      expect(data.call_id.length).to eq(47)
+      expect(data.account_id).to eq(BW_ACCOUNT_ID)
+      expect(data.application_id).to eq(BW_VOICE_APPLICATION_ID)
+      expect(data.to).to eq(USER_NUMBER)
+      expect(data.from).to eq(BW_NUMBER)
+      expect(data.call_timeout).to eq(call_timeout)
+      expect(data.callback_timeout).to eq(callback_timeout)
+      expect(data.enqueued_time).to be_instance_of(Time)
+      expect(data.answer_method).to eq(answer_method)
+      expect(data.answer_fallback_method).to eq(answer_fallback_method)
+      expect(data.disconnect_method).to eq(disconnect_method)
+      expect(data.answer_url).to eq(answer_url)
+      expect(data.disconnect_url).to eq(disconnect_url)
+
+      $call_info_id = data.call_id
       $active_calls.append($call_info_id)
     end
   end
@@ -67,17 +82,24 @@ describe 'CallsApi Integration Tests' do
   # Get Call State Information
   describe 'get_call_state' do
     it 'gets the call state' do
-      response = @api_instance_calls.get_call_state_with_http_info(BW_ACCOUNT_ID, $call_info_id)
-
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA]).to be_instance_of(Bandwidth::CallState)
-      expect(response[DATA].call_id).to eq($call_info_id)
-      expect(response[DATA].account_id).to eq(BW_ACCOUNT_ID)
-      expect(response[DATA].application_id).to eq(BW_VOICE_APPLICATION_ID)
-      expect(response[DATA].start_time).to be_instance_of(Time)
-      expect(response[DATA].last_update).to be_instance_of(Time)
-      expect(response[DATA].state).to be_instance_of(String)
-      expect(response[DATA].direction).to eq(Bandwidth::CallDirectionEnum::OUTBOUND)
+      begin
+        sleep(SLEEP_TIME_S)
+        data, status_code, headers = @calls_api_instance.get_call_state_with_http_info(BW_ACCOUNT_ID, $call_info_id)
+  
+        expect(status_code).to eq(200)
+        expect(data).to be_instance_of(Bandwidth::CallState)
+        expect(data.call_id).to eq($call_info_id)
+        expect(data.account_id).to eq(BW_ACCOUNT_ID)
+        expect(data.application_id).to eq(BW_VOICE_APPLICATION_ID)
+        expect(data.start_time).to be_instance_of(Time)
+        expect(data.last_update).to be_instance_of(Time)
+        expect(data.state).to be_instance_of(String)
+        expect(data.direction).to eq(direction)
+      rescue Bandwidth::ApiError => e
+        if e.code != 404
+          raise e
+        end
+      end
     end
   end
 
@@ -86,34 +108,34 @@ describe 'CallsApi Integration Tests' do
     it 'creates and updates a call' do    
       update_call_body = Bandwidth::UpdateCall.new(
         state: Bandwidth::CallStateEnum::ACTIVE,
-        redirect_url: MANTECA_BASE_URL + "/bxml/pause"
+        redirect_url: MANTECA_BASE_URL + '/bxml/pause'
       )
       
-      update_call_id = create_manteca_call(@api_instance_calls)
+      update_call_id = create_manteca_call(@calls_api_instance)
       sleep(SLEEP_TIME_S)
       
-      update_response = @api_instance_calls.update_call_with_http_info(BW_ACCOUNT_ID, update_call_id, update_call_body)
-      expect(update_response[CODE]).to eq(200)
+      update_data, update_status_code, update_headers = @calls_api_instance.update_call_with_http_info(BW_ACCOUNT_ID, update_call_id, update_call_body)
+      expect(update_status_code).to eq(200)
       sleep(SLEEP_TIME_S)
       
-      complete_response = @api_instance_calls.update_call_with_http_info(BW_ACCOUNT_ID, update_call_id, $complete_call_body)
-      expect(complete_response[CODE]).to eq(200)
+      complete_data, complete_status_code, complete_headers = @calls_api_instance.update_call_with_http_info(BW_ACCOUNT_ID, update_call_id, $complete_call_body)
+      expect(complete_status_code).to eq(200)
     end
   end
 
   # Update Call BXML
   describe 'update_call_bxml' do
     it 'updates a call using bxml' do
-      update_call_id = create_manteca_call(@api_instance_calls)
+      update_call_id = create_manteca_call(@calls_api_instance)
       sleep(SLEEP_TIME_S)
 
-      update_bxml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><Bxml><SpeakSentence locale=\"en_US\" gender=\"female\" voice=\"susan\">This is a test bxml response</SpeakSentence><Pause duration=\"3\"/></Bxml>";
-      update_response = @api_instance_calls.update_call_bxml_with_http_info(BW_ACCOUNT_ID, update_call_id, update_bxml)
-      expect(update_response[CODE]).to eq(204)
+      update_bxml = '<?xml version="1.0" encoding="UTF-8"?><Bxml><SpeakSentence locale="en_US" gender="female" voice="susan">This is a test bxml response</SpeakSentence><Pause duration="3"/></Bxml>'
+      update_data, update_status_code, update_headers = @calls_api_instance.update_call_bxml_with_http_info(BW_ACCOUNT_ID, update_call_id, update_bxml)
+      expect(update_status_code).to eq(204)
       sleep(SLEEP_TIME_S)
       
-      complete_response = @api_instance_calls.update_call_with_http_info(BW_ACCOUNT_ID, update_call_id, $complete_call_body)
-      expect(complete_response[CODE]).to eq(200)
+      complete_data, complete_status_code, complete_headers = @calls_api_instance.update_call_with_http_info(BW_ACCOUNT_ID, update_call_id, $complete_call_body)
+      expect(complete_status_code).to eq(200)
     end
   end
 
@@ -122,16 +144,16 @@ describe 'CallsApi Integration Tests' do
     it 'causes a 400 error' do
       call_body_bad = Bandwidth::CreateCall.new(
         application_id: BW_VOICE_APPLICATION_ID,
-        to: "+1invalid",
+        to: '+1invalid',
         from: BW_NUMBER,
-        answer_url: BASE_CALLBACK_URL + "/callbacks/answer",
-        answer_method: "POST",
-        disconnect_url: BASE_CALLBACK_URL + "/callbacks/disconnect",
-        disconnect_method: "GET"
+        answer_url: answer_url,
+        answer_method: answer_method,
+        disconnect_url: disconnect_url,
+        disconnect_method: disconnect_method
       )
 
       expect {
-        @api_instance_calls.create_call_with_http_info(BW_ACCOUNT_ID, call_body_bad)
+        @calls_api_instance.create_call_with_http_info(BW_ACCOUNT_ID, call_body_bad)
       }.to raise_error { |e|
         expect(e).to be_instance_of(Bandwidth::ApiError)
         expect(e.code).to eq(400)
@@ -139,10 +161,8 @@ describe 'CallsApi Integration Tests' do
     end
 
     it 'causes a 404 error' do
-      dne_id = "does-not-exist"
-
       expect {
-        @api_instance_calls.get_call_state_with_http_info(BW_ACCOUNT_ID, dne_id)
+        @calls_api_instance.get_call_state_with_http_info(BW_ACCOUNT_ID, 'does-not-exist')
       }.to raise_error { |e|
         expect(e).to be_instance_of(Bandwidth::ApiError)
         expect(e.code).to eq(404)
@@ -151,12 +171,12 @@ describe 'CallsApi 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
 
       expect {
-        @api_instance_calls.get_call_state_with_http_info(BW_ACCOUNT_ID, $call_info_id)
+        @calls_api_instance.get_call_state_with_http_info(BW_ACCOUNT_ID, $call_info_id)
       }.to raise_error { |e|
         expect(e).to be_instance_of(Bandwidth::ApiError)
         expect(e.code).to eq(401)
@@ -170,12 +190,11 @@ describe 'CallsApi Integration Tests' do
       end
 
       expect {
-        @api_instance_calls.get_call_state_with_http_info(BW_ACCOUNT_ID, $call_info_id)
+        @calls_api_instance.get_call_state_with_http_info(BW_ACCOUNT_ID, $call_info_id)
       }.to raise_error { |e|
         expect(e).to be_instance_of(Bandwidth::ApiError)
         expect(e.code).to eq(403)
       }
     end
   end
-
 end

data/spec/integration/conferences_api_integration_spec.rb

@@ -1,21 +1,26 @@
-require 'spec_helper'
-require 'json'
 require_relative '../call_utils'
 
 # Integration Tests for Bandwidth::ConferencesApi
 describe 'ConferencesApi Integration Tests' do
   before(:all) do
+    WebMock.allow_net_connect!
     Bandwidth.configure do |config|
       config.username = BW_USERNAME
       config.password = BW_PASSWORD
       config.return_binary_data = true
     end
-    @api_instance_conferences = Bandwidth::ConferencesApi.new
-    @api_instance_calls = Bandwidth::CallsApi.new
+    @conferences_api_instance = Bandwidth::ConferencesApi.new
+    @calls_api_instance = Bandwidth::CallsApi.new
+
+    # conference info
     $manteca_test_id = setup_manteca('conference')
-    $manteca_call_id = create_manteca_call($manteca_test_id, "/bxml/joinConferencePause", @api_instance_calls)
-    $conference_id = ""
-    $recording_id = ""
+    $manteca_call_id = create_manteca_call($manteca_test_id, '/bxml/joinConferencePause', @calls_api_instance)
+    $conference_id = ''
+    $recording_id = ''
+  end
+
+  after(:all) do
+    WebMock.disable_net_connect!
   end
   
   # Get Conferences
@@ -26,37 +31,38 @@ describe 'ConferencesApi Integration Tests' do
       }
 
       sleep(SLEEP_TIME_S)
-      response = @api_instance_conferences.list_conferences_with_http_info(BW_ACCOUNT_ID, conference_opts)
+      data, status_code, headers = @conferences_api_instance.list_conferences_with_http_info(BW_ACCOUNT_ID, conference_opts)
 
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA][0]).to be_instance_of(Bandwidth::Conference)
-      expect(response[DATA][0].id).to be_instance_of(String)
-      $conference_id = response[DATA][0].id
+      expect(status_code).to eq(200)
+      expect(data).to be_instance_of(Array)
+      expect(data[0]).to be_instance_of(Bandwidth::Conference)
+      expect(data[0].id).to be_instance_of(String)
+      $conference_id = data[0].id
     end
   end
 
   # Get Conference Information
   describe 'get_conference' do
     it 'get a conference by id' do
-      response = @api_instance_conferences.get_conference_with_http_info(BW_ACCOUNT_ID, $conference_id)
+      data, status_code, headers = @conferences_api_instance.get_conference_with_http_info(BW_ACCOUNT_ID, $conference_id)
 
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA]).to be_instance_of(Bandwidth::Conference)
-      expect(response[DATA].id).to eq($conference_id)
-      expect(response[DATA].name).to eq($manteca_test_id)
-      expect(response[DATA].tag).to eq($manteca_test_id)
+      expect(status_code).to eq(200)
+      expect(data).to be_instance_of(Bandwidth::Conference)
+      expect(data.id).to eq($conference_id)
+      expect(data.name).to eq($manteca_test_id)
+      expect(data.tag).to eq($manteca_test_id)
     end
   end
   
   # Get Conference Member
   describe 'get_conference_member' do
     it 'gets a conference member by call id' do
-      response = @api_instance_conferences.get_conference_member_with_http_info(BW_ACCOUNT_ID, $conference_id, $manteca_call_id)
+      data, status_code, headers = @conferences_api_instance.get_conference_member_with_http_info(BW_ACCOUNT_ID, $conference_id, $manteca_call_id)
 
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA]).to be_instance_of(Bandwidth::ConferenceMember)
-      expect(response[DATA].conference_id).to eq($conference_id)
-      expect(response[DATA].call_id).to eq($manteca_call_id)
+      expect(status_code).to eq(200)
+      expect(data).to be_instance_of(Bandwidth::ConferenceMember)
+      expect(data.conference_id).to eq($conference_id)
+      expect(data.call_id).to eq($manteca_call_id)
     end
   end
   
@@ -67,8 +73,8 @@ describe 'ConferencesApi Integration Tests' do
         mute: false
       )
 
-      response = @api_instance_conferences.update_conference_member_with_http_info(BW_ACCOUNT_ID, $conference_id, $manteca_call_id, update_conference_member)
-      expect(response[CODE]).to eq(204)
+      data, status_code, headers = @conferences_api_instance.update_conference_member_with_http_info(BW_ACCOUNT_ID, $conference_id, $manteca_call_id, update_conference_member)
+      expect(status_code).to eq(204)
     end
   end
 
@@ -77,34 +83,34 @@ describe 'ConferencesApi Integration Tests' do
     it 'updates a conference' do
       update_conference_body = Bandwidth::UpdateConference.new(
         status: Bandwidth::ConferenceStateEnum::ACTIVE,
-        redirect_url: MANTECA_BASE_URL + "/bxml/pause",
+        redirect_url: MANTECA_BASE_URL + '/bxml/pause',
         redirect_method: Bandwidth::RedirectMethodEnum::POST,
-        username: "username",
-        password: "password",
-        redirect_fallback_url: MANTECA_BASE_URL + "/bxml/pause",
+        username: 'username',
+        password: 'password',
+        redirect_fallback_url: MANTECA_BASE_URL + '/bxml/pause',
         redirect_fallback_method: Bandwidth::RedirectMethodEnum::POST,
-        fallback_username: "username",
-        fallback_password: "password"
+        fallback_username: 'username',
+        fallback_password: 'password'
       )
 
-      response = @api_instance_conferences.update_conference_with_http_info(BW_ACCOUNT_ID, $conference_id, update_conference_body)
-      expect(response[CODE]).to eq(204)
+      data, status_code, headers = @conferences_api_instance.update_conference_with_http_info(BW_ACCOUNT_ID, $conference_id, update_conference_body)
+      expect(status_code).to eq(204)
     end
   end
 
   # Update Conference BXML
   describe 'update_conference_bxml' do
     it 'updates a conference using bxml' do
-      update_bxml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><Bxml><StartRecording/><SpeakSentence locale=\"en_US\" gender=\"female\" voice=\"susan\">This should be a conference recording.</SpeakSentence><StopRecording/></Bxml>"
+      update_bxml = '<?xml version="1.0" encoding="UTF-8"?><Bxml><StartRecording/><SpeakSentence locale="en_US" gender="female" voice="susan">This should be a conference recording.</SpeakSentence><StopRecording/></Bxml>'
 
-      response = @api_instance_conferences.update_conference_bxml_with_http_info(BW_ACCOUNT_ID, $conference_id, update_bxml)
-      expect(response[CODE]).to eq(204)
+      data, status_code, headers = @conferences_api_instance.update_conference_bxml_with_http_info(BW_ACCOUNT_ID, $conference_id, update_bxml)
+      expect(status_code).to eq(204)
 
       retries = 0
       recording_complete = false
       begin
         while !recording_complete && retries < MAX_RETRIES
-          recording_complete = get_manteca_test_status($manteca_test_id)["callRecorded"]
+          recording_complete = get_manteca_test_status($manteca_test_id)['callRecorded']
           retries += 1
           sleep(SLEEP_TIME_S)
         end
@@ -112,52 +118,52 @@ describe 'ConferencesApi Integration Tests' do
         puts e.inspect
       end
 
-      expect(recording_complete).to be_instance_of(TrueClass)
+      expect(recording_complete).to be true
     end
   end
   
   # Get Conference Recordings
   describe 'list_conference_recordings' do
     it 'lists recordings for a conference' do
-      response = @api_instance_conferences.list_conference_recordings_with_http_info(BW_ACCOUNT_ID, $conference_id)
-
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA][0]).to be_instance_of(Bandwidth::ConferenceRecordingMetadata)
-      expect(response[DATA][0].conference_id).to eq($conference_id)
-      expect(response[DATA][0].account_id).to eq(BW_ACCOUNT_ID)
-      expect(response[DATA][0].name).to eq($manteca_test_id)
-      expect(response[DATA][0].status).to eq('complete').or eq('partial')
-      expect(response[DATA][0].recording_id).to be_instance_of(String)
-      expect(response[DATA][0].file_format).to eq(Bandwidth::FileFormatEnum::WAV)
-
-      $recording_id = response[DATA][0].recording_id
+      data, status_code, headers = @conferences_api_instance.list_conference_recordings_with_http_info(BW_ACCOUNT_ID, $conference_id)
+
+      expect(status_code).to eq(200)
+      expect(data).to be_instance_of(Array)
+      expect(data[0]).to be_instance_of(Bandwidth::ConferenceRecordingMetadata)
+      expect(data[0].conference_id).to eq($conference_id)
+      expect(data[0].account_id).to eq(BW_ACCOUNT_ID)
+      expect(data[0].name).to eq($manteca_test_id)
+      expect(data[0].status).to eq('complete').or eq('partial')
+      expect(data[0].recording_id).to be_instance_of(String)
+      expect(data[0].file_format).to eq(Bandwidth::FileFormatEnum::WAV)
+
+      $recording_id = data[0].recording_id
     end
   end
   
-    # Get Conference Recording Information
-    describe 'get_conference_recording' do
-      it 'gets a conference recording by id' do
-        response = @api_instance_conferences.get_conference_recording_with_http_info(BW_ACCOUNT_ID, $conference_id, $recording_id)
-
-        expect(response[CODE]).to eq(200)
-        expect(response[DATA]).to be_instance_of(Bandwidth::ConferenceRecordingMetadata)
-        expect(response[DATA].conference_id).to eq($conference_id)
-        expect(response[DATA].account_id).to eq(BW_ACCOUNT_ID)
-        expect(response[DATA].name).to eq($manteca_test_id)
-        expect(response[DATA].status).to eq('complete').or eq('partial')
-        expect(response[DATA].recording_id).to be_instance_of(String)
-        expect(response[DATA].file_format).to eq(Bandwidth::FileFormatEnum::WAV)
-      end
+  # Get Conference Recording Information
+  describe 'get_conference_recording' do
+    it 'gets a conference recording by id' do
+      data, status_code, headers = @conferences_api_instance.get_conference_recording_with_http_info(BW_ACCOUNT_ID, $conference_id, $recording_id)
+
+      expect(status_code).to eq(200)
+      expect(data).to be_instance_of(Bandwidth::ConferenceRecordingMetadata)
+      expect(data.conference_id).to eq($conference_id)
+      expect(data.account_id).to eq(BW_ACCOUNT_ID)
+      expect(data.name).to eq($manteca_test_id)
+      expect(data.status).to eq('complete').or eq('partial')
+      expect(data.recording_id).to be_instance_of(String)
+      expect(data.file_format).to eq(Bandwidth::FileFormatEnum::WAV)
     end
+  end
 
   # Download Conference Recording
   describe 'download_conference_recording test' do
     it 'should work' do
-      response = @api_instance_conferences.download_conference_recording_with_http_info(BW_ACCOUNT_ID, $conference_id, $recording_id)
+      data, status_code, headers = @conferences_api_instance.download_conference_recording_with_http_info(BW_ACCOUNT_ID, $conference_id, $recording_id)
 
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA]).to be_instance_of(String)
+      expect(status_code).to eq(200)
+      expect(data).to be_instance_of(String)
     end
   end
-
 end

data/spec/integration/media_api_integration_spec.rb

@@ -1,73 +1,80 @@
-require 'spec_helper'
-require 'json'
-
 # Integration Tests for Bandwidth::MediaApi
 describe 'MediaApi Integration Tests' do
+  # media info
+  let(:binary_media_data) { '123456' }
+  let(:media_file_data) { File.open('spec/fixtures/ruby_cat.jpeg').read }
+  let(:media_file_md5) { Digest::MD5.hexdigest(media_file_data) }
+  
   before(:all) do
+    WebMock.allow_net_connect!
     Bandwidth.configure do |config|
       config.username = BW_USERNAME
       config.password = BW_PASSWORD
       config.return_binary_data = true
     end
     @api_instance_media = Bandwidth::MediaApi.new
+
+    # media names
     @binary_media_name = 'ruby_binary_media' + SecureRandom.uuid
-    @binary_media_data = '123456'
     @media_file_name = 'ruby_media_file' + SecureRandom.uuid
-    @media_file_data = File.open("spec/fixtures/ruby_cat.jpeg").read
-    @media_file_md5 = Digest::MD5.hexdigest(@media_file_data)
+  end
+
+  after(:all) do
+    WebMock.disable_net_connect!
   end
 
   # Upload Media
   describe 'upload_media' do
     it 'uploads binary media' do
-      response = @api_instance_media.upload_media_with_http_info(BW_ACCOUNT_ID, @binary_media_name, @binary_media_data)
-      expect(response[CODE]).to eq(204)
+      data, status_code, headers = @api_instance_media.upload_media_with_http_info(BW_ACCOUNT_ID, @binary_media_name, binary_media_data)
+      expect(status_code).to eq(204)
     end
 
     it 'uploads media file' do
-      response = @api_instance_media.upload_media_with_http_info(BW_ACCOUNT_ID, @media_file_name, @media_file_data)
-      expect(response[CODE]).to eq(204)
+      data, status_code, headers = @api_instance_media.upload_media_with_http_info(BW_ACCOUNT_ID, @media_file_name, media_file_data)
+      expect(status_code).to eq(204)
     end
   end
   
-    # List Media
-    describe 'list_media' do
-      it 'lists media' do
-        response = @api_instance_media.list_media_with_http_info(BW_ACCOUNT_ID)
-        expect(response[CODE]).to eq(200)
-        expect(response[DATA][0]).to be_instance_of(Bandwidth::Media)
-        expect(response[DATA][0].content).to be_instance_of(String)
-        expect(response[DATA][0].content_length).to be > 0
-      end
+  # List Media
+  describe 'list_media' do
+    it 'lists media' do
+      data, status_code, headers = @api_instance_media.list_media_with_http_info(BW_ACCOUNT_ID)
+      expect(status_code).to eq(200)
+      expect(data).to be_instance_of(Array)
+      expect(data[0]).to be_instance_of(Bandwidth::Media)
+      expect(data[0].content).to be_instance_of(String)
+      expect(data[0].content_length).to be > 0
     end
+  end
 
   # Get Media
   describe 'get_media' do
     it 'gets uploaded binary media' do
-      response = @api_instance_media.get_media_with_http_info(BW_ACCOUNT_ID, @binary_media_name, debug_return_type: 'String')
-      expect(response[CODE]).to eq(200)
-      expect(response[DATA]).to eq(@binary_media_data)
+      data, status_code, headers = @api_instance_media.get_media_with_http_info(BW_ACCOUNT_ID, @binary_media_name)
+      expect(status_code).to eq(200)
+      expect(data).to eq(binary_media_data)
     end
 
     it 'gets uploaded media file' do
-      response = @api_instance_media.get_media_with_http_info(BW_ACCOUNT_ID, @media_file_name)
-      response_md5 = Digest::MD5.hexdigest(response[DATA])
+      data, status_code, headers = @api_instance_media.get_media_with_http_info(BW_ACCOUNT_ID, @media_file_name)
+      response_md5 = Digest::MD5.hexdigest(data)
 
-      expect(response[CODE]).to eq(200)
-      expect(response_md5).to eq(@media_file_md5)
+      expect(status_code).to eq(200)
+      expect(response_md5).to eq(media_file_md5)
     end
   end
 
   # Delete Media
   describe 'delete_media' do
     it 'deletes the binary media' do
-      response = @api_instance_media.delete_media_with_http_info(BW_ACCOUNT_ID, @binary_media_name)
-      expect(response[CODE]).to eq(204)
+      data, status_code, headers = @api_instance_media.delete_media_with_http_info(BW_ACCOUNT_ID, @binary_media_name)
+      expect(status_code).to eq(204)
     end
 
     it 'deletes the media file' do
-      response = @api_instance_media.delete_media_with_http_info(BW_ACCOUNT_ID, @media_file_name)
-      expect(response[CODE]).to eq(204)
+      data, status_code, headers = @api_instance_media.delete_media_with_http_info(BW_ACCOUNT_ID, @media_file_name)
+      expect(status_code).to eq(204)
     end
   end
 
@@ -75,12 +82,11 @@ describe 'MediaApi Integration Tests' do
   describe 'http error' do
     it 'causes a 404 error' do
       expect {
-        response = @api_instance_media.get_media_with_http_info(BW_ACCOUNT_ID, "does_not_exist")
+        @api_instance_media.get_media_with_http_info(BW_ACCOUNT_ID, 'does_not_exist')
       }.to raise_error { |e|
         expect(e).to be_instance_of(Bandwidth::ApiError)
         expect(e.code).to eq(404)
       }
     end
   end
-
 end