pubnub 4.6.2 → 5.0.0

data/features/step_definitions/access_steps.rb

@@ -0,0 +1,258 @@
+require 'pubnub'
+
+token_with_all = "qEF2AkF0GmEI03xDdHRsGDxDcmVzpURjaGFuoWljaGFubmVsLTEY70NncnChb2NoYW5uZWxfZ3JvdXAtMQVDdXNyoENzcGOgRHV1aWShZnV1aWQtMRhoQ3BhdKVEY2hhbqFtXmNoYW5uZWwtXFMqJBjvQ2dycKF0XjpjaGFubmVsX2dyb3VwLVxTKiQFQ3VzcqBDc3BjoER1dWlkoWpedXVpZC1cUyokGGhEbWV0YaBEdXVpZHR0ZXN0LWF1dGhvcml6ZWQtdXVpZENzaWdYIPpU-vCe9rkpYs87YUrFNWkyNq8CVvmKwEjVinnDrJJc"
+
+Given('I have a keyset with access manager enabled') do
+  expect(ENV['PAM_SUB_KEY']).not_to be_nil
+  expect(ENV['PAM_PUB_KEY']).not_to be_nil
+  expect(ENV['PAM_SEC_KEY']).not_to be_nil
+  @pn_configuration['subscribe_key'] = ENV['PAM_SUB_KEY']
+  @pn_configuration['publish_key'] = ENV['PAM_PUB_KEY']
+  @pn_configuration['secret_key'] = ENV['PAM_SEC_KEY']
+  logger = Logger.new(STDOUT)
+  logger.level = Logger::DEBUG
+  @pn_configuration['logger'] = logger
+  @pn_configuration['uuid'] = Pubnub::UUID.generate
+
+  @pubnub = Pubnub.new(@pn_configuration)
+end
+
+Given('I have a keyset with access manager enabled - without secret key') do
+  expect(ENV['PAM_SUB_KEY']).not_to be_nil
+  expect(ENV['PAM_PUB_KEY']).not_to be_nil
+  @pn_configuration['subscribe_key'] = ENV['PAM_SUB_KEY']
+  @pn_configuration['publish_key'] = ENV['PAM_PUB_KEY']
+  logger = Logger.new(STDOUT)
+  logger.level = Logger::DEBUG
+  @pn_configuration['logger'] = logger
+  @pn_configuration['uuid'] = Pubnub::UUID.generate
+
+  @pubnub = Pubnub.new(@pn_configuration)
+end
+
+Given('the authorized UUID {string}') do |uuid|
+  @grant_token_state[:authorized_uuid] = uuid
+end
+
+Given('the TTL {int}') do |ttl|
+  @grant_token_state[:ttl] = ttl
+end
+
+Given('the {string} {resourceType} resource access permissions') do |name, resource_type|
+  @grant_token_state[:current_name] = name
+
+  @grant_token_state[:current_grant][name] = {
+    :name => name,
+    :resource_type => resource_type,
+    :permission_type => []
+  }
+end
+
+And('grant resource permission {permissionType}') do |permission_type|
+  current_name = @grant_token_state[:current_name]
+  @grant_token_state[:current_grant][current_name][:permission_type].push(permission_type)
+end
+
+Given('the {string} {resourceType} pattern access permissions') do |pattern, resource_type|
+  @grant_token_state[:current_pattern] = pattern
+  @grant_token_state[:current_grant][pattern] = {
+    :pattern => pattern,
+    :resource_type => resource_type,
+    :permission_type => []
+  }
+end
+
+Given('a valid token with permissions to publish with channel {string}') do |string|
+  @grant_token_state[:token] = token_with_all
+end
+
+Given('a token') do
+  @grant_token_state[:token] = token_with_all
+end
+
+Given('an expired token with permissions to publish with channel {string}') do |string|
+  @grant_token_state[:token] = token_with_all
+end
+
+And('grant pattern permission {permissionType}') do |permission_type|
+  current_pattern = @grant_token_state[:current_pattern]
+  @grant_token_state[:current_grant][current_pattern][:permission_type].push(permission_type)
+end
+
+When('I grant a token specifying those permissions') do
+  res = call_grant_token(@pubnub, @grant_token_state)
+  @grant_token_state[:parsed_token] = @pubnub.parse_token(res.result[:data]["token"])
+end
+
+When('I publish a message using that auth token with channel {string}') do |channel|
+  @pubnub.set_token(@grant_token_state[:token])
+  res = @pubnub.publish(
+    message: "This is message",
+    channel: channel,
+    http_sync: true
+  )
+  @global_state[:last_call_res] = res
+end
+
+When('I attempt to publish a message using that auth token with channel {string}') do |channel|
+  @pubnub.set_token(@grant_token_state[:token])
+  res = @pubnub.publish(
+    message: "This is message",
+    channel: channel,
+    http_sync: true
+  )
+  @global_state[:last_call_res] = res
+end
+
+When('I revoke a token') do
+  res = @pubnub.revoke_token(
+    token: @grant_token_state[:token],
+    http_sync: true
+  )
+  @global_state[:last_call_res] = res
+end
+
+Then('the token contains the authorized UUID {string}') do |expected_uuid|
+  expect(@grant_token_state[:parsed_token]["uuid"]).to eq expected_uuid
+end
+
+Then('the token contains the TTL {int}') do |ttl|
+  expect(@grant_token_state[:parsed_token]["ttl"]).to eq ttl
+end
+
+Then('the token has {string} {resourceType} resource access permissions') do |resource, resource_type|
+  case resource_type
+  when "CHANNEL"
+    @grant_token_state[:token_resource] = @grant_token_state[:parsed_token]["res"]["chan"][resource]
+  when "CHANNEL_GROUP"
+    @grant_token_state[:token_resource] = @grant_token_state[:parsed_token]["res"]["grp"][resource]
+  when "UUID"
+    @grant_token_state[:token_resource] = @grant_token_state[:parsed_token]["res"]["uuid"][resource]
+  else
+    fail
+  end
+
+  expect(@grant_token_state[:token_resource]).not_to eq nil
+end
+
+Then('token resource permission {permissionType}') do |permission_type|
+  expect(has_permission(@grant_token_state[:token_resource], permission_type)).to eq true
+end
+
+Then('the token has {string} {resourceType} pattern access permissions') do |pattern, resourceType|
+  case resourceType
+  when "CHANNEL"
+    @grant_token_state[:token_resource] = @grant_token_state[:parsed_token]["pat"]["chan"][pattern]
+  when "CHANNEL_GROUP"
+    @grant_token_state[:token_resource] = @grant_token_state[:parsed_token]["pat"]["grp"][pattern]
+  when "UUID"
+    @grant_token_state[:token_resource] = @grant_token_state[:parsed_token]["pat"]["uuid"][pattern]
+  else
+    fail
+  end
+
+  expect(@grant_token_state[:token_resource]).not_to eq nil
+end
+
+And('token pattern permission {permissionType}') do |permission_type|
+  expect(has_permission(@grant_token_state[:token_resource], permission_type)).to eq true
+end
+
+Then('the token does not contain an authorized uuid') do
+  expect(@grant_token_state[:parsed_token]["uuid"]).to eq nil
+end
+
+Given('deny resource permission {permissionType}') do |permission_type|
+  current_name = @grant_token_state[:current_name]
+  @grant_token_state[:current_grant][current_name][:permission_type].filter { |p| p != permission_type }
+end
+
+When('I attempt to grant a token specifying those permissions') do
+  @global_state[:last_call_res] = call_grant_token(@pubnub, @grant_token_state)
+end
+
+Then('an error is returned') do
+  envelope = @global_state[:last_call_res]
+  expect(envelope).not_to eq nil
+  expect(envelope.is_a?(Pubnub::ErrorEnvelope)).to eq true
+end
+
+Then('the error status code is {int}') do |code|
+  expect(@global_state[:last_call_res].status[:code]).to eq code
+end
+
+Then('the error message is {string}') do |error_message|
+  expect(parse_error_body(@global_state[:last_call_res])["error"]["message"]).to eq error_message
+end
+
+Then('the error source is {string}') do |error_source|
+  expect(parse_error_body(@global_state[:last_call_res])["error"]["source"]).to eq error_source
+end
+
+Then('the error detail message is {string}') do |details_message|
+  expect(parse_error_body(@global_state[:last_call_res])["error"]["details"][0]["message"]).to eq details_message
+end
+
+Then('the error detail location is {string}') do |details_location|
+  expect(parse_error_body(@global_state[:last_call_res])["error"]["details"][0]["location"]).to eq details_location
+end
+
+Then('the error detail location type is {string}') do |location_type|
+  expect(parse_error_body(@global_state[:last_call_res])["error"]["details"][0]["locationType"]).to eq location_type
+end
+
+Given('I have a known token containing an authorized UUID') do
+  @grant_token_state[:token] = token_with_all
+end
+
+When('I parse the token') do
+  @grant_token_state[:parsed_token] = @pubnub.parse_token(@grant_token_state[:token])
+end
+
+Then('the parsed token output contains the authorized UUID {string}') do |expected_uuid|
+  expect(@grant_token_state[:parsed_token]["uuid"]).to eq expected_uuid
+end
+
+Given('I have a known token containing UUID resource permissions') do
+  @grant_token_state[:token] = token_with_all
+end
+
+Given('I have a known token containing UUID pattern Permissions') do
+  @grant_token_state[:token] = token_with_all
+end
+
+Given('the token string {string}') do |token|
+  @grant_token_state[:token] = token
+end
+
+Then('the result is successful') do
+  envelope = @global_state[:last_call_res]
+  expect(envelope.is_a?(Pubnub::ErrorEnvelope)).to eq false
+  expect(envelope.status[:code]).to eq 200
+end
+
+Then('an auth error is returned') do
+  envelope = @global_state[:last_call_res]
+  expect(envelope).not_to eq nil
+  expect(envelope.is_a?(Pubnub::ErrorEnvelope)).to eq true
+end
+
+Then('the auth error message is {string}') do |error_message|
+  expect(parse_error_body(@global_state[:last_call_res])["message"]).to eq error_message
+end
+
+Then('the error service is {string}') do |service|
+  expect(parse_error_body(@global_state[:last_call_res])["service"]).to eq service
+end
+
+Then('I get confirmation that token has been revoked') do
+  envelope = @global_state[:last_call_res]
+  expect(envelope.is_a?(Pubnub::ErrorEnvelope)).to eq false
+  expect(envelope.status[:code]).to eq 200
+end
+
+Then('the error detail message is not empty') do
+  expect(parse_error_body(@global_state[:last_call_res])["error"]["message"].empty?).to eq false
+end
+
+

