twilio_base 1.8.0

data/spec/services/twilio_base/routers/voice/default_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe TwilioBase::Routers::Voice::Default do
+  let(:protocol) do
+    TwilioBase::Protocols::Voice::Pstn.new(to: '+1234567890')
+  end
+
+  describe '.init' do
+    context 'with set routing_method' do
+      it 'overwrites ENV variable' do
+        stub_const('ENV', ENV.to_h.merge('ROUTING_METHOD' => 'direct_dial'))
+
+        allow(TwilioBase::Routers::Voice::DirectDial).to receive(:new)
+        allow(TwilioBase::Routers::Voice::TaskRouter).to receive(:new)
+
+        described_class.init(protocol: protocol, routing_method: 'task_router')
+
+        expect(TwilioBase::Routers::Voice::DirectDial)
+          .to_not have_received(:new)
+        expect(TwilioBase::Routers::Voice::TaskRouter).to have_received(:new)
+          .with(protocol: protocol)
+      end
+    end
+
+    context 'with not set routing_method' do
+      context 'with direct dial routing method' do
+        before do
+          stub_const('ENV', ENV.to_h.merge('ROUTING_METHOD' => 'direct_dial'))
+        end
+
+        it 'inits Routers::Voice::DirectDial' do
+          allow(TwilioBase::Routers::Voice::DirectDial).to receive(:new)
+
+          described_class.init(protocol: protocol)
+
+          expect(TwilioBase::Routers::Voice::DirectDial).to have_received(:new)
+            .with(protocol: protocol)
+        end
+      end
+
+      context 'with task router routing method' do
+        before do
+          stub_const('ENV', ENV.to_h.merge('ROUTING_METHOD' => 'task_router'))
+        end
+
+        it 'inits Routers::Voice::TaskRouter' do
+          allow(TwilioBase::Routers::Voice::TaskRouter).to receive(:new)
+
+          described_class.init(protocol: protocol)
+
+          expect(TwilioBase::Routers::Voice::TaskRouter).to have_received(:new)
+            .with(protocol: protocol)
+        end
+      end
+    end
+  end
+end

data/spec/services/twilio_base/routers/voice/task_router_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe TwilioBase::Routers::Voice::TaskRouter do
+  let!(:config) { create(:global_config) }
+
+  describe '#route' do
+    context 'with pstn protocol' do
+      it 'enqueue the task using plain phone number' do
+        protocol = TwilioBase::Protocols::Voice::Pstn.new(
+          params: {
+            action_url: 'https://someurl.com',
+            status_callback_url: 'https://somestatusurl.com',
+            wait_url: 'https://somewaiturl.com'
+          },
+          to: '+1234567890'
+        )
+
+        direct_dial = described_class.new(protocol: protocol)
+        expected_result = enqueue_twiml(protocol: protocol)
+
+        expect(direct_dial.route).to eq(expected_result)
+      end
+    end
+
+    context 'with sip protocol' do
+      it 'enqueue the task using sip endpoint' do
+        protocol = TwilioBase::Protocols::Voice::Sip.new(
+          params: {
+            action_url: 'https://someurl.com',
+            sip_endpoint: '124@abc.net',
+            status_callback_url: 'https://somestatusurl.com',
+            wait_url: 'https://somewaiturl.com'
+          },
+          to: '+1234567890'
+        )
+
+        direct_dial = described_class.new(protocol: protocol)
+        expected_result = enqueue_twiml(protocol: protocol)
+
+        expect(direct_dial.route).to eq(expected_result)
+      end
+    end
+  end
+
+  def enqueue_twiml(protocol:)
+    action_url = protocol.action_url
+    endpoint = protocol.endpoint
+    wait_url = protocol.wait_url
+    workflow_sid = config.workflow_sid
+
+    '<?xml version="1.0" encoding="UTF-8"?>' \
+    "\n<Response>\n" \
+      "<Enqueue action=\"#{action_url}\" waitUrl=\"#{wait_url}\" " \
+        "workflowSid=\"#{workflow_sid}\">" \
+        "\n<Task>" \
+          "{\"outbound_contact_uri\":\"#{endpoint}\"}" \
+        "</Task>\n" \
+      '</Enqueue>' \
+    "\n</Response>\n"
+  end
+end

