bandwidth-sdk 10.1.0 → 11.0.0.pre.beta.1

data/ruby-notes.md

@@ -0,0 +1,64 @@
+# Config and Basic Auth
+
+## APIMatic
+
+```ruby
+bandwidth_client = Bandwidth::Client.new(
+    messaging_basic_auth_user_name: BW_USERNAME,
+    messaging_basic_auth_password: BW_PASSWORD
+)
+messaging_client = bandwidth_client.messaging_client.client
+```
+
+## OpenAPIGenerator
+
+```ruby
+OpenapiClient.configure do |config|
+      config.username = BW_USERNAME
+      config.password = BW_PASSWORD
+end
+messaging_client = OpenapiClient::MessagesApi.new()
+```
+
+# Send SMS
+
+## APIMatic
+```ruby
+account_id = BW_ACCOUNT_ID
+
+body = MessageRequest.new
+body.application_id = BW_MESSAGING_APPLICATION_ID
+body.to = [USER_NUMBER]
+body.from = BW_NUMBER
+body.text = "Hello World!"
+
+messaging_client.create_message(account_id, body)
+```
+
+## OpenAPIGenerator
+
+```ruby
+account_id = BW_ACCOUNT_ID
+
+body = OpenapiClient::MessageRequest.new(
+      application_id: BW_MESSAGING_APPLICATION_ID.to_s,
+      to: [USER_NUMBER],
+      from: BW_NUMBER,
+      text: "ruby new sdk test"
+)
+
+messaging_client.create_message(account_id, body)
+```
+
+# OpenApiGenerator Quirks
+
+* To get a custom url, instead of setting the `environment` parameter in the config, you must make a custom operation in `configuration.rb`
+``` ruby
+"Pipedream": [
+          {
+            url: "https://d6979da481772c167be0edcd10eb64d7.m.pipedream.net",
+            description: "testing"
+          }
+        ],
+```
+this must go in `operation_server_settings` and then `:operation => :"Pipedream",` must go in `new_options = opts.merge(` for the method you are calling within the `?_api.rb` file for the specific api

data/spec/call_utils.rb

@@ -0,0 +1,74 @@
+# Helper functions for voice calls 
+# These are reused in multiple tests
+
+def setup_manteca(type)
+    manteca_body = {
+      os: OPERATING_SYSTEM,
+      language: RUBY_VERSION,
+      type: type
+    }
+    manteca_test_url = URI(MANTECA_BASE_URL + "/tests")
+    manteca_header = { 'Content-Type': 'application/json' }
+  
+    begin
+      test_id = Net::HTTP.post(manteca_test_url, manteca_body.to_json, manteca_header)
+      return test_id.body.to_s.gsub("\"", "")
+    rescue => e
+      puts e.inspect
+    end
+end
+
+def create_manteca_call(tag = "ruby", answer_path = "/bxml/pause", calls_api)
+    manteca_call_body = Bandwidth::CreateCall.new(
+      application_id: MANTECA_APPLICATION_ID,
+      to: MANTECA_IDLE_NUMBER,
+      from: MANTECA_ACTIVE_NUMBER,
+      answer_url: MANTECA_BASE_URL + answer_path,
+      tag: tag
+    )
+  
+    response = calls_api.create_call(BW_ACCOUNT_ID, manteca_call_body)
+    $active_calls.append(response.call_id)
+    return response.call_id
+end
+
+def get_manteca_test_status(test_id)
+  manteca_status_url = URI(MANTECA_BASE_URL + "/tests/" + test_id)
+  response = JSON.parse(Net::HTTP.get(manteca_status_url))
+  return response
+end
+
+def cleanup_calls(calls, calls_api)
+  attempts = 0
+
+  while (calls.length > 0 && attempts < 10)
+    calls.delete_if { |call_id| call_ended(call_id, calls_api) }
+    sleep(SLEEP_TIME_S)
+    attempts += 1
+  end
+
+  if (calls.length > 0)
+    error_message = "Failed to terminate all calls" + calls.to_s
+    raise StandardError.new error_message
+  end
+end
+
+def call_ended(call_id, calls_api)
+  begin
+    response = calls_api.get_call_state(BW_ACCOUNT_ID, call_id)
+  rescue Bandwidth::ApiError
+    return false
+  end
+
+  if !(response.state == 'disconnected')
+    begin
+      calls_api.update_call(BW_ACCOUNT_ID, call_id, $complete_call_body)
+      return true
+    rescue Bandwidth::ApiError
+    end
+  else
+    return true
+  end
+
+  return false
+end