data/features/support/env.rb

@@ -0,0 +1,15 @@
+ParameterType(
+  name:        'resourceType',
+  regexp:      /CHANNEL|CHANNEL_GROUP|UUID/,
+  type:        String,
+  transformer: ->(s) { s }
+)
+
+ParameterType(
+  name:        'permissionType',
+  regexp:      /READ|WRITE|GET|MANAGE|UPDATE|JOIN|DELETE|/,
+  type:        String,
+  transformer: ->(s) { s }
+)
+
+

data/features/support/helper.rb

@@ -0,0 +1,39 @@
+def has_permission(perms, permission_type)
+  current_perm = nil
+  eval "current_perm = Pubnub::Permissions.res(#{permission_type.downcase}: true).calculate_bitmask"
+  perms & current_perm != 0
+end
+
+def prepare_permissions_map(grants, resource_type)
+  grants
+    .select { |_, value|
+      value[:resource_type] == resource_type
+    }
+    .to_h { |name, value|
+      empty_permissions = if value[:pattern]
+                            Pubnub::Permissions.pat
+                          else
+                            Pubnub::Permissions.res
+                          end
+      permissions = value[:permission_type].reduce(empty_permissions) { |accumulated_permissions, string_perm|
+        accumulated_permissions.instance_variable_set("@" + string_perm.downcase, true)
+        accumulated_permissions
+      }
+      [name, permissions]
+    }
+end
+
+def call_grant_token(pubnub, grant_token_state)
+  pubnub.grant_token(
+    ttl: grant_token_state[:ttl],
+    http_sync: true,
+    channels: prepare_permissions_map(grant_token_state[:current_grant], "CHANNEL"),
+    channel_groups: prepare_permissions_map(grant_token_state[:current_grant], "CHANNEL_GROUP"),
+    uuids: prepare_permissions_map(grant_token_state[:current_grant], "UUID"),
+    authorized_uuid: grant_token_state[:authorized_uuid]
+  )
+end
+
+def parse_error_body(error_response)
+  Pubnub::Formatter.parse_json(error_response.status[:server_response].body)[0]
+end

