restcomm-ruby 1.2.0

data/spec/rest/sms/message_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Restcomm::REST::SMS::Message do
+
+  before do
+    client = double("Client")
+    allow(client).to receive(:post) do 
+      {'sid' => 'qwerty' } 
+    end
+
+    allow(client).to receive(:get) do 
+      {'sid' => 'qwerty', 'sms_message' => [] } 
+    end
+    
+    allow(client).to receive(:delete) do 
+      {'sid' => 'qwerty' } 
+    end
+
+    @message = Restcomm::REST::SMS::Message.new('someUri',client)
+  end
+ 
+  it 'should warn of deprecation of SMS Message Update' do
+    expect(@message).to receive(:warn)
+    @message.update
+  end
+
+  it 'should warn of deprecation of SMS Message Refresh' do
+    expect(@message).to receive(:warn)
+    @message.refresh
+  end
+
+  it 'should warn of deprecation of SMS Message Delete' do
+    expect(@message).to receive(:warn)
+    @message.delete
+  end
+
+end

data/spec/rest/sms/messages_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Restcomm::REST::SMS::Messages do
+
+  before do
+    client = double("Client")
+    allow(client).to receive(:post) do 
+      {'sid' => 'qwerty' } 
+    end
+
+    allow(client).to receive(:get) do 
+      {'sid' => 'qwerty', 'sms_messages' => [] } 
+    end
+    @messages = Restcomm::REST::SMS::Messages.new('someUri',client)
+  end
+
+  it 'should warn of deprecation of SMS Messages Create' do
+    expect(@messages).to receive(:warn)
+    @messages.create to: "+1", from: "+2", body: "But Jenny!"
+  end  
+
+  it 'should warn of deprecation of SMS Messages List' do
+    expect(@messages).to receive(:warn)
+    @messages.list to: "+1"
+  end  
+  
+  it 'should warn of deprecation of SMS Messages Get' do
+    expect(@messages).to receive(:warn)
+    @messages.get sid: "qwerty"
+  end  
+
+  it 'should warn of deprecation of SMS Messages total' do
+    expect(@messages).to receive(:warn)
+    @messages.total
+  end  
+end

data/spec/rest/task_router/reservation_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Restcomm::REST::TaskRouter::Reservations do
+  it 'creates a reservation object' do
+    task = Restcomm::REST::TaskRouter::Task.new('someUri', 'someClient')
+    expect(task).to respond_to(:reservations)
+    expect(task.reservations.instance_variable_get('@path')).to eq('someUri/Reservations')
+  end
+end

data/spec/rest/task_router/task_queue_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Restcomm::REST::TaskRouter::TaskQueues do
+  it 'creates a task queue object' do
+    workspace = Restcomm::REST::TaskRouter::Workspace.new('someUri', 'someClient')
+    expect(workspace).to respond_to(:task_queues)
+    expect(workspace.task_queues.instance_variable_get('@path')).to eq('someUri/TaskQueues')
+  end
+end

data/spec/rest/token_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Restcomm::REST::Token do
+  before do
+    @token = Restcomm::REST::Token.new('someUri', 'someClient')
+  end
+end

data/spec/rest/utils_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+class UtilClass
+  include Restcomm::REST::Utils
+end
+
+describe UtilClass do
+  subject(:util) { UtilClass.new }
+
+  it 'should convert a parameter name to a Restcomm-style name' do
+    expect(util.restify('sms_url')).to eq('SmsUrl')
+  end
+
+  it 'should convert all parameter names to Restcomm-style names' do
+    unrestified = {
+      :sms_url => 'someUrl',
+      'voiceFallbackUrl' => 'anotherUrl',
+      'Status_callback' => 'yetAnotherUrl'
+    }
+    restified = {
+      :SmsUrl => 'someUrl',
+      :VoiceFallbackUrl => 'anotherUrl',
+      :StatusCallback => 'yetAnotherUrl'
+    }
+    expect(util.restify(unrestified)).to eq(restified)
+  end
+
+  it 'should convert a Restcomm-style name to a parameter name' do
+    expect(util.derestify('SmsUrl')).to eq('sms_url')
+  end
+
+  it 'should convert all Restcomm-style names to parameter names' do
+    unrestified = {
+      :sms_url => 'someUrl',
+      :voice_fallback_url => 'anotherUrl',
+      :status_callback => 'yetAnotherUrl'
+    }
+    restified = {
+      :SmsUrl => 'someUrl',
+      :VoiceFallbackUrl => 'anotherUrl',
+      :StatusCallback => 'yetAnotherUrl'
+    }
+    expect(util.derestify(restified)).to eq(unrestified)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'bundler'
+Bundler.setup
+
+Dir.glob(File.expand_path("../support/**/*.rb", __FILE__), &method(:require))
+
+require 'restcomm-ruby'
+require 'rack'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/support/fakeweb.rb

@@ -0,0 +1,2 @@
+require 'fakeweb'
+FakeWeb.allow_net_connect = false