data/spec/integration/calls_api_integration_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+require 'json'
+require_relative '../call_utils'
+
+# Integration Tests for Bandwidth::CallsApi
+describe 'CallsApi Integration Tests' do
+  before(:all) do
+    Bandwidth.configure do |config|
+      config.username = BW_USERNAME
+      config.password = BW_PASSWORD
+    end
+    @api_instance_calls = Bandwidth::CallsApi.new
+    $call_info_id = ""
+  end
+
+  # Create Call
+  describe 'create_call' do
+    it 'creates a call with amd' do
+      amd_config = Bandwidth::MachineDetectionConfiguration.new(
+        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_method: Bandwidth::CallbackMethodEnum::POST
+      )
+
+      call_body = Bandwidth::CreateCall.new(
+        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",
+        machine_detection: amd_config,
+        call_timeout: 30.0,
+        callback_timeout: 15.0
+      )
+
+      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
+      $active_calls.append($call_info_id)
+    end
+  end
+
+  # 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)
+    end
+  end
+
+  # Update Call
+  describe 'update_call' 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"
+      )
+      
+      update_call_id = create_manteca_call(@api_instance_calls)
+      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)
+      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)
+    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)
+      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)
+      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)
+    end
+  end
+
+  # HTTP 4XX Errors
+  describe 'http error' do
+    it 'causes a 400 error' do
+      call_body_bad = Bandwidth::CreateCall.new(
+        application_id: BW_VOICE_APPLICATION_ID,
+        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"
+      )
+
+      expect {
+        @api_instance_calls.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)
+      }
+    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)
+      }.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 = 'bad_username'
+        config.password = 'bad_password'
+      end
+
+      expect {
+        @api_instance_calls.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)
+      }
+    end
+
+    it 'causes a 403 error' do
+      Bandwidth.configure do |config|
+        config.username = FORBIDDEN_USERNAME
+        config.password = FORBIDDEN_PASSWORD
+      end
+
+      expect {
+        @api_instance_calls.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

@@ -0,0 +1,163 @@
+require 'spec_helper'
+require 'json'
+require_relative '../call_utils'
+
+# Integration Tests for Bandwidth::ConferencesApi
+describe 'ConferencesApi Integration Tests' do
+  before(:all) do
+    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
+    $manteca_test_id = setup_manteca('conference')
+    $manteca_call_id = create_manteca_call($manteca_test_id, "/bxml/joinConferencePause", @api_instance_calls)
+    $conference_id = ""
+    $recording_id = ""
+  end
+  
+  # Get Conferences
+  describe 'list_conferences' do
+    it 'list all conferences' do
+      conference_opts = {
+        name: $manteca_test_id
+      }
+
+      sleep(SLEEP_TIME_S)
+      response = @api_instance_conferences.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
+    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)
+
+      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)
+    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)
+
+      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)
+    end
+  end
+  
+  # Update Conference Member
+  describe 'update_conference_member' do
+    it 'updates a conference member by call id' do
+      update_conference_member = Bandwidth::UpdateConferenceMember.new(
+        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)
+    end
+  end
+
+  # Update Conference
+  describe 'update_conference' do
+    it 'updates a conference' do
+      update_conference_body = Bandwidth::UpdateConference.new(
+        status: Bandwidth::ConferenceStateEnum::ACTIVE,
+        redirect_url: MANTECA_BASE_URL + "/bxml/pause",
+        redirect_method: Bandwidth::RedirectMethodEnum::POST,
+        username: "username",
+        password: "password",
+        redirect_fallback_url: MANTECA_BASE_URL + "/bxml/pause",
+        redirect_fallback_method: Bandwidth::RedirectMethodEnum::POST,
+        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)
+    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>"
+
+      response = @api_instance_conferences.update_conference_bxml_with_http_info(BW_ACCOUNT_ID, $conference_id, update_bxml)
+      expect(response[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"]
+          retries += 1
+          sleep(SLEEP_TIME_S)
+        end
+      rescue => e
+        puts e.inspect
+      end
+
+      expect(recording_complete).to be_instance_of(TrueClass)
+    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
+    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
+    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)
+
+      expect(response[CODE]).to eq(200)
+      expect(response[DATA]).to be_instance_of(String)
+    end
+  end
+
+end

data/spec/integration/media_api_integration_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'json'
+
+# Integration Tests for Bandwidth::MediaApi
+describe 'MediaApi Integration Tests' do
+  before(:all) do
+    Bandwidth.configure do |config|
+      config.username = BW_USERNAME
+      config.password = BW_PASSWORD
+      config.return_binary_data = true
+    end
+    @api_instance_media = Bandwidth::MediaApi.new
+    @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
+
+  # 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)
+    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)
+    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
+    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)
+    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])
+
+      expect(response[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)
+    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)
+    end
+  end
+
+  # HTTP 4XX Errors
+  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")
+      }.to raise_error { |e|
+        expect(e).to be_instance_of(Bandwidth::ApiError)
+        expect(e.code).to eq(404)
+      }
+    end
+  end
+
+end