data/spec/services/twilio_base/sync/service.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe TwilioBase::Sync::Service do
+  describe '.create' do
+    it 'creates a new sync service' do
+      expect { described_class.create }
+        .to change { TwilioBase::Fake::Sync.sync_services.count }.by(1)
+    end
+
+    it 'assigns default friendly name to the service' do
+      described_class.create
+
+      expect(TwilioBase::Fake::Sync.sync_services.last.friendly_name)
+        .to eq Twilio::Sync::Service::DEFAULT_FRIENDLY_NAME
+    end
+
+    it 'assigns spcified friendly name to the service' do
+      name = 'Test name'
+
+      described_class.create(friendly_name: name)
+
+      expect(TwilioBase::Fake::Sync.sync_services.last.friendly_name).to eq name
+    end
+  end
+end

data/spec/services/twilio_base/task_router/activity_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+RSpec.describe TwilioBase::TaskRouter::Activity do
+  include_context :global_config
+
+  describe '.available' do
+    it 'returns object of activity with friendly name "Available"' do
+      available_activity = TwilioBase::Fake::TaskRouter::Activity.new.create(
+        friendly_name: described_class::AVAILABLE_ACTIVITY_NAME
+      )
+
+      expect(described_class.available).to eq(available_activity)
+    end
+  end
+
+  describe '.busy' do
+    it 'returns object of activity with friendly name "Busy"' do
+      busy_activity = TwilioBase::Fake::TaskRouter::Activity.new.create(
+        friendly_name: described_class::ASSIGNMENT_ACTIVITY_NAME
+      )
+
+      expect(described_class.busy).to eq(busy_activity)
+    end
+  end
+
+  describe '.idle' do
+    it 'returns object of activity with friendly name "Idle"' do
+      idle_activity = TwilioBase::Fake::TaskRouter::Activity.new.create(
+        friendly_name: described_class::IDLE_ACTIVITY_NAME
+      )
+
+      expect(described_class.idle).to eq(idle_activity)
+    end
+  end
+
+  describe '.list' do
+    it 'shows list of activities' do
+      4.times do |i|
+        TwilioBase::Fake::TaskRouter::Activity.new
+          .create(friendly_name: "activity #{i}")
+      end
+
+      expect(
+        described_class.list.count
+      ).to eq 4
+    end
+  end
+
+  describe '.offline' do
+    it 'returns object of activity with friendly name "Offline' do
+      offline_activity = TwilioBase::Fake::TaskRouter::Activity.new.create(
+        friendly_name: described_class::OFFLINE_ACTIVITY_NAME
+      )
+
+      expect(described_class.offline).to eq(offline_activity)
+    end
+  end
+
+  describe '.reserved' do
+    it 'returns object of activity with friendly name "Reserved"' do
+      reserved_activity = TwilioBase::Fake::TaskRouter::Activity.new.create(
+        friendly_name: described_class::RESERVATION_ACTIVITY_NAME
+      )
+
+      expect(described_class.reserved).to eq(reserved_activity)
+    end
+  end
+end