data/features/support/hooks.rb

@@ -0,0 +1,98 @@
+require 'net/http'
+require 'json'
+
+Before do |scenario|
+  @grant_token_state = {}
+  @global_state = {}
+  @grant_token_state[:current_grant] = {}
+  @pn_configuration = {}
+
+  when_mock_server_used {
+    puts "Using mock"
+    expect(ENV['SERVER_HOST']).not_to be_nil
+    expect(ENV['SERVER_PORT']).not_to be_nil
+    @pn_configuration = {
+      origin: ENV['SERVER_HOST'] + ":" + ENV['SERVER_PORT'],
+      isSecure: false,
+    }
+  }
+
+  when_mock_server_used {
+    init_mock(scenario)
+  }
+end
+
+After do |scenario|
+  when_mock_server_used {
+    expect_mock(scenario)
+  }
+end
+
+def when_mock_server_used(&block)
+  if ENV['SERVER_MOCK']&.to_s&.downcase == 'true'
+    block.call
+  end
+end
+
+def init_mock(scenario)
+  contract_name = contract_name(scenario)
+  if contract_name
+    call_init_endpoint(contract_name)
+  end
+end
+
+def call_init_endpoint(contract_name)
+  Net::HTTP.get_response("#{ENV['SERVER_HOST']}", "/init?__contract__script__=#{contract_name}", "#{ENV['SERVER_PORT']}")
+end
+
+def expect_mock(scenario)
+  contract_name = contract_name(scenario)
+  if contract_name
+    expect_result = call_expect_endpoint()
+    print(expect_result)
+    if still_pending?(expect_result) || some_failed?(expect_result)
+      message = "Scenario #{extract_contract(expect_result)} considered failure:
+pending - #{extract_pending(expect_result)},
+failed - #{extract_failed(expect_result)}"
+      RSpec::Expectations.fail_with(message)
+    end
+  end
+end
+
+def extract_contract(expect_result)
+  expect_result['contract']
+end
+
+def extract_pending(expect_result)
+  expect_result['expectations']['pending'].join(", ")
+end
+
+def extract_failed(expect_result)
+  expect_result['expectations']['failed'].join(", ")
+end
+
+def still_pending?(expect_result)
+  pending = expect_result['expectations']['pending']
+  not pending.empty?
+end
+
+def some_failed?(expect_result)
+  pending = expect_result['expectations']['failed']
+  not pending.empty?
+end
+
+def call_expect_endpoint
+  expect_response = Net::HTTP.get_response("#{ENV['SERVER_HOST']}", "/expect", "#{ENV['SERVER_PORT']}")
+
+  if expect_response == nil || expect_response.body == nil
+    RSpec::Expectations.fail_with("Expect response body is null")
+  else
+    JSON.parse(expect_response.body)
+  end
+end
+
+def contract_name(scenario)
+  scenario.source_tag_names&.
+    select { |tagName| tagName.start_with?("@contract") }&.
+    map { |tagName| tagName.split("=")[1] }&.first
+end

