twilio-ruby 4.13.0 → 5.6.4

data/spec/task_router_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::TaskRouter::Capability do
-  describe 'with a capability' do
-    before :each do
-      @capability = Twilio::TaskRouter::Capability.new 'AC123', 'foobar', 'WS456', '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

data/spec/task_router_taskqueue_spec.rb

@@ -1,111 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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(6)
-      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)
-
-      tasks_policy = {
-          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Tasks/**',
-          'method' => 'GET',
-          'query_filter' => {},
-          'post_filter' => {},
-          'allow' => true
-      }
-      expect(decoded['policies'][4]).to eq(tasks_policy)
-
-      worker_reservations_policy = {
-          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Workers/WK789/Reservations/**',
-          'method' => 'GET',
-          'query_filter' => {},
-          'post_filter' => {},
-          'allow' => true
-      }
-      expect(decoded['policies'][5]).to eq(worker_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 two policies 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'
-      tasks_policy = {
-        'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Tasks/**',
-        'method' => 'POST',
-        'query_filter' => {},
-        'post_filter' => {},
-        'allow' => true
-      }
-      expect(decoded['policies'][-2]).to eq(tasks_policy)
-      worker_reservations_policy = {
-          'url' => 'https://taskrouter.twilio.com/v1/Workspaces/WS456/Workers/WK789/Reservations/**',
-          'method' => 'POST',
-          'query_filter' => {},
-          'post_filter' => {},
-          'allow' => true
-      }
-      expect(decoded['policies'][-1]).to eq(worker_reservations_policy)
-      expect(decoded['policies'].size).to eq(policies_size+2)
-    end
-  end
-end

data/spec/task_router_workspace_spec.rb

@@ -1,110 +0,0 @@
-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

data/spec/util/access_token_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper'
-
-describe Twilio::Util::AccessToken do
-
-  it 'should generate a token for no grants' do
-    scat = Twilio::Util::AccessToken.new 'AC123', 'SK123','secret'
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['nbf']).to be_nil
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(0)
-  end
-
-  it 'should generate a nbf' do
-    now = Time.now.to_i - 1
-    scat = Twilio::Util::AccessToken.new 'AC123', 'SK123','secret'
-    scat.identity = 'abc'
-    scat.nbf = now
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['nbf']).not_to be_nil
-    expect(payload['nbf']).to eq(now)
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(1)
-    expect(payload['grants']['identity']).to eq('abc')
-  end
-
-  it 'should be able to add conversation grant' do
-    scat = Twilio::Util::AccessToken.new 'AC123', 'SK123','secret'
-    scat.add_grant(Twilio::Util::AccessToken::ConversationsGrant.new)
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(1)
-    expect(payload['grants']['rtc']).not_to be_nil
-  end
-
-  it 'should be able to add endpoint grants' do
-    scat = Twilio::Util::AccessToken.new 'AC123', 'SK123','secret'
-
-    grant = Twilio::Util::AccessToken::IpMessagingGrant.new
-    grant.push_credential_sid = 'CR123'
-    grant.deployment_role_sid = 'DR123'
-    grant.service_sid = 'IS123'
-    grant.endpoint_id = 'EP123'
-    scat.add_grant(grant)   
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(1)
-    expect(payload['grants']['ip_messaging']).not_to be_nil
-    expect(payload['grants']['ip_messaging']['service_sid']).to eq('IS123')
-    expect(payload['grants']['ip_messaging']['endpoint_id']).to eq('EP123')
-    expect(payload['grants']['ip_messaging']['push_credential_sid']).to eq('CR123')
-    expect(payload['grants']['ip_messaging']['deployment_role_sid']).to eq('DR123')
-  end
-
-  it 'should add rest grants' do
-    scat = Twilio::Util::AccessToken.new 'AC123', 'SK123','secret'
-    scat.add_grant(Twilio::Util::AccessToken::ConversationsGrant.new)
-    scat.add_grant(Twilio::Util::AccessToken::IpMessagingGrant.new)
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(2)
-    expect(payload['grants']['rtc']).not_to be_nil
-    expect(payload['grants']['ip_messaging']).not_to be_nil
-  end
-
-  it 'should add programmable voice grant' do
-    scat = Twilio::Util::AccessToken.new 'AC123', 'SK123','secret'
-    pvg = Twilio::Util::AccessToken::VoiceGrant.new
-    pvg.outgoing_application_sid = 'AP123'
-    pvg.outgoing_application_params = { :foo => 'bar' }
-
-    scat.add_grant(pvg)
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(1)
-    expect(payload['grants']['voice']).not_to be_nil
-    expect(payload['grants']['voice']['outgoing']['application_sid']).to eq('AP123')
-    expect(payload['grants']['voice']['outgoing']['params']['foo']).to eq('bar')
-  end
-
-  it 'should add video grant' do
-    scat = Twilio::Util::AccessToken.new 'AC123', 'SK123','secret'
-    vg = Twilio::Util::AccessToken::VideoGrant.new
-    vg.configuration_profile_sid = 'CP123'
-
-    scat.add_grant(vg)
-
-    token = scat.to_s
-    expect(token).not_to be_nil
-    payload, header = JWT.decode token, 'secret'
-
-    expect(payload['iss']).to eq('SK123')
-    expect(payload['sub']).to eq('AC123')
-    expect(payload['exp']).not_to be_nil
-    expect(payload['exp']).to be >= Time.now.to_i
-    expect(payload['jti']).not_to be_nil
-    expect(payload['jti']).to start_with payload['iss']
-    expect(payload['grants']).not_to be_nil
-    expect(payload['grants'].count).to eq(1)
-    expect(payload['grants']['video']).not_to be_nil
-    expect(payload['grants']['video']['configuration_profile_sid']).to eq('CP123')
-  end
-end