twilio-ruby 4.2.1 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af489771a6143eed6bab64834224d33424173807
-  data.tar.gz: 9ace9554caa5f9726e8391aaa554dbd9ccfcd2a3
+  metadata.gz: b89103d98fe5a0cc274231f662de67e7a3b33c35
+  data.tar.gz: 23519a4229477cd81a3d0a03023c3c0d0032eb28
 SHA512:
-  metadata.gz: 73a48780f30ca69167c4de6f48acea63366718ddb6d54908e11147075edb864497f7972b2de58393e50c28cf77076c8754fc28b34ebcd7a45264aaea3b962d25
-  data.tar.gz: 885802c111f183d73945f7fd8ddc99f75834017890e4a304e26296a791e9b508396771bf77bbabcf2588a8e5aa1e07b3f46d9094c77e7e9e265acfa008e9a12e
+  metadata.gz: 22efb989dd0661f6e15f2357faff19b67cb9ee0314d38024ea5a399b46fb8dd1d44f30975bc1b744ef3f75854d97df17d71992c528b9ee231cd75d5d685399f1
+  data.tar.gz: e3b6739ff15ef1c1ab643f85923776e8831213412c8a1ddc3d36c23cc2331324976f6357aabd098f667ebaf651e97abab5883d26595c03e90714e86fa4e58a55

data/CHANGES.md

@@ -1,6 +1,16 @@
 twilio-ruby changelog
 =====================
 
+Version 4.3.0
+-------------
+
+Release August 11, 2015
+
+- Add support for new Taskrouter JWT Functionality, JWTs now grant access to
+  - Workspace
+  - Worker
+  - TaskQueue
+
 Version 4.2.1
 -------------
 

data/lib/twilio-ruby/rest/list_resource.rb

@@ -35,11 +35,10 @@ module Twilio
 
       ##
       # Grab a list of this kind of resource and return it as an array. The
-      # array includes a special attribute named +total+ which will return the
-      # total number of items in the list on Twilio's server. This may differ
-      # from the +size+ and +length+ attributes of the returned array since
-      # by default Twilio will only return 50 resources, and the maximum number
-      # of resources you can request is 1000.
+      # array includes two special methods +previous_page+ and +next_page+
+      # which will return the previous or next page or resources. By default
+      # Twilio will only return 50 resources, and the maximum number of
+      # resources you can request (using the :page_size param) is 1000.
       #
       # The optional +params+ hash allows you to filter the list returned. The
       # filters for each list resource type are defined by Twilio.

data/lib/twilio-ruby/task_router/capability.rb

@@ -1,7 +1,6 @@
 module Twilio
   module TaskRouter
     class Capability
-
       TASK_ROUTER_BASE_URL = 'https://taskrouter.twilio.com'
       TASK_ROUTER_VERSION = 'v1'
       TASK_ROUTER_WEBSOCKET_BASE_URL = 'https://event-bridge.twilio.com/v1/wschannels'
@@ -9,79 +8,217 @@ module Twilio
       REQUIRED = {required: true}
       OPTIONAL = {required: false}
 
-      def initialize(account_sid, auth_token, workspace_sid, worker_sid)
+      def initialize(account_sid, auth_token, workspace_sid, channel_id)
         @account_sid = account_sid
         @auth_token = auth_token
-        @workspace_sid = workspace_sid
-        @worker_sid = worker_sid
         @policies = []
-        allow_websocket_requests
-        allow_activity_list_fetch
+
+        @workspace_sid = workspace_sid
+        @channel_id = channel_id
+
+        @baseUrl = "#{TASK_ROUTER_BASE_URL}/#{TASK_ROUTER_VERSION}/Workspaces/#{workspace_sid}"
+
+        validate_jwt
+
+        setup_resource
+
+        allow_websocket_requests(@channel_id)
+        allow(@resourceUrl, "GET")
       end
 