data/lib/pubnub/cbor.rb

@@ -0,0 +1,182 @@
+module Pubnub
+  class Cbor
+
+    private
+
+    TYPE_MASK = 0b11100000
+    ADDITIONAL_MASK = 0b00011111
+
+    TYPE_UNSIGNED_INT = 0b00000000
+    TYPE_NEGATIVE_INT = 0b00100000
+    TYPE_BYTE_STRING = 0b01000000
+    TYPE_TEXT_STRING = 0b01100000
+    TYPE_ARRAY = 0b10000000
+    TYPE_HASHMAP = 0b10100000
+    TYPE_TAG = 0b11000000
+    TYPE_FLOAT = 0b11100000
+
+    ADDITIONAL_TYPE_INDEFINITE = 31
+    INDEFINITE_BREAK = 0b11111111
+
+    ADDITIONAL_LENGTH_1B = 24
+    ADDITIONAL_LENGTH_2B = 25
+    ADDITIONAL_LENGTH_4B = 26
+    ADDITIONAL_LENGTH_8B = 27
+
+    ADDITIONAL_LENGTH_BYTES = {
+      ADDITIONAL_LENGTH_1B => 1,
+      ADDITIONAL_LENGTH_2B => 2,
+      ADDITIONAL_LENGTH_4B => 4,
+      ADDITIONAL_LENGTH_8B => 8,
+    }
+
+    SIMPLE_VALUE_FALSE = 0xF4
+    SIMPLE_VALUE_TRUE = 0xF5
+    SIMPLE_VALUE_NULL = 0xF6
+    SIMPLE_VALUE_UNDEF = 0xF7
+
+    def bytearray_to_i(byte_array)
+      byte_array.reverse_each.map.with_index do |b, i|
+        b << 8 * i
+      end.reduce(0) do |reduced, byte|
+        reduced | byte
+      end
+    end
+
+    def decode_integer(data, additional)
+      if ADDITIONAL_LENGTH_BYTES.member?(additional)
+        bytearray_to_i(data.shift(ADDITIONAL_LENGTH_BYTES[additional]))
+      else
+        additional
+      end
+    end
+
+    def decode_float(data, additional)
+      if additional <= 23
+        additional
+      else
+        bytes = bytearray_to_i(data.shift(ADDITIONAL_LENGTH_BYTES[additional]))
+        case (additional)
+        when ADDITIONAL_LENGTH_1B
+          bytes
+        when ADDITIONAL_LENGTH_2B
+          sign = (bytes >> 15) != 0 ? -1 : 1
+          exp = (bytes & 0b0111110000000000) >> 10
+          mant = bytes & 0b1111111111
+          if exp == 0
+            result = (2 ** -14) * (mant / 1024.to_f)
+          elsif exp == 0b11111
+            result = Float::INFINITY
+          else
+            result = (2 ** (exp - 15)) * (1 + mant / 1024.to_f)
+          end
+          sign * result
+        when ADDITIONAL_LENGTH_4B
+          sign = (bytes >> 31) != 0 ? -1 : 1
+          x = (bytes & ((1 << 23) - 1)) + (1 << 23)
+          exp = (bytes >> 23 & 0xFF) - 127
+          x * (2 ** (exp - 23)) * sign
+        when ADDITIONAL_LENGTH_8B
+          sign = (bytes >> 63) != 0 ? -1 : 1
+          exp = (bytes >> 52) & 0x7FF
+
+          mant = bytes & 0xFFFFFFFFFFFFF
+
+          if 0 == exp
+            val = mant * 2 ** (-(1022 + 52))
+          elsif 0b11111111111 != exp
+            val = (mant + (1 << 52)) * 2 ** (exp - (1023 + 52))
+          else
+            val = 0 == mant ? Float::INFINITY : Float::NAN
+          end
+          sign * val
+        end
+      end
+    end
+
+    def indefinite_data(data)
+      result = []
+
+      loop do
+        byte = data.shift
+        break if byte == INDEFINITE_BREAK
+        result.append(byte)
+        break if data.empty?
+      end
+      result
+    end
+
+    def compute_length(data, additional)
+      if ADDITIONAL_LENGTH_BYTES.member?(additional)
+        bytearray_to_i(data.shift(ADDITIONAL_LENGTH_BYTES[additional]))
+      else
+        additional
+      end
+    end
+
+    def decode_string(data, additional)
+      if additional == ADDITIONAL_TYPE_INDEFINITE
+        indefinite_data(data).pack('C*').force_encoding('UTF-8')
+      else
+        length = compute_length(data, additional)
+        data.shift(length).pack('C*').force_encoding('UTF-8')
+      end
+    end
+
+    def decode_map(data, additional)
+      length = compute_length(data, additional)
+      result = Hash.new
+      (1..length).each { result.store(parse_data(data), parse_data(data)) }
+      result
+    end
+
+    def decode_array(data, additional)
+      length = compute_length(data, additional)
+      (1..length).map { parse_data(data) }
+    end
+
+    def parse_data(data)
+      byte = data.shift
+
+      case (byte)
+      when SIMPLE_VALUE_NULL
+        return nil
+      when SIMPLE_VALUE_TRUE
+        return true
+      when SIMPLE_VALUE_FALSE
+        return false
+      when SIMPLE_VALUE_UNDEF
+        return nil
+      else
+        type = byte & TYPE_MASK
+        additional = byte & ADDITIONAL_MASK
+
+        case (type)
+        when TYPE_NEGATIVE_INT
+          -1 - decode_integer(data, additional)
+        when TYPE_UNSIGNED_INT
+          decode_integer(data, additional)
+        when TYPE_FLOAT
+          decode_float(data, additional).to_f
+        when TYPE_BYTE_STRING
+          decode_string(data, additional)
+        when TYPE_TEXT_STRING
+          decode_string(data, additional)
+        when TYPE_ARRAY
+          decode_array(data, additional)
+        when TYPE_HASHMAP
+          decode_map(data, additional)
+        else
+          nil
+        end
+      end
+    end
+
+    public
+
+    def decode(value)
+      parse_data(value)
+    end
+  end
+
+end