data/spec/services/twilio_base/task_router/task_queue_spec.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+RSpec.describe TwilioBase::TaskRouter::TaskQueue do
+  describe '.find_or_create_by' do
+    context 'taskqueue already exists with params' do
+      it 'does not create a task queue' do
+        workspace = TwilioBase::Fake::TaskRouter::Workspace.new.create({})
+        friendly_name = 'Name'
+        _task_queue = TwilioBase::Fake::TaskRouter::TaskQueue.new.create(
+          workspace: workspace,
+          friendly_name: friendly_name
+        )
+
+        expect do
+          described_class.find_or_create_by(
+            workspace: workspace,
+            friendly_name: friendly_name
+          )
+        end.not_to(
+          change { TwilioBase::Fake::TaskRouter::TaskQueue.task_queues.count }
+        )
+      end
+
+      it 'returns the task queue' do
+        workspace = TwilioBase::Fake::TaskRouter::Workspace.new.create({})
+        friendly_name = 'Name'
+        task_queue = TwilioBase::Fake::TaskRouter::TaskQueue.new.create(
+          workspace: workspace,
+          friendly_name: friendly_name
+        )
+
+        expect(
+          described_class.find_or_create_by(
+            workspace: workspace, friendly_name: friendly_name
+          )
+        ).to eq task_queue
+      end
+    end
+
+    context 'taskqueue does not exist with params' do
+      let!(:reserved_activity) do
+        TwilioBase::Fake::TaskRouter::Activity
+          .new.create(friendly_name: 'Reserved')
+      end
+      let!(:busy_activity) do
+        TwilioBase::Fake::TaskRouter::Activity.new.create(friendly_name: 'Busy')
+      end
+
+      it 'creates a task queue' do
+        workspace = TwilioBase::Fake::TaskRouter::Workspace.new.create({})
+        friendly_name = 'Name'
+
+        expect do
+          described_class.find_or_create_by(
+            workspace: workspace,
+            friendly_name: friendly_name
+          )
+        end.to change {
+          TwilioBase::Fake::TaskRouter::TaskQueue.task_queues.count
+        }.by(1)
+      end
+
+      it 'returns the task queue' do
+        workspace = TwilioBase::Fake::TaskRouter::Workspace.new.create({})
+        friendly_name = 'Name'
+
+        expect(
+          described_class.find_or_create_by(
+            workspace: workspace, friendly_name: friendly_name
+          )
+        ).to eq TwilioBase::Fake::TaskRouter::TaskQueue.task_queues.last
+      end
+
+      it 'assigns the friendly name to the task queue' do
+        workspace = TwilioBase::Fake::TaskRouter::Workspace.new.create({})
+        friendly_name = 'Name'
+
+        described_class.find_or_create_by(
+          workspace: workspace, friendly_name: friendly_name
+        )
+
+        task_queue_name = TwilioBase::Fake::TaskRouter::TaskQueue
+          .task_queues.last.friendly_name
+        expect(task_queue_name).to eq friendly_name
+      end
+
+      it 'assigns the busy activity to the task queue assignment activity' do
+        workspace = TwilioBase::Fake::TaskRouter::Workspace.new.create({})
+        friendly_name = 'Name'
+
+        described_class.find_or_create_by(
+          workspace: workspace, friendly_name: friendly_name
+        )
+
+        assignment_activity_sid = TwilioBase::Fake::TaskRouter::TaskQueue
+          .task_queues.last.assignment_activity_sid
+        expect(assignment_activity_sid).to eq busy_activity.sid
+      end
+
+      it 'assigns the reserved activity to task queue reservation activity' do
+        workspace = TwilioBase::Fake::TaskRouter::Workspace.new.create({})
+        friendly_name = 'Name'
+
+        described_class.find_or_create_by(
+          workspace: workspace, friendly_name: friendly_name
+        )
+
+        reservation_activity_sid = TwilioBase::Fake::TaskRouter::TaskQueue
+          .task_queues.last.reservation_activity_sid
+        expect(reservation_activity_sid).to eq reserved_activity.sid
+      end
+    end
+  end
+end

