Calls, Recordings, Conferences, and Statistics Integration Tests (#71)

* DX-2937 Calls Integration Tests

* update ignore

* separate tests

* remove test.rb

* split tests and add 4xx tests

* add 403

* update call test

* update call

* clearer variable name and update env vars

* secrets.

* finish calls

* add env vars, refactoring, and recording tests

* conferences test

* more recordings tests

* finish recordings

* add asserts for response objects

* finalize calls

* reorder recordings

* finish conferences

* complete or partial

* fix test.yml

* spaces

* updates and statistics tests (#79)

* use stricter type matching for asserts

* stricter asserts

* add statistics tests

* add retry logic to call cleanup

* add sleep and retry less

Author: ckoegel

.github/workflows/test.yml

@@ -35,11 +35,19 @@ jobs:
           BW_ACCOUNT_ID: ${{ secrets.BW_ACCOUNT_ID }}
           BW_USERNAME: ${{ secrets.BW_USERNAME }}
           BW_PASSWORD: ${{ secrets.BW_PASSWORD }}
+          BW_USERNAME_FORBIDDEN: ${{ secrets.BW_USERNAME_FORBIDDEN }}
+          BW_PASSWORD_FORBIDDEN: ${{ secrets.BW_PASSWORD_FORBIDDEN }}
           BW_VOICE_APPLICATION_ID: ${{ secrets.BW_VOICE_APPLICATION_ID }}
           BW_MESSAGING_APPLICATION_ID: ${{ secrets.BW_MESSAGING_APPLICATION_ID }}
           BW_NUMBER: ${{ secrets.BW_NUMBER }}
           USER_NUMBER: ${{ secrets.USER_NUMBER }}
           BASE_CALLBACK_URL: ${{ secrets.BASE_CALLBACK_URL }}
+          MANTECA_ACTIVE_NUMBER: ${{ secrets.MANTECA_ACTIVE_NUMBER }}
+          MANTECA_IDLE_NUMBER: ${{ secrets.MANTECA_IDLE_NUMBER }}
+          MANTECA_BASE_URL: ${{ secrets.MANTECA_BASE_URL }}
+          MANTECA_APPLICATION_ID: ${{ secrets.MANTECA_APPLICATION_ID }}
+          OPERATING_SYSTEM: ${{ matrix.os }}
+          RUBY_VERSION: ${{ matrix.ruby-version }}
         run: rake
 
       - name: Notify Slack of Failures

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

spec/integration/calls_api_integration_spec.rb

@@ -1,42 +1,180 @@
 require 'spec_helper'
 require 'json'
+require_relative '../call_utils'
 
 # Integration Tests for Bandwidth::CallsApi
 describe 'CallsApi Integration Tests' do
-  before do
-    # run before each test
-    @api_instance = Bandwidth::CallsApi.new
-  end
-
-  after do
-    # run after each test
+  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 test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+  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 test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+  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 test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+  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 test' do
-    it 'should work' do
-      # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+  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