data/lib/pubnub/client/events.rb

@@ -4,7 +4,7 @@ module Pubnub
   class Client
     # Module that holds generator for all events
     module Events
-      EVENTS = %w[publish subscribe presence leave history here_now audit grant delete_messages
+      EVENTS = %w[publish subscribe presence leave history here_now audit grant grant_token revoke_token delete_messages
                   revoke time heartbeat where_now set_state state channel_registration message_counts signal
                   add_channels_to_push list_push_provisions remove_channels_from_push remove_device_from_push
                   set_uuid_metadata set_channel_metadata remove_uuid_metadata remove_channel_metadata

data/lib/pubnub/client/getters_setters.rb

@@ -1,9 +1,12 @@
+require 'pubnub/validators/common_validator'
+
 # Toplevel Pubnub module.
 module Pubnub
   # Pubnub client Class
   class Client
     # Module that holds some getters and setters
     module GettersSetters
+
       def sdk_version
         "PubNub-Ruby/#{Pubnub::VERSION}"
       end
@@ -25,6 +28,8 @@ module Pubnub
       def change_uuid(uuid)
         Pubnub.logger.debug('Pubnub::Client') { 'Changing uuid' }
         raise('Cannot change UUID while subscribed.') if subscribed?
+        Validator::Client.validate_uuid uuid
+
         @env[:uuid] = uuid
       end