data/spec/services/twilio_base/task_router/worker_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+RSpec.describe TwilioBase::TaskRouter::Worker do
+  include_context :global_config
+
+  describe '.create' do
+    it 'creates a new worker' do
+      _idle_activity = TwilioBase::Fake::TaskRouter::Activity.new
+        .create(friendly_name: 'Idle')
+
+      expect { described_class.create(name: 'Name', attributes: {}) }
+        .to change { TwilioBase::Fake::TaskRouter::Worker.workers.count }
+        .by(1)
+    end
+
+    it 'creates worker with correct attributes' do
+      friendly_name = 'Name'
+      idle_activity = TwilioBase::Fake::TaskRouter::Activity.new
+        .create(friendly_name: 'Idle')
+
+      described_class.create(name: friendly_name, attributes: {})
+      new_worker = TwilioBase::Fake::TaskRouter::Worker.workers.last
+
+      expect(new_worker.friendly_name).to eq friendly_name
+      expect(new_worker.activity_sid).to eq idle_activity.sid
+    end
+  end
+
+  describe '.find' do
+    it 'returns the relevant worker' do
+      _idle_activity = TwilioBase::Fake::TaskRouter::Activity.new
+        .create(friendly_name: 'Idle')
+      found_worker = TwilioBase::Fake::TaskRouter::Worker.new.create({})
+      _not_found_worker = TwilioBase::Fake::TaskRouter::Worker.new.create({})
+
+      expect(described_class.find(found_worker.sid)).to eq found_worker
+    end
+
+    context 'non-matching worker' do
+      it 'returns nil' do
+        _idle_activity = TwilioBase::Fake::TaskRouter::Activity.new
+          .create(friendly_name: 'Idle')
+        _not_found_worker = TwilioBase::Fake::TaskRouter::Worker.new.create({})
+
+        expect(described_class.find(FactoryBot.generate(:worker_sid))).to be_nil
+      end
+    end
+  end
+end

data/spec/services/twilio_base/task_router/workflow_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe TwilioBase::TaskRouter::Workflow do
+  let(:attributes) do
+    {
+      configuration: {},
+      friendly_name: 'Test Workspace'
+    }
+  end
+
+  describe '#create' do
+    it 'should create a new workflow' do
+      workspace = TwilioBase::Fake::TaskRouter::Workspace.new.create({})
+      expect do
+        described_class.create(
+          attributes: attributes,
+          workspace: workspace
+        )
+      end.to change {
+        TwilioBase::Fake::TaskRouter::Workflow.workflows.count
+      }.by(1)
+    end
+
+    it 'assigns the config to the workflow' do
+      workspace = TwilioBase::Fake::TaskRouter::Workspace.new.create({})
+
+      described_class.create(
+        attributes: attributes,
+        workspace: workspace
+      )
+
+      workflow_name = TwilioBase::Fake::TaskRouter::Workflow
+        .workflows.last.friendly_name
+      expect(workflow_name).to eq attributes[:friendly_name]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+ENV['RAILS_ENV'] ||= 'test'
+ENV['APP_NAME'] = 'Test app'
+ENV['COUNTRY_CODE'] = 'GB'
+ENV['TWILIO_ACCOUNT_SID'] = 'account_sid'
+ENV['TWILIO_AUTH_TOKEN'] = 'auth_token'
+
+require 'active_record'
+require 'factory_bot'
+require 'rails'
+require 'twilio_base'
+
+require File.expand_path('twilio_base_dummy/config/environment.rb', __dir__)
+Dir[File.join(__dir__, 'support', '**', '*.rb')].each { |file| require file }
+
+require 'bundler/setup'
+require 'byebug'
+require 'database_cleaner'
+require 'shoulda/matchers'
+require 'shoulda/callback/matchers'
+require 'timecop'
+require 'rspec/rails'
+
+ActiveRecord::Migration.maintain_test_schema!
+
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :rspec
+    with.library :active_record
+  end
+end
+
+TwilioBase::Engine.routes.default_url_options[:host] = 'localhost:3000'
+
+RSpec.configure do |config|
+  config.include(Shoulda::Matchers::ActiveModel, type: :model)
+  config.include(Shoulda::Matchers::ActiveRecord, type: :model)
+  config.include(Shoulda::Callback::Matchers::ActiveModel)
+  config.include(TwilioBase::Responses::Twiml)
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.infer_spec_type_from_file_location!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.before(:each) do
+    TwilioBase::Fake::Helpers.clean_cache
+    Rails.cache.clear
+  end
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation, except: %w[ar_internal_metadata])
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+
+  Twilio::REST::Client = TwilioBase::Fake::Clients::Rest
+end