-      def workspace_url
-        "#{TASK_ROUTER_BASE_URL}/#{TASK_ROUTER_VERSION}/Workspaces/#{@workspace_sid}"
+      def allow_fetch_subresources
+        allow(@resourceUrl + "/**", "GET")
       end
 
-      def worker_url
-        "#{workspace_url}/Workers/#{@worker_sid}"
+      def allow_updates
+        allow(@resourceUrl, "POST")
       end
 
+      def allow_updates_subresources
+        allow(@resourceUrl + "/**", "POST")
+      end
+
+      def allow_delete
+        allow(@resourceUrl, "DELETE")
+      end
+
+      def allow_delete_subresources
+        allow(@resourceUrl + "/**", "DELETE")
+      end
+
+      # @deprecated Please use {Twilio::TaskRouter::WorkerCapability.allowActivityUpdates} instead
       def allow_worker_activity_updates
-        add_policy(worker_url, "POST", nil, {ActivitySid: REQUIRED})
+        if(@channel_id[0..1] == 'WK')
+          allow(@resourceUrl, "POST", nil, {ActivitySid: REQUIRED})
+        else
+          raise "Deprecreated function not applicable to non-Worker"
+        end
       end
 
+      # @deprecated Please use {Twilio::TaskRouter::WorkerCapability} instead; added automatically in constructor
       def allow_worker_fetch_attributes
-        add_policy(worker_url, "GET")
+        if(@channel_id[0..1] == 'WK')
+          allow(@resourceUrl, "GET")
+        else
+          raise "Deprecated function not applicable to non Worker"
+        end
       end
 
+      # @deprecated Please use {Twilio::TaskRouter::WorkerCapability.allowReservationUpdates} instead
       def allow_task_reservation_updates
-        task_url = "#{workspace_url}/Tasks/**"
-        add_policy(task_url, "POST", nil, {ReservationStatus: REQUIRED})
+        if(@channel_id[0..1] == 'WK')
+          task_url = "#{@baseUrl}/Tasks/**"
+          allow(task_url, "POST", nil, nil)
+        else
+          raise "Deprecated function not applicable to non Worker"
+        end
       end
 
-      def add_policy(url, method, query_filters = nil, post_filters = nil, allowed = true)
+      def add_policy(url, method, allowed = true, query_filters = nil, post_filters = nil)
         policy = {
-          url: url,
-          method: method,
-          query_filter: query_filters || {},
-          post_filter: post_filters || {},
-          allow: allowed
+            url: url,
+            method: method,
+            query_filter: query_filters || {},
+            post_filter: post_filters || {},
+            allow: allowed
         }
 
         @policies.push(policy)
       end
 
+      def allow(url, method, query_filters = nil, post_filters = nil)
+        add_policy(url, method, true, query_filters, post_filters)
+      end
+
+      def deny(url, method, query_filters = nil, post_filters = nil)
+        add_policy(url, method, false, query_filters, post_filters)
+      end
+
       def generate_token(ttl = 3600)
+        taskRouterAttributes = {
+            account_sid: @account_sid,
+            workspace_sid: @workspace_sid,
+            channel: @channel_id
+        }
+
+        if(@channel_id[0..1] == 'WK')
+          taskRouterAttributes['worker_sid'] = @channel_id
+        elsif(@channel_id[0..1] == 'WQ')
+          taskRouterAttributes['taskqueue_sid'] = @channel_id
+        end
+
+        generate_token_protected(ttl, taskRouterAttributes)
+      end
+
+      protected
+
+      def generate_token_protected(ttl = 3600, extraAttributes)
         payload = {
-          iss: @account_sid,
-          exp: (Time.now.to_i + ttl),
-          version: @version,
-          friendly_name: @worker_sid,
-          policies: @policies,
-          account_sid: @account_sid,
-          worker_sid: @worker_sid,
-          channel: @worker_sid,
-          workspace_sid: @workspace_sid
+            iss: @account_sid,
+            exp: (Time.now.to_i + ttl),
+            version: TASK_ROUTER_VERSION,
+            friendly_name: @channel_id,
+            policies: @policies,
+        }
+        extraAttributes.each { |key, value|
+          payload[key] = value
         }
 
         JWT.encode payload, @auth_token
       end
 