data/spec/task_router_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Restcomm::TaskRouter::Capability do
+  describe 'with a capability' do
+    before :each do
+      @capability = Restcomm::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
+    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(3)
+      get_policy = {
+        "url" => 'https://event-bridge.restcomm.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.restcomm.com/v1/wschannels/AC123/WK789',
+        "method" => 'POST',
+        "query_filter" => {},
+        "post_filter" => {},
+        "allow" => true
+      }
+      expect(decoded['policies'][1]).to eq(post_policy)
+
+      activities_policy = {
+        'url' => 'https://taskrouter.restcomm.com/v1/Workspaces/WS456/Activities',
+        'method' => 'GET',
+        'query_filter' => {},
+        'post_filter' => {},
+        'allow' => true
+      }
+      expect(decoded['policies'][2]).to eq(activities_policy)
+    end
+
+    it 'should add a policy when #allow_worker_activity_updates is called' do
+      @capability.allow_worker_activity_updates
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies'].size).to eq(4)
+      activity_policy = {
+        'url' => 'https://taskrouter.restcomm.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
+
+    it 'should add a policy when #allow_worker_fetch_attributes is called' do
+      @capability.allow_worker_fetch_attributes
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies'].size).to eq(4)
+      worker_policy = {
+        'url' => 'https://taskrouter.restcomm.com/v1/Workspaces/WS456/Workers/WK789',
+        'method' => 'GET',
+        'query_filter' => {},
+        'post_filter' => {},
+        'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(worker_policy)
+    end
+
+    it 'should add a policy when #allow_task_reservation_updates is called' do
+      @capability.allow_task_reservation_updates
+      token = @capability.generate_token
+      decoded, header = JWT.decode token, 'foobar'
+      expect(decoded['policies'].size).to eq(4)
+      task_policy = {
+        'url' => 'https://taskrouter.restcomm.com/v1/Workspaces/WS456/Tasks/**',
+        'method' => 'POST',
+        'query_filter' => {},
+        'post_filter' => {'ReservationStatus' => {'required' => true}},
+        'allow' => true
+      }
+      expect(decoded['policies'][-1]).to eq(task_policy)
+    end
+  end
+end

data/spec/twilio_spec.rb

@@ -0,0 +1,15 @@
+describe Restcomm do
+  after(:each) do
+    Restcomm.instance_variable_set('@configuration', nil)
+  end
+
+  it 'should set the account sid and auth token with a config block' do
+    Restcomm.configure do |config|
+      config.account_sid = 'someSid'
+      config.auth_token = 'someToken'
+    end
+
+    expect(Restcomm.account_sid).to eq('someSid')
+    expect(Restcomm.auth_token).to eq('someToken')
+  end
+end

data/spec/util/capability_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe Restcomm::Util::Capability do
+  describe 'config' do
+    after(:each) do
+      Restcomm.instance_variable_set('@configuration', nil)
+    end
+
+    it 'should set the account sid and auth token from a configuration block' do
+      Restcomm.configure do |config|
+        config.account_sid = 'someSid'
+        config.auth_token = 'someToken'
+      end
+
+      capability = Restcomm::Util::Capability.new
+      expect(capability.instance_variable_get('@account_sid')).to eq('someSid')
+      expect(capability.instance_variable_get('@auth_token')).to eq('someToken')
+    end
+
+    it 'should overwrite account sid and auth token if passed to initializer' do
+      Restcomm.configure do |config|
+        config.account_sid = 'someSid'
+        config.auth_token = 'someToken'
+      end
+
+      capability = Restcomm::Util::Capability.new'otherSid', 'otherToken'
+      expect(capability.instance_variable_get('@account_sid')).to eq('otherSid')
+      expect(capability.instance_variable_get('@auth_token')).to eq('otherToken')
+    end
+
+    it 'should overwrite the account sid if only the sid is given' do
+      Restcomm.configure do |config|
+        config.account_sid = 'someSid'
+        config.auth_token = 'someToken'
+      end
+
+      capability = Restcomm::Util::Capability.new 'otherSid'
+      expect(capability.instance_variable_get('@account_sid')).to eq('otherSid')
+      expect(capability.instance_variable_get('@auth_token')).to eq('someToken')
+    end
+
+    it 'should throw an argument error if the sid and token isn\'t set' do
+      expect { Restcomm::Util::Capability.new }.to raise_error(ArgumentError)
+    end
+
+    it 'should throw an argument error if only the account_sid is set' do
+      expect { Restcomm::Util::Capability.new 'someSid' }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe 'with a capability' do
+    before :each do
+      @capability = Restcomm::Util::Capability.new 'myAccountSid', 'myAuthToken'
+    end
+
+    def queries(q)
+      q.scan(/scope:client:(incoming|outgoing)\?(\S+)/).map{|(type, query)| [type, Rack::Utils.parse_query(query)]}
+    end
+
+    it 'should return a valid jwt when #generate is called' do
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(decoded['scope']).not_to be_nil
+      expect(decoded['iss']).not_to be_nil
+      expect(decoded['exp']).not_to be_nil
+    end
+
+    it 'should properly set the iss key in the payload' do
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(decoded['iss']).to eq('myAccountSid')
+    end
+
+    it 'should properly set the exp key based on the default hour ttl' do
+      seconds = Time.now.to_i
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(decoded['exp']).to eq(seconds + 3600)
+    end
+
+    it 'should properly set the exp key based on the ttl passed to #generate' do
+      ttl = rand 10000
+      seconds = Time.now.to_i
+      token = @capability.generate ttl
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(decoded['exp']).to eq(seconds + ttl)
+    end
+
+    it 'should generate a proper incoming client scope string' do
+      @capability.allow_client_incoming 'andrew'
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([['incoming', {'clientName' => 'andrew'}]])
+    end
+
+    it 'should generate multiple proper incoming client scope strings' do
+      @capability.allow_client_incoming 'andrew'
+      @capability.allow_client_incoming 'bridget'
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([
+        ['incoming', {'clientName' => 'andrew'}],
+        ['incoming', {'clientName' => 'bridget'}]
+      ])
+    end
+
+    it 'should generate a proper outgoing client scope string' do
+      @capability.allow_client_outgoing 'myAppSid'
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([['outgoing', {'appSid' => 'myAppSid'}]])
+    end
+
+    it 'should generate a proper outgoing client scope string with parameters' do
+      app_params_hash = {'key' => 'a value', :foo => 'bar/baz'}
+      @capability.allow_client_outgoing 'myAppSid', app_params_hash
+      app_params = @capability.instance_eval {url_encode(app_params_hash)}
+      params_hash = {'appSid' => 'myAppSid', 'appParams' => app_params}
+      @capability.instance_eval {url_encode(params_hash)}
+      token = @capability.generate
+      decoded, header= JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([['outgoing', params_hash]])
+    end
+
+    it 'should generate a proper outgoing client scope string based on the ' +
+         'client name when calling #allow_client_incoming first' do
+      @capability.allow_client_incoming 'andrew'
+      @capability.allow_client_outgoing 'myAppSid'
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([
+        ['incoming', {'clientName' => 'andrew'}],
+        ['outgoing', {'clientName' => 'andrew', 'appSid' => 'myAppSid'}]
+      ])
+    end
+
+    it 'should generate a proper outgoing client scope string based on the ' +
+         'client name when calling #allow_client_incoming second' do
+      @capability.allow_client_outgoing 'myAppSid'
+      @capability.allow_client_incoming 'andrew'
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      expect(queries(decoded['scope'])).to eq([["incoming", {"clientName"=>"andrew"}], ["outgoing", {"clientName"=>"andrew", "appSid"=>"myAppSid"}]])
+    end
+
+    it 'should generate a proper outgoing client scope string with parameters ' +
+         'and a client name when calling #allow_client_incoming first' do
+      @capability.allow_client_incoming 'andrew'
+      app_params_hash = {'key' => 'a value', :foo => 'bar/baz'}
+      @capability.allow_client_outgoing 'myAppSid', app_params_hash
+      app_params = @capability.instance_eval {url_encode(app_params_hash)}
+      params_hash = {'appSid' => 'myAppSid', 'appParams' => app_params, 'clientName' => 'andrew'}
+      @capability.instance_eval {url_encode(params_hash)}
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      scopes = queries(decoded['scope'])
+      expect(scopes.shift).to eq(["incoming", {"clientName"=>"andrew"}])
+      scope = scopes.shift
+      expect(scope.first).to eq('outgoing')
+      expect(Rack::Utils.parse_query(scope.last['appParams'])).to eq({'key' => 'a value', 'foo' => 'bar/baz'})
+      expect(scope.last["clientName"]).to eq("andrew")
+      expect(scope.last["appSid"]).to eq("myAppSid")
+      expect(scopes).to be_empty
+    end
+
+    it 'should generate a proper outgoing client scope string with parameters ' +
+         'and a client name when calling #allow_client_incoming second' do
+      app_params_hash = {'key' => 'a value', :foo => 'bar/baz'}
+      @capability.allow_client_outgoing 'myAppSid', app_params_hash
+      @capability.allow_client_incoming 'andrew'
+      app_params = @capability.instance_eval {url_encode(app_params_hash)}
+      params_hash = {'appSid' => 'myAppSid', 'appParams' => app_params, 'clientName' => 'andrew'}
+      @capability.instance_eval {url_encode(params_hash)}
+      token = @capability.generate
+      decoded, header = JWT.decode token, 'myAuthToken'
+      scopes = queries(decoded['scope'])
+      expect(scopes.shift).to eq(["incoming", {"clientName"=>"andrew"}])
+      scope = scopes.shift
+      expect(scope.first).to eq('outgoing')
+      expect(Rack::Utils.parse_query(scope.last['appParams'])).to eq({'key' => 'a value', 'foo' => 'bar/baz'})
+      expect(scope.last["clientName"]).to eq("andrew")
+      expect(scope.last["appSid"]).to eq("myAppSid")
+      expect(scopes).to be_empty
+    end
+  end
+end