twilio_base 1.8.0

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    class Proxy
+      Proxy = Struct.new(:attributes) do
+        def unique_name
+          attributes[:unique_name]
+        end
+      end
+
+      cattr_accessor :proxies
+      self.proxies = []
+
+      def create(attributes)
+        proxy = Proxy.new(attributes)
+        self.class.proxies << proxy
+        proxy
+      end
+
+      def services
+        self
+      end
+
+      def list
+        proxies
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    class Recording
+      Recording = Struct.new(:sid, :attributes) do
+        def update(attributes)
+          self.attributes.merge! attributes
+
+          self
+        end
+      end
+
+      cattr_accessor :recordings, :sid
+      self.recordings = []
+
+      def initialize(sid = nil)
+        self.sid = sid || FactoryBot.generate(:recording_sid)
+      end
+
+      def create(args = {})
+        Recording.new(sid, args).tap do |recording|
+          recordings << recording
+        end
+      end
+
+      def list(attributes = {})
+        recordings.select do |recording|
+          recording.attributes.slice(*attributes.keys) == attributes
+        end
+      end
+
+      def fetch
+        recordings.detect { |recording| recording.sid == sid }
+      end
+
+      def update(attrs = {})
+        return fetch.update(attrs) if fetch.present?
+
+        create(attrs)
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/sync/client.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module Sync
+      class Client
+        def v1
+          self
+        end
+
+        def services(sid = nil)
+          Fake::Sync::Service.new(sid)
+        end
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/sync/service.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module Sync
+      class Service
+        Service = Struct.new(:friendly_name) do
+          def sid
+            @sid ||= FactoryBot.generate(:sync_service_sid)
+          end
+
+          def create(friendly_name: '')
+            self.friendly_name = friendly_name
+          end
+
+          def documents
+            Fake::Sync::Services::Document.new
+          end
+
+          def sync_lists
+            Fake::Sync::Services::List.new
+          end
+
+          def sync_maps
+            Fake::Sync::Services::Map.new
+          end
+        end
+
+        cattr_accessor :services
+        self.services = []
+
+        def initialize(sid = nil)
+          self.sid = sid
+        end
+
+        def create(friendly_name: '')
+          service = Service.new(
+            friendly_name: friendly_name
+          )
+          self.class.services << service
+          service
+        end
+
+        def services(unique_name = nil)
+          Service.new(unique_name || rand(999).to_s)
+        end
+
+        def documents(document_unique_name = nil)
+          Fake::Sync::Services::Document.new(unique_name: document_unique_name)
+        end
+
+        def sync_lists(list_unique_name = nil)
+          Fake::Sync::Services::List.new(unique_name: list_unique_name)
+        end
+
+        def sync_maps(map_unique_name = nil)
+          Fake::Sync::Services::Map.new(unique_name: map_unique_name)
+        end
+
+        def v1
+          self
+        end
+
+        private
+
+        attr_accessor :sid
+
+        def method_missing(_name)
+          self || super
+        end
+
+        def respond_to_missing?(method_name)
+          super
+        end
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/sync/services/document.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module Sync
+      module Services
+        class Document
+          cattr_accessor :documents
+          self.documents = []
+
+          def initialize(data: {}, ttl: '', unique_name: '')
+            self.data = data
+            self.ttl = ttl
+            self.unique_name = unique_name
+          end
+
+          attr_accessor :data, :ttl, :unique_name
+
+          def create(data: {}, ttl: '', unique_name: '')
+            document = Document.new(
+              data: data,
+              ttl: ttl,
+              unique_name: unique_name
+            )
+            self.class.documents << document
+            document
+          end
+
+          def fetch
+            matched_document = self.class.documents.detect do |document|
+              document.unique_name == unique_name
+            end
+
+            raise ArgumentError if matched_document.blank?
+
+            matched_document
+          end
+
+          def documents(unique_name = nil)
+            Document.new(unique_name || rand(999).to_s)
+          end
+
+          def update(params)
+            params[:data]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/sync/services/list.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module Sync
+      module Services
+        class List
+          cattr_accessor :lists
+          self.lists = []
+
+          attr_accessor :data, :ttl, :unique_name
+
+          def initialize(data: {}, ttl: '', unique_name: '')
+            self.data = data
+            self.ttl = ttl
+            self.unique_name = unique_name
+          end
+
+          def create(data: {}, ttl: '', unique_name: '')
+            list = List.new(
+              data: data,
+              ttl: ttl,
+              unique_name: unique_name
+            )
+            self.class.lists << list
+            list
+          end
+
+          def fetch
+            matched_list = self.class.lists.detect do |list|
+              list.unique_name == unique_name
+            end
+
+            raise ArgumentError if matched_list.blank?
+
+            matched_list
+          end
+
+          def lists(unique_name = nil)
+            List.new(unique_name || rand(999).to_s)
+          end
+
+          def sync_list_items
+            Fake::Sync::Services::Lists::Item.new
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/sync/services/lists/item.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module Sync
+      module Services
+        module Lists
+          class Item
+            Item = Struct.new(:data) do
+              attr_accessor :sid
+
+              def create(data: {})
+                self.data = data
+              end
+            end
+
+            cattr_accessor :items
+            self.items = []
+
+            def initialize(sid = nil)
+              self.sid = sid
+            end
+
+            def create(data: {})
+              item = Item.new(
+                data: data
+              )
+              self.class.items << item
+              item
+            end
+
+            private
+
+            attr_accessor :sid
+
+            def method_missing(_name)
+              self || super
+            end
+
+            def respond_to_missing?(method_name)
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/sync/services/map.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module Sync
+      module Services
+        class Map
+          cattr_accessor :maps
+          self.maps = {}
+
+          attr_accessor :data, :ttl, :unique_name
+
+          def initialize(data: {}, ttl: '', unique_name: '')
+            self.data = data
+            self.ttl = ttl
+            self.unique_name = unique_name
+          end
+
+          def create(data: {}, ttl: '', unique_name: '')
+            map = Map.new(
+              data: data,
+              ttl: ttl,
+              unique_name: unique_name
+            )
+            self.class.maps << map
+            map
+          end
+
+          def fetch
+            matched_map = self.class.maps.detect do |map|
+              map.unique_name == unique_name
+            end
+
+            raise ArgumentError if matched_map.blank?
+
+            matched_map
+          end
+
+          def maps(unique_name = nil)
+            Map.new(unique_name || rand(999).to_s)
+          end
+
+          def sync_map_items
+            Fake::Sync::Services::Maps::Item.new
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/sync/services/maps/item.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module Sync
+      module Services
+        module Maps
+          class Item
+            Map = Struct.new(:data, :key) do
+              attr_accessor :sid
+
+              def create(data: {}, key: '')
+                self.data = data
+                self.key = key
+              end
+
+              def update(data: {})
+                self.data = data
+              end
+            end
+
+            cattr_accessor :items
+            self.items = []
+
+            def initialize(sid = nil)
+              self.sid = sid
+            end
+
+            def create(data: {}, key: '')
+              item = Map.new(
+                data: data,
+                key: key
+              )
+              self.class.items << item
+              item
+            end
+
+            private
+
+            attr_accessor :sid
+
+            def method_missing(_name)
+              self || super
+            end
+
+            def respond_to_missing?(method_name)
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/task_router/activity.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module TaskRouter
+      class Activity
+        Activity = Struct.new(:friendly_name) do
+          def sid
+            @sid ||= ::FactoryBot.generate(:activity_sid)
+          end
+        end
+
+        cattr_accessor :activities
+        self.activities = []
+
+        def create(friendly_name:)
+          activity = Activity.new(friendly_name)
+          self.class.activities << activity
+          activity
+        end
+
+        def list(friendly_name: nil)
+          if friendly_name
+            self.class.activities.select do |activity|
+              activity.friendly_name == friendly_name
+            end
+          else
+            self.class.activities
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module TaskRouter
+      class Channel
+        Channel = Struct.new(:name, :attributes) do
+          def sid
+            @sid ||= FactoryBot.generate(channel_sid)
+          end
+
+          def capacity
+            attributes[:capacity]
+          end
+
+          def update(attributes)
+            self.attributes = attributes
+          end
+        end
+
+        cattr_accessor :channels, :name
+        self.channels = []
+
+        def initialize(name = nil)
+          self.name = name
+        end
+
+        def create(name, attributes = nil)
+          channel = Channel.new(name, attributes)
+          self.class.channels << channel
+          channel
+        end
+
+        def fetch
+          channels.detect { |channel| channel.name == name }
+        end
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/task_router/client.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module TaskRouter
+      class Client
+        def initialize(_account_sid, _auth_token); end
+
+        def v1
+          self
+        end
+
+        def workspaces(sid = nil)
+          Fake::TaskRouter::Workspace.new(sid)
+        end
+
+        def tasks(sid = nil)
+          @tasks ||= Fake::TaskRouter::Task.new(sid)
+        end
+
+        def workers
+          Fake::TaskRouter::Worker.new
+        end
+
+        def activities
+          Fake::TaskRouter::Activity.new
+        end
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/task_router/statistic.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module TaskRouter
+      class Statistic
+        Statistic = Struct.new(:sid, :realtime) do
+          def update(_attributes = {})
+            self
+          end
+        end
+
+        cattr_accessor :attrs, :sid, :statistics
+        self.statistics = []
+
+        def initialize(sid = nil, attrs = {})
+          self.sid = sid
+          self.attrs = attrs
+        end
+
+        def create
+          statistic = Statistic.new(
+            sid,
+            attrs[:realtime]
+          )
+          self.class.statistics << statistic
+          statistic
+        end
+
+        def fetch
+          create
+
+          statistics.detect { |statistic| statistic.sid == sid }
+        end
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/task_router/task.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module TaskRouter
+      class Task
+        Task = Struct.new(
+          :sid,
+          :workflow_sid,
+          :task_channel,
+          :attributes,
+          :age,
+          :priority,
+          :task_queue_friendly_name,
+          :timeout
+        ) do
+          def assignment_status
+            JSON.parse(attributes)['assignment_status']
+          end
+
+          def delete
+            TwilioBase::Fake::TaskRouter::Task.tasks -= [self]
+          end
+
+          def task_channel_unique_name
+            task_channel&.name
+          end
+
+          def update(params = {})
+            self.attributes = params.to_json
+          end
+
+          def update(params)
+            attributes = JSON.parse(params[:attributes] || '{}')
+            self.attributes = attributes.merge(params.except(:attributes))
+              .to_json
+          end
+        end
+
+        cattr_accessor :sid, :tasks
+        self.tasks = []
+
+        def initialize(sid = nil)
+          self.sid = sid || FactoryBot.generate(:task_sid)
+        end
+
+        def create(attributes)
+          task = Task.new(
+            sid,
+            attributes[:workflow_sid],
+            attributes[:task_channel],
+            task_attributes(attributes),
+            attributes[:age],
+            attributes[:priority],
+            attributes[:task_queue_friendly_name],
+            attributes[:timeout]
+          )
+          self.class.tasks << task
+          task
+        end
+
+        def task_attributes(attributes)
+          if attributes[:attributes].present?
+            attributes[:attributes]
+          else
+            { assignment_status: 'reserved' }.to_json
+          end
+        end
+
+        def list(_attributes = {})
+          tasks
+        end
+
+        def fetch
+          tasks.detect { |task| task.sid == sid }
+        end
+      end
+    end
+  end
+end

data/spec/support/twilio_base/fake/task_router/task_queue.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module TwilioBase
+  module Fake
+    module TaskRouter
+      class TaskQueue
+        TaskQueue = Struct.new(:attributes) do
+          def assignment_activity_sid
+            attributes[:assignment_activity_sid]
+          end
+
+          def friendly_name
+            attributes[:friendly_name]
+          end
+
+          def reservation_activity_sid
+            attributes[:reservation_activity_sid]
+          end
+
+          def update(params)
+            self.attributes = params.to_json
+          end
+        end
+
+        cattr_accessor :task_queues
+        self.task_queues = []
+
+        def create(attributes)
+          task_queue = TaskQueue.new(attributes)
+          self.class.task_queues << task_queue
+          task_queue
+        end
+
+        def list(friendly_name: nil)
+          if friendly_name
+            task_queues.select do |task_queue|
+              task_queue.friendly_name == friendly_name
+            end
+          else
+            task_queues
+          end
+        end
+      end
+    end
+  end
+end