data/spec/integration/messages_api_integration_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'json'
+
+# Integration Tests for Bandwidth::MessagesApi
+describe 'MessagesApi Integration Tests' do
+  before(:all) do
+    Bandwidth.configure do |config|
+      config.username = BW_USERNAME
+      config.password = BW_PASSWORD
+    end
+    @api_instance_msg = Bandwidth::MessagesApi.new()
+  end
+
+  # Create Message
+  describe 'create_message' do
+    it 'creates an mms message' do
+      message_text = "ruby sdk test MMS"
+        body = Bandwidth::MessageRequest.new(
+            application_id: BW_MESSAGING_APPLICATION_ID,
+            to: [USER_NUMBER],
+            from: BW_NUMBER,
+            text: message_text,
+            media: ["https://cdn2.thecatapi.com/images/MTY3ODIyMQ.jpg"]
+        )
+        response = @api_instance_msg.create_message_with_http_info(BW_ACCOUNT_ID, body)
+
+        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].from).to eq(BW_NUMBER)
+        expect(response[DATA].to).to eq([USER_NUMBER])
+        expect(response[DATA].tag).to eq(body.tag)
+        expect(response[DATA].media).to eq(body.media)
+        expect(response[DATA].text).to eq(message_text)
+    end
+  end
+
+  # List Messages
+  describe 'list_messages' do
+    it 'lists messages' do
+      get_opts = {
+        :source_tn => BW_NUMBER,
+        :message_direction => "OUTBOUND"
+      }
+      response = @api_instance_msg.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)
+    end
+  end
+
+  # HTTP 4XX Errors
+  describe 'http error' do
+    it 'causes a 400 error' do
+      body = Bandwidth::MessageRequest.new(
+        application_id: BW_MESSAGING_APPLICATION_ID,
+        to: ["+1invalid"],
+        from: BW_NUMBER,
+        text: "ruby sdk 400 test"
+      )
+
+      expect {
+        $response = @api_instance_msg.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)
+      }
+    end
+
+    it 'causes a 401 error' do
+      Bandwidth.configure do |config|
+        config.username = 'bad_username'
+        config.password = 'bad_password'
+      end
+
+      body = Bandwidth::MessageRequest.new(
+        application_id: BW_MESSAGING_APPLICATION_ID,
+        to: [USER_NUMBER],
+        from: BW_NUMBER,
+        text: "ruby sdk 401 test"
+      )
+      
+      expect {
+        $response = @api_instance_msg.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)
+      }
+    end
+  end
+  
+end