-      protected
+      def setup_resource
+        if(@channel_id[0..1] == 'WS')
+          @resourceUrl = @baseUrl
+        elsif(@channel_id[0..1] == 'WK')
+          @resourceUrl = @baseUrl + "/Workers/" + @channel_id
 
-      def allow_websocket_requests
-        worker_url = "#{TASK_ROUTER_WEBSOCKET_BASE_URL}/#{@account_sid}/#{@worker_sid}"
+          @activityUrl = @baseUrl + "/Activities"
+          allow(@activityUrl, "GET")
+
+          @reservationsUrl = @baseUrl + "/Tasks/**"
+          allow(@reservationsUrl, "GET")
+
+        elsif(@channel_id[0..1] == 'WQ')
+          @resourceUrl = @baseUrl + "/TaskQueues/" + @channel_id
+        end
+      end
+
+      def allow_websocket_requests(channel_id)
+        worker_url = "#{TASK_ROUTER_WEBSOCKET_BASE_URL}/#{@account_sid}/#{channel_id}"
         ['GET', 'POST'].each do |meth|
           add_policy(worker_url, meth)
         end
       end
 
-      def allow_activity_list_fetch
-        url = "#{workspace_url}/Activities"
-        add_policy(url, 'GET')
+      def validate_jwt
+        if(@account_sid.nil? or @account_sid[0..1] != 'AC')
+          raise "Invalid AccountSid provided #{@account_sid}"
+        end
+        if(@workspace_sid.nil? or @workspace_sid[0..1] != 'WS')
+          raise "Invalid WorkspaceSid provided #{@workspace_sid}"
+        end
+        if(@channel_id.nil?)
+          raise "ChannelId not provided"
+        end
+        @prefix = @channel_id[0..1]
+        if(@prefix != 'WS' and @prefix != 'WK' and @prefix != 'WQ')
+          raise "Invalid ChannelId provided: #{@channel_id}"
+        end
+      end
+    end
+    class WorkerCapability < Capability
+
+      def initialize(account_sid, auth_token, workspace_sid, worker_sid)
+        super(account_sid, auth_token, workspace_sid, worker_sid)
+        @reservationsUrl = @baseUrl + "/Tasks/**"
+        @activityUrl = @baseUrl + "/Activities"
+
+        allow(@activityUrl, "GET")
+        allow(@reservationsUrl, "GET")
+      end
+
+      def allow_activity_updates
+        allow(@resourceUrl, "POST", nil, {ActivitySid: REQUIRED})
+      end
+
+      def allow_reservation_updates
+        allow(@reservationsUrl, "POST", nil, nil)
+      end
+
+      protected
+
+      def setup_resource
+        @resourceUrl = @baseUrl + "/Workers/" + @channel_id
       end
 
     end
+
+    class WorkspaceCapability < Capability
+
+      def initialize(account_sid, auth_token, workspace_sid)
+        super(account_sid, auth_token, workspace_sid, workspace_sid)
+      end
+
+      protected
+
+      def setup_resource
+        @resourceUrl = @baseUrl
+      end
+
+    end
+
+    class TaskQueueCapability < Capability
+
+      def initialize(account_sid, auth_token, workspace_sid, taskqueue_sid)
+        super(account_sid, auth_token, workspace_sid, taskqueue_sid)
+      end
+
+      protected
+
+      def setup_resource
+        @resourceUrl = @baseUrl + "/TaskQueues/" + @channel_id
+      end
+    end
   end
 end

data/lib/twilio-ruby/version.rb

@@ -1,3 +1,3 @@
 module Twilio
-  VERSION = '4.2.1'
+  VERSION = '4.3.0'
 end