data/spec/support/factory_bot.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.include FactoryBot::Syntax::Methods
+
+  config.before(:suite) do
+    FactoryBot.find_definitions
+  end
+end

data/spec/support/shared_contexts/global_config.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+RSpec.shared_context :global_config do
+  before(:each) { FactoryBot.create(:global_config) }
+  let(:config) { TwilioBase::GlobalConfig.first }
+end

data/spec/support/shared_contexts/twilio_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.shared_context :twilio_controller do
+  before(:each) { expect(controller).to receive(:validate_request) }
+end

data/spec/support/twilio_base/fake/api_key.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    class ApiKey
+      Key = Struct.new(:friendly_name) do
+        def sid
+          @sid ||= FactoryBot.generate(:api_key_sid)
+        end
+
+        def secret
+          @secret ||= FactoryBot.generate(:api_key_secret)
+        end
+      end
+
+      cattr_accessor :keys
+      self.keys = []
+
+      def create(friendly_name:)
+        key = Key.new(friendly_name)
+        self.class.keys << key
+        key
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/application.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    class Application
+      Application = Struct.new(:attributes) do
+        def sid
+          @sid ||= TwilioBase::GlobalConfig.first&.application_sid ||
+                   FactoryBot.generate(:application_sid)
+        end
+
+        def friendly_name
+          attributes[:friendly_name]
+        end
+
+        def sms_url
+          attributes[:sms_url]
+        end
+
+        def sms_method
+          attributes[:sms_method]
+        end
+
+        def voice_url
+          attributes[:voice_url]
+        end
+
+        def voice_method
+          attributes[:voice_method]
+        end
+
+        def update(attributes)
+          self.attributes = attributes
+        end
+      end
+
+      cattr_accessor :applications, :sid
+      self.applications = []
+
+      def initialize(sid = nil)
+        self.sid = sid
+      end
+
+      def create(attributes)
+        application = Application.new(attributes)
+        self.class.applications << application
+        application
+      end
+
+      def list
+        applications
+      end
+
+      def fetch
+        applications.detect { |application| application.sid == sid }
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/available_phone_number.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    class AvailablePhoneNumber
+      PhoneNumber = Struct.new(:phone_number)
+
+      cattr_accessor :phone_numbers
+      self.phone_numbers = []
+
+      def initialize(_country_code = nil); end
+
+      def local
+        self
+      end
+
+      def list(*)
+        available_numbers
+      end
+
+      def available_numbers
+        [
+          PhoneNumber.new(FactoryBot.generate(:phone_number)),
+          PhoneNumber.new(FactoryBot.generate(:phone_number))
+        ]
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/chat/channel.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module Chat
+      class Channel
+        Channel = Struct.new(:attributes) do
+          def friendly_name
+            attributes[:friendly_name]
+          end
+
+          def messages
+            TwilioBase::Fake::Chat::Message.new
+          end
+
+          def members
+            TwilioBase::Fake::Chat::Member.new
+          end
+
+          def sid
+            @sid ||= FactoryBot.generate(:channel_sid)
+          end
+
+          def delete
+            TwilioBase::Fake::Chat::Channel.channels.pop
+          end
+
+          def update(update_attributes)
+            attributes.merge! update_attributes
+          end
+        end
+
+        cattr_accessor :channels
+        self.channels = []
+
+        def initialize(channel_sid = nil)
+          self.channel_sid = channel_sid
+        end
+
+        def create(attributes)
+          self.class.channels << Channel.new(attributes)
+          channels.last
+        end
+
+        def fetch
+          raise ArgumentError unless matched_channel?
+
+          self.class.channels.last
+        end
+
+        private
+
+        attr_accessor :channel_sid
+
+        def matched_channel?
+          self.class.channels.detect do |channel|
+            channel.sid == channel_sid
+          end.present?
+        end
+      end
+    end
+  end
+end