data/spec/task_router_deprecated_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe Twilio::TaskRouter::Capability do
+  describe 'with a deprecated capability' do
+    before :each do
+      @capability = Twilio::TaskRouter::Capability.new 'AC123', 'foobar', 'WS456', 'WK789'
+    end
+
+    it 'should return a valid jwt when #generate_token is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies']).not_to be_nil
+      expect(decoded['iss']).not_to be_nil
+      expect(decoded['exp']).not_to be_nil
+      expect(decoded['account_sid']).to eq('AC123')
+      expect(decoded['workspace_sid']).to eq('WS456')
+      expect(decoded['worker_sid']).to eq('WK789')
+      expect(decoded['channel']).to eq('WK789')
+    end
+
+    it 'should properly set the iss key in the payload' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['iss']).to eq('AC123')
+    end
+
+    it 'should properly set exp based on the default 1-hour ttl' do
+      seconds = Time.now.to_i
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['exp']).to eq(seconds + 3600)
+    end
+
+    it 'should properly set exp based on the ttl arg to #generate_token' do
+      seconds = Time.now.to_i
+      ttl = rand 10000
+      token = @capability.generate_token ttl
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['exp']).to eq(seconds + ttl)
+    end
+
+    it 'should allow websocket operations and fetching the workspace by default' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies'].size).to eq(5)
+
+      activites_fetch_policy = {
+          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Activities',
+          'method' => 'GET',
+          'query_filter' => {},
+          'post_filter' => {},
+          'allow' => true
+      }
+      expect(decoded['policies'][0]).to eq(activites_fetch_policy)
+
+      reservation_fetch_policy = {
+          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Tasks/**',
+          'method' => 'GET',
+          'query_filter' => {},
+          'post_filter' => {},
+          'allow' => true
+      }
+      expect(decoded['policies'][1]).to eq(reservation_fetch_policy)
+
+      get_policy = {
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WK789',
+        "method" => 'GET',
+        "query_filter" => {},
+        "post_filter" => {},
+        "allow" => true
+      }
+      expect(decoded['policies'][2]).to eq(get_policy)
+      post_policy = {
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WK789',
+        "method" => 'POST',
+        "query_filter" => {},
+        "post_filter" => {},
+        "allow" => true
+      }
+      expect(decoded['policies'][3]).to eq(post_policy)
+
+      worker_fetch_policy = {
+          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Workers/WK789',
+          'method' => 'GET',
+          'query_filter' => {},
+          'post_filter' => {},
+          'allow' => true
+      }
+      expect(decoded['policies'][4]).to eq(worker_fetch_policy)
+    end
+
+    it 'should add a policy when #allow_worker_activity_updates is called' do
+    	token = @capability.generate_token
+    	decoded, header = JWT.decode token, 'foobar'
+    	policies_size = decoded['policies'].size
+
+      @capability.allow_worker_activity_updates
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      activity_policy = {
+          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Workers/WK789',
+          'method' => 'POST',
+          'query_filter' => {},
+          'post_filter' => {'ActivitySid' => {'required' => true}},
+          'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(activity_policy)
+      expect(decoded['policies'].size).to eq(policies_size+1)
+    end
+
+    it 'should add a policy when #allow_task_reservation_updates is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      policies_size = decoded['policies'].size
+
+      @capability.allow_task_reservation_updates
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      reservation_policy = {
+          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Tasks/**',
+          'method' => 'POST',
+          'query_filter' => {},
+          'post_filter' => {},
+          'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(reservation_policy)
+      expect(decoded['policies'].size).to eq(policies_size+1)
+    end
+  end
+end

data/spec/task_router_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Twilio::TaskRouter::Capability do
   describe 'with a capability' do
     before :each do
-      @capability = Twilio::TaskRouter::Capability.new 'AC123', 'foobar', 'WS456', 'WK789'
+      @capability = Twilio::TaskRouter::Capability.new 'AC123', 'foobar', 'WS456', 'WS456'
     end
 
     it 'should return a valid jwt when #generate_token is called' do
@@ -12,6 +12,9 @@ describe Twilio::TaskRouter::Capability do
       expect(decoded['policies']).not_to be_nil
       expect(decoded['iss']).not_to be_nil
       expect(decoded['exp']).not_to be_nil
+      expect(decoded['account_sid']).to eq('AC123')
+      expect(decoded['workspace_sid']).to eq('WS456')
+      expect(decoded['channel']).to eq('WS456')
     end
 
     it 'should properly set the iss key in the payload' do
@@ -35,12 +38,12 @@ describe Twilio::TaskRouter::Capability do
       expect(decoded['exp']).to eq(seconds + ttl)
     end
 
-    it 'should allow websocket operations and activity list fetches by default' do
+    it 'should allow websocket operations and fetching the workspace by default' do
       token = @capability.generate_token
       decoded, header = JWT.decode token, 'foobar'
       expect(decoded['policies'].size).to eq(3)
       get_policy = {
-        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WK789',
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WS456',
         "method" => 'GET',
         "query_filter" => {},
         "post_filter" => {},
@@ -48,7 +51,7 @@ describe Twilio::TaskRouter::Capability do
       }
       expect(decoded['policies'][0]).to eq(get_policy)
       post_policy = {
-        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WK789',
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WS456',
         "method" => 'POST',
         "query_filter" => {},
         "post_filter" => {},
@@ -56,59 +59,52 @@ describe Twilio::TaskRouter::Capability do
       }
       expect(decoded['policies'][1]).to eq(post_policy)
 
-      activities_policy = {
-        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Activities',
-        'method' => 'GET',
-        'query_filter' => {},
-        'post_filter' => {},
-        'allow' => true
+      workspace_fetch_policy = {
+          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456',
+          'method' => 'GET',
+          'query_filter' => {},
+          'post_filter' => {},
+          'allow' => true
       }
-      expect(decoded['policies'][2]).to eq(activities_policy)
+      expect(decoded['policies'][2]).to eq(workspace_fetch_policy)
     end
 
-    it 'should add a policy when #allow_worker_activity_updates is called' do
-      @capability.allow_worker_activity_updates
+    it 'should add a policy when #allow_fetch_subresources is called' do
       token = @capability.generate_token
       decoded, header = JWT.decode token, 'foobar'
-      expect(decoded['policies'].size).to eq(4)
-      activity_policy = {
-        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Workers/WK789',
-        'method' => 'POST',
-        'query_filter' => {},
-        'post_filter' => {'ActivitySid' => {'required' => true}},
-        'allow' => true
-      }
-      expect(decoded['policies'][-1]).to eq(activity_policy)
-    end
+      policies_size = decoded['policies'].size
 
-    it 'should add a policy when #allow_worker_fetch_attributes is called' do
-      @capability.allow_worker_fetch_attributes
+      @capability.allow_fetch_subresources
       token = @capability.generate_token
       decoded, header = JWT.decode token, 'foobar'
-      expect(decoded['policies'].size).to eq(4)
-      worker_policy = {
-        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Workers/WK789',
+      workspace_fetch_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/**',
         'method' => 'GET',
         'query_filter' => {},
         'post_filter' => {},
         'allow' => true
       }
-      expect(decoded['policies'][-1]).to eq(worker_policy)
+      expect(decoded['policies'][-1]).to eq(workspace_fetch_policy)
+      expect(decoded['policies'].size).to eq(policies_size+1)
     end
 
-    it 'should add a policy when #allow_task_reservation_updates is called' do
-      @capability.allow_task_reservation_updates
+    it 'should add a policy when #allow_update_subresources is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      policies_size = decoded['policies'].size
+
+      @capability.allow_updates_subresources
       token = @capability.generate_token
       decoded, header = JWT.decode token, 'foobar'
-      expect(decoded['policies'].size).to eq(4)
-      task_policy = {
-        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Tasks/**',
+      workspace_update_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/**',
         'method' => 'POST',
         'query_filter' => {},
-        'post_filter' => {'ReservationStatus' => {'required' => true}},
+        'post_filter' => {},
         'allow' => true
       }
-      expect(decoded['policies'][-1]).to eq(task_policy)
+      expect(decoded['policies'][-1]).to eq(workspace_update_policy)
+      expect(decoded['policies'].size).to eq(policies_size+1)
     end
   end
 end

data/spec/task_router_taskqueue_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Twilio::TaskRouter::Capability do
+  describe 'with a capability' do
+    before :each do
+      @capability = Twilio::TaskRouter::TaskQueueCapability.new 'AC123', 'foobar', 'WS456', 'WQ789'
+    end
+
+    it 'should return a valid jwt when #generate_token is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies']).not_to be_nil
+      expect(decoded['iss']).not_to be_nil
+      expect(decoded['exp']).not_to be_nil
+      expect(decoded['account_sid']).to eq('AC123')
+      expect(decoded['workspace_sid']).to eq('WS456')
+      expect(decoded['taskqueue_sid']).to eq('WQ789')
+      expect(decoded['channel']).to eq('WQ789')
+    end
+
+    it 'should properly set the iss key in the payload' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['iss']).to eq('AC123')
+    end
+
+    it 'should properly set exp based on the default 1-hour ttl' do
+      seconds = Time.now.to_i
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['exp']).to eq(seconds + 3600)
+    end
+
+    it 'should properly set exp based on the ttl arg to #generate_token' do
+      seconds = Time.now.to_i
+      ttl = rand 10000
+      token = @capability.generate_token ttl
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['exp']).to eq(seconds + ttl)
+    end
+
+    it 'should allow websocket operations and fetching the workspace by default' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies'].size).to eq(3)
+      get_policy = {
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WQ789',
+        "method" => 'GET',
+        "query_filter" => {},
+        "post_filter" => {},
+        "allow" => true
+      }
+      expect(decoded['policies'][0]).to eq(get_policy)
+      post_policy = {
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WQ789',
+        "method" => 'POST',
+        "query_filter" => {},
+        "post_filter" => {},
+        "allow" => true
+      }
+      expect(decoded['policies'][1]).to eq(post_policy)
+
+      taskqueue_fetch_policy = {
+          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/TaskQueues/WQ789',
+          'method' => 'GET',
+          'query_filter' => {},
+          'post_filter' => {},
+          'allow' => true
+      }
+      expect(decoded['policies'][2]).to eq(taskqueue_fetch_policy)
+    end
+
+    it 'should add a policy when #allow_fetch_subresources is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      policies_size = decoded['policies'].size
+
+      @capability.allow_fetch_subresources
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      taskqueue_fetch_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/TaskQueues/WQ789/**',
+        'method' => 'GET',
+        'query_filter' => {},
+        'post_filter' => {},
+        'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(taskqueue_fetch_policy)
+      expect(decoded['policies'].size).to eq(policies_size+1)
+    end
+
+    it 'should add a policy when #allow_update_subresources is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      policies_size = decoded['policies'].size
+
+      @capability.allow_updates_subresources
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      taskqueue_update_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/TaskQueues/WQ789/**',
+        'method' => 'POST',
+        'query_filter' => {},
+        'post_filter' => {},
+        'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(taskqueue_update_policy)
+      expect(decoded['policies'].size).to eq(policies_size+1)
+    end
+  end
+end

data/spec/task_router_worker_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Twilio::TaskRouter::WorkerCapability do
+  describe 'with a capability' do
+    before :each do
+      @capability = Twilio::TaskRouter::WorkerCapability.new 'AC123', 'foobar', 'WS456', 'WK789'
+    end
+
+    it 'should return a valid jwt when #generate_token is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies']).not_to be_nil
+      expect(decoded['iss']).not_to be_nil
+      expect(decoded['exp']).not_to be_nil
+      expect(decoded['account_sid']).to eq('AC123')
+      expect(decoded['workspace_sid']).to eq('WS456')
+      expect(decoded['worker_sid']).to eq('WK789')
+      expect(decoded['channel']).to eq('WK789')
+    end
+
+    it 'should properly set the iss key in the payload' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['iss']).to eq('AC123')
+    end
+
+    it 'should properly set exp based on the default 1-hour ttl' do
+      seconds = Time.now.to_i
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['exp']).to eq(seconds + 3600)
+    end
+
+    it 'should properly set exp based on the ttl arg to #generate_token' do
+      seconds = Time.now.to_i
+      ttl = rand 10000
+      token = @capability.generate_token ttl
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['exp']).to eq(seconds + ttl)
+    end
+
+    it 'should allow websocket operations and activity list fetches by default' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies'].size).to eq(5)
+      get_policy = {
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WK789',
+        "method" => 'GET',
+        "query_filter" => {},
+        "post_filter" => {},
+        "allow" => true
+      }
+      expect(decoded['policies'][0]).to eq(get_policy)
+      post_policy = {
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WK789',
+        "method" => 'POST',
+        "query_filter" => {},
+        "post_filter" => {},
+        "allow" => true
+      }
+      expect(decoded['policies'][1]).to eq(post_policy)
+
+      worker_fetch_policy = {
+          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Workers/WK789',
+          'method' => 'GET',
+          'query_filter' => {},
+          'post_filter' => {},
+          'allow' => true
+      }
+      expect(decoded['policies'][2]).to eq(worker_fetch_policy)
+
+      activities_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Activities',
+        'method' => 'GET',
+        'query_filter' => {},
+        'post_filter' => {},
+        'allow' => true
+      }
+      expect(decoded['policies'][3]).to eq(activities_policy)
+
+      reservations_policy = {
+          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Tasks/**',
+          'method' => 'GET',
+          'query_filter' => {},
+          'post_filter' => {},
+          'allow' => true
+      }
+      expect(decoded['policies'][4]).to eq(reservations_policy)
+    end
+
+    it 'should add a policy when #allow_activity_updates is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      policies_size = decoded['policies'].size
+
+      @capability.allow_activity_updates
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      activity_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Workers/WK789',
+        'method' => 'POST',
+        'query_filter' => {},
+        'post_filter' => {'ActivitySid' => {'required' => true}},
+        'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(activity_policy)
+      expect(decoded['policies'].size).to eq(policies_size+1)
+    end
+
+    it 'should add a policy when #allow_reservation_updates is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      policies_size = decoded['policies'].size
+
+      @capability.allow_reservation_updates
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      reservation_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Tasks/**',
+        'method' => 'POST',
+        'query_filter' => {},
+        'post_filter' => {},
+        'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(reservation_policy)
+      expect(decoded['policies'].size).to eq(policies_size+1)
+    end
+  end
+end

data/spec/task_router_workspace_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Twilio::TaskRouter::Capability do
+  describe 'with a capability' do
+    before :each do
+      @capability = Twilio::TaskRouter::WorkspaceCapability.new 'AC123', 'foobar', 'WS456'
+    end
+
+    it 'should return a valid jwt when #generate_token is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies']).not_to be_nil
+      expect(decoded['iss']).not_to be_nil
+      expect(decoded['exp']).not_to be_nil
+      expect(decoded['account_sid']).to eq('AC123')
+      expect(decoded['workspace_sid']).to eq('WS456')
+      expect(decoded['channel']).to eq('WS456')
+    end
+
+    it 'should properly set the iss key in the payload' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['iss']).to eq('AC123')
+    end
+
+    it 'should properly set exp based on the default 1-hour ttl' do
+      seconds = Time.now.to_i
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['exp']).to eq(seconds + 3600)
+    end
+
+    it 'should properly set exp based on the ttl arg to #generate_token' do
+      seconds = Time.now.to_i
+      ttl = rand 10000
+      token = @capability.generate_token ttl
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['exp']).to eq(seconds + ttl)
+    end
+
+    it 'should allow websocket operations and fetching the workspace by default' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies'].size).to eq(3)
+      get_policy = {
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WS456',
+        "method" => 'GET',
+        "query_filter" => {},
+        "post_filter" => {},
+        "allow" => true
+      }
+      expect(decoded['policies'][0]).to eq(get_policy)
+      post_policy = {
+        "url" => 'https://event-bridge.twilio.com/v1/wschannels/AC123/WS456',
+        "method" => 'POST',
+        "query_filter" => {},
+        "post_filter" => {},
+        "allow" => true
+      }
+      expect(decoded['policies'][1]).to eq(post_policy)
+
+      workspace_fetch_policy = {
+          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456',
+          'method' => 'GET',
+          'query_filter' => {},
+          'post_filter' => {},
+          'allow' => true
+      }
+      expect(decoded['policies'][2]).to eq(workspace_fetch_policy)
+    end
+
+    it 'should add a policy when #allow_fetch_subresources is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      policies_size = decoded['policies'].size
+
+      @capability.allow_fetch_subresources
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      workspace_fetch_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/**',
+        'method' => 'GET',
+        'query_filter' => {},
+        'post_filter' => {},
+        'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(workspace_fetch_policy)
+      expect(decoded['policies'].size).to eq(policies_size+1)
+    end
+
+    it 'should add a policy when #allow_update_subresources is called' do
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      policies_size = decoded['policies'].size
+
+      @capability.allow_updates_subresources
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      workspace_update_policy = {
+        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/**',
+        'method' => 'POST',
+        'query_filter' => {},
+        'post_filter' => {},
+        'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(workspace_update_policy)
+      expect(decoded['policies'].size).to eq(policies_size+1)
+    end
+  end
+end

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: twilio-ruby
 version: !ruby/object:Gem::Version
-  version: 4.2.1
+  version: 4.3.0
 platform: ruby
 authors:
 - Andrew Benton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-19 00:00:00.000000000 Z
+date: 2015-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.3.0
 - !ruby/object:Gem::Dependency
   name: builder
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.1.2
 - !ruby/object:Gem::Dependency
   name: jwt
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.5'
 description: A simple library for communicating with the Twilio REST API, building
@@ -76,8 +76,8 @@ extra_rdoc_files:
 - README.md
 - LICENSE.md
 files:
-- ".gitignore"
-- ".travis.yml"
+- .gitignore
+- .travis.yml
 - AUTHORS.md
 - CHANGES.md
 - Gemfile
@@ -241,7 +241,11 @@ files:
 - spec/rest/utils_spec.rb
 - spec/spec_helper.rb
 - spec/support/fakeweb.rb
+- spec/task_router_deprecated_spec.rb
 - spec/task_router_spec.rb
+- spec/task_router_taskqueue_spec.rb
+- spec/task_router_worker_spec.rb
+- spec/task_router_workspace_spec.rb
 - spec/twilio_spec.rb
 - spec/util/capability_spec.rb
 - spec/util/client_config_spec.rb
@@ -255,27 +259,27 @@ licenses:
 metadata: {}
 post_install_message: 
 rdoc_options:
-- "--line-numbers"
-- "--inline-source"
-- "--title"
+- --line-numbers
+- --inline-source
+- --title
 - twilio-ruby
-- "--main"
+- --main
 - README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: A simple library for communicating with the Twilio REST API, building TwiML,
@@ -306,7 +310,11 @@ test_files:
 - spec/rest/utils_spec.rb
 - spec/spec_helper.rb
 - spec/support/fakeweb.rb
+- spec/task_router_deprecated_spec.rb
 - spec/task_router_spec.rb
+- spec/task_router_taskqueue_spec.rb
+- spec/task_router_worker_spec.rb
+- spec/task_router_workspace_spec.rb
 - spec/twilio_spec.rb
 - spec/util/capability_spec.rb
 - spec/util/client_config_spec.rb