SPEC.md

Ably REST Client Library 1.0.6 Specification

Ably::Rest::Client#time

(see lib/submodules/ably-ruby/spec/acceptance/rest/time_spec.rb)

• using JSON protocol
  • fetching the service time
    • should return the service time as a Time object
    • with reconfigured HTTP timeout
      • should raise a timeout exception
• using MsgPack protocol
  • fetching the service time
    • should return the service time as a Time object
    • with reconfigured HTTP timeout
      • should raise a timeout exception

Ably::Rest::Client

(see lib/submodules/ably-ruby/spec/acceptance/rest/client_spec.rb)

• using JSON protocol
  • #initialize
    • with only an API key
      • uses basic authentication
    • with an explicit string :token
      • uses token authentication
    • with :use_token_auth set to true
      • uses token authentication
    • with a :client_id configured
      • uses token authentication
    • with a non string :client_id
      • raises an ArgumentError
    • with an invalid wildcard "*" :client_id
      • raises an exception
    • with an :auth_callback lambda
      • calls the auth lambda to get a new token
      • uses token authentication
    • with :default_token_params
      • overides the default token params (#TO3j11)
    • with an :auth_callback lambda (clientId provided in library options instead of as a token_request param)
      • correctly sets the clientId on the token
    • with an auth URL
      • uses token authentication
      • before any REST request
        • sends an HTTP request to the provided auth URL to get a new token
    • auth headers
      • with basic auth
        • sends the API key in authentication part of the secure URL (the Authorization: Basic header is not used with the Faraday HTTP library by default)
      • with token auth
        • without specifying protocol
          • sends the token string over HTTPS in the Authorization Bearer header with Base64 encoding
        • when setting constructor ClientOption :tls to false
          • sends the token string over HTTP in the Authorization Bearer header with Base64 encoding
  • using tokens
    • when expired
      • creates a new token automatically when the old token expires
      • with a different client_id in the subsequent token
        • fails to authenticate and raises an exception
    • when token has not expired
      • reuses the existing token for every request
  • connection transport
    • defaults
      • for default host
        • is configured to timeout connection opening in 4 seconds
        • is configured to timeout connection requests in 10 seconds
      • for the fallback hosts
        • is configured to timeout connection opening in 4 seconds
        • is configured to timeout connection requests in 10 seconds
    • with custom http_open_timeout and http_request_timeout options
      • for default host
        • is configured to use custom open timeout
        • is configured to use custom request timeout
      • for the fallback hosts
        • is configured to timeout connection opening in 4 seconds
        • is configured to timeout connection requests in 10 seconds
  • fallback hosts
    • configured
      • should make connection attempts to A.ably-realtime.com, B.ably-realtime.com, C.ably-realtime.com, D.ably-realtime.com, E.ably-realtime.com (#RSC15a)
    • when environment is NOT production (#RSC15b)
      • does not retry failed requests with fallback hosts when there is a connection error
    • when environment is production
      • and connection times out
        • tries fallback hosts 3 times (#RSC15b, #RSC15b)
        • and the total request time exeeds 15 seconds
          • makes no further attempts to any fallback hosts
      • and connection fails
        • tries fallback hosts 3 times
      • and first request to primary endpoint fails
        • tries a fallback host, and for the next request tries the primary endpoint again (#RSC15e)
      • and basic authentication fails
        • does not attempt the fallback hosts as this is an authentication failure
      • and server returns a 50x error
        • attempts the fallback hosts as this is an authentication failure (#RSC15d)
    • when environment is production and server returns a 50x error
      • with custom fallback hosts provided
        • attempts the fallback hosts as this is an authentication failure (#RSC15b, #RSC15a, #TO3k6)
      • with an empty array of fallback hosts provided (#RSC15b, #RSC15a, #TO3k6)
        • does not attempt the fallback hosts as this is an authentication failure
      • using a local web-server
        • and timing out the primary host
          • POST with request timeout less than max_retry_duration
            • tries the primary host, then both fallback hosts (#RSC15d)
          • GET with request timeout less than max_retry_duration
            • tries the primary host, then both fallback hosts (#RSC15d)
          • POST with request timeout more than max_retry_duration
            • does not try any fallback hosts (#RSC15d)
          • GET with request timeout more than max_retry_duration
            • does not try any fallback hosts (#RSC15d)
        • and failing the primary host
          • tries one of the fallback hosts
    • when environment is not production and server returns a 50x error
      • with custom fallback hosts provided (#RSC15b, #TO3k6)
        • attempts the fallback hosts as this is not an authentication failure
      • with an empty array of fallback hosts provided (#RSC15b, #TO3k6)
        • does not attempt the fallback hosts as this is an authentication failure
      • with fallback_hosts_use_default: true (#RSC15b, #TO3k7)
        • attempts the default fallback hosts as this is an authentication failure
  • with a custom host
    • that does not exist
      • fails immediately and raises a Faraday Error
      • fallback hosts
        • are never used
    • that times out
      • fails immediately and raises a Faraday Error
      • fallback hosts
        • are never used
  • HTTP configuration options
    • is frozen
    • defaults
      • #http_open_timeout is 4s
      • #http_request_timeout is 10s
      • #http_max_retry_count is 3
      • #http_max_retry_duration is 15s
    • configured
      • #http_open_timeout uses provided value
      • #http_request_timeout uses provided value
      • #http_max_retry_count uses provided value
      • #http_max_retry_duration uses provided value
  • #auth
    • is provides access to the Auth object
    • configures the Auth object with all ClientOptions passed to client in the initializer
  • version headers
    • with variant none
      • sends a protocol version and lib version header (#G4, #RSC7a, #RSC7b)
    • with variant foo
      • sends a protocol version and lib version header (#G4, #RSC7a, #RSC7b)
  • #request (#RSC19*)
    • get
      • returns an HttpPaginatedResponse object
      • 404 request to invalid URL
        • returns an object with 404 status code and error message
      • paged results
        • provides paging
  • request_id generation
    • Timeout error
      • with option add_request_ids: true
        • FAILED: has an error with the same request_id of the request
      • with option add_request_ids: true and REST operations with a message body
        • with mocks to inspect the params
          • with a single publish
            • succeeds and sends the request_id as a param
          • with an array publish
            • succeeds and sends the request_id as a param
        • without mocks to ensure the requests are accepted
          • with a single publish
            • succeeds and sends the request_id as a param
          • with an array publish
            • succeeds and sends the request_id as a param
      • option add_request_ids: true and specified fallback hosts
        • request_id is the same across retries
      • without request_id
        • does not include request_id in ConnectionTimeout error
    • UnauthorizedRequest nonce error
      • includes request_id in UnauthorizedRequest error due to replayed nonce
  • failed request logging
    • FAILED: is absent when requests do not fail
    • with the first request failing
      • FAILED: is present with success message when requests do not actually fail
    • with all requests failing
      • FAILED: is present when all requests fail
• using MsgPack protocol
  • #initialize
    • with only an API key
      • uses basic authentication
    • with an explicit string :token
      • uses token authentication
    • with :use_token_auth set to true
      • uses token authentication
    • with a :client_id configured
      • uses token authentication
    • with a non string :client_id
      • raises an ArgumentError
    • with an invalid wildcard "*" :client_id
      • raises an exception
    • with an :auth_callback lambda
      • calls the auth lambda to get a new token
      • uses token authentication
    • with :default_token_params
      • overides the default token params (#TO3j11)
    • with an :auth_callback lambda (clientId provided in library options instead of as a token_request param)
      • correctly sets the clientId on the token
    • with an auth URL
      • uses token authentication
      • before any REST request
        • sends an HTTP request to the provided auth URL to get a new token
    • auth headers
      • with basic auth
        • sends the API key in authentication part of the secure URL (the Authorization: Basic header is not used with the Faraday HTTP library by default)
      • with token auth
        • without specifying protocol
          • sends the token string over HTTPS in the Authorization Bearer header with Base64 encoding
        • when setting constructor ClientOption :tls to false
          • sends the token string over HTTP in the Authorization Bearer header with Base64 encoding
  • using tokens
    • when expired
      • creates a new token automatically when the old token expires
      • with a different client_id in the subsequent token
        • fails to authenticate and raises an exception
    • when token has not expired
      • reuses the existing token for every request
  • connection transport
    • defaults
      • for default host
        • is configured to timeout connection opening in 4 seconds
        • is configured to timeout connection requests in 10 seconds
      • for the fallback hosts
        • is configured to timeout connection opening in 4 seconds
        • is configured to timeout connection requests in 10 seconds
    • with custom http_open_timeout and http_request_timeout options
      • for default host
        • is configured to use custom open timeout
        • is configured to use custom request timeout
      • for the fallback hosts
        • is configured to timeout connection opening in 4 seconds
        • is configured to timeout connection requests in 10 seconds
  • fallback hosts
    • configured
      • should make connection attempts to A.ably-realtime.com, B.ably-realtime.com, C.ably-realtime.com, D.ably-realtime.com, E.ably-realtime.com (#RSC15a)
    • when environment is NOT production (#RSC15b)
      • does not retry failed requests with fallback hosts when there is a connection error
    • when environment is production
      • and connection times out
        • tries fallback hosts 3 times (#RSC15b, #RSC15b)
        • and the total request time exeeds 15 seconds
          • makes no further attempts to any fallback hosts
      • and connection fails
        • tries fallback hosts 3 times
      • and first request to primary endpoint fails
        • tries a fallback host, and for the next request tries the primary endpoint again (#RSC15e)
      • and basic authentication fails
        • does not attempt the fallback hosts as this is an authentication failure
      • and server returns a 50x error
        • attempts the fallback hosts as this is an authentication failure (#RSC15d)
    • when environment is production and server returns a 50x error
      • with custom fallback hosts provided
        • attempts the fallback hosts as this is an authentication failure (#RSC15b, #RSC15a, #TO3k6)
      • with an empty array of fallback hosts provided (#RSC15b, #RSC15a, #TO3k6)
        • does not attempt the fallback hosts as this is an authentication failure
      • using a local web-server
        • and timing out the primary host
          • POST with request timeout less than max_retry_duration
            • tries the primary host, then both fallback hosts (#RSC15d)
          • GET with request timeout less than max_retry_duration
            • tries the primary host, then both fallback hosts (#RSC15d)
          • POST with request timeout more than max_retry_duration
            • does not try any fallback hosts (#RSC15d)
          • GET with request timeout more than max_retry_duration
            • does not try any fallback hosts (#RSC15d)
        • and failing the primary host
          • tries one of the fallback hosts
    • when environment is not production and server returns a 50x error
      • with custom fallback hosts provided (#RSC15b, #TO3k6)
        • attempts the fallback hosts as this is not an authentication failure
      • with an empty array of fallback hosts provided (#RSC15b, #TO3k6)
        • does not attempt the fallback hosts as this is an authentication failure
      • with fallback_hosts_use_default: true (#RSC15b, #TO3k7)
        • attempts the default fallback hosts as this is an authentication failure
  • with a custom host
    • that does not exist
      • fails immediately and raises a Faraday Error
      • fallback hosts
        • are never used
    • that times out
      • fails immediately and raises a Faraday Error
      • fallback hosts
        • are never used
  • HTTP configuration options
    • is frozen
    • defaults
      • #http_open_timeout is 4s
      • #http_request_timeout is 10s
      • #http_max_retry_count is 3
      • #http_max_retry_duration is 15s
    • configured
      • #http_open_timeout uses provided value
      • #http_request_timeout uses provided value
      • #http_max_retry_count uses provided value
      • #http_max_retry_duration uses provided value
  • #auth
    • is provides access to the Auth object
    • configures the Auth object with all ClientOptions passed to client in the initializer
  • version headers
    • with variant none
      • sends a protocol version and lib version header (#G4, #RSC7a, #RSC7b)
    • with variant foo
      • sends a protocol version and lib version header (#G4, #RSC7a, #RSC7b)
  • #request (#RSC19*)
    • get
      • returns an HttpPaginatedResponse object
      • 404 request to invalid URL
        • returns an object with 404 status code and error message
      • paged results
        • provides paging
  • request_id generation
    • Timeout error
      • with option add_request_ids: true
        • FAILED: has an error with the same request_id of the request
      • with option add_request_ids: true and REST operations with a message body
        • with mocks to inspect the params
          • with a single publish
            • succeeds and sends the request_id as a param
          • with an array publish
            • succeeds and sends the request_id as a param
        • without mocks to ensure the requests are accepted
          • with a single publish
            • succeeds and sends the request_id as a param
          • with an array publish
            • succeeds and sends the request_id as a param
      • option add_request_ids: true and specified fallback hosts
        • request_id is the same across retries
      • without request_id
        • does not include request_id in ConnectionTimeout error
    • UnauthorizedRequest nonce error
      • includes request_id in UnauthorizedRequest error due to replayed nonce
  • failed request logging
    • FAILED: is absent when requests do not fail
    • with the first request failing
      • FAILED: is present with success message when requests do not actually fail
    • with all requests failing
      • FAILED: is present when all requests fail

Ably::Rest::Client#stats

(see lib/submodules/ably-ruby/spec/acceptance/rest/stats_spec.rb)

• using JSON protocol
  • fetching application stats
    • returns a PaginatedResult object
    • by minute
      • with no options
        • uses the minute interval by default
      • with :from set to last interval and :limit set to 1
        • retrieves only one stat
        • returns zero value for any missing metrics
        • returns all aggregated message data
        • returns inbound realtime all data
        • returns inbound realtime message data
        • returns outbound realtime all data
        • returns persisted presence all data
        • returns connections all data
        • returns channels all data
        • returns api_requests data
        • returns token_requests data
        • returns stat objects with #interval_granularity equal to :minute
        • returns stat objects with #interval_id matching :start
        • returns stat objects with #interval_time matching :start Time
      • with :start set to first interval, :limit set to 1 and direction :forwards
        • returns the first interval stats as stats are provided forwards from :start
        • returns 3 pages of stats
      • with :end set to last interval, :limit set to 1 and direction :backwards
        • returns the 3rd interval stats first as stats are provided backwards from :end
        • returns 3 pages of stats
      • with :end set to last interval and :limit set to 3 to ensure only last years stats are included
        • the REST API
          • defaults to direction :backwards
      • with :end set to previous year interval
        • the REST API
          • defaults to 100 items for pagination
    • by hour
      • should aggregate the stats for that period
    • by day
      • should aggregate the stats for that period
    • by month
      • should aggregate the stats for that period
    • when argument start is after end
      • should raise an exception
• using MsgPack protocol
  • fetching application stats
    • returns a PaginatedResult object
    • by minute
      • with no options
        • uses the minute interval by default
      • with :from set to last interval and :limit set to 1
        • retrieves only one stat
        • returns zero value for any missing metrics
        • returns all aggregated message data
        • returns inbound realtime all data
        • returns inbound realtime message data
        • returns outbound realtime all data
        • returns persisted presence all data
        • returns connections all data
        • returns channels all data
        • returns api_requests data
        • returns token_requests data
        • returns stat objects with #interval_granularity equal to :minute
        • returns stat objects with #interval_id matching :start
        • returns stat objects with #interval_time matching :start Time
      • with :start set to first interval, :limit set to 1 and direction :forwards
        • returns the first interval stats as stats are provided forwards from :start
        • returns 3 pages of stats
      • with :end set to last interval, :limit set to 1 and direction :backwards
        • returns the 3rd interval stats first as stats are provided backwards from :end
        • returns 3 pages of stats
      • with :end set to last interval and :limit set to 3 to ensure only last years stats are included
        • the REST API
          • defaults to direction :backwards
      • with :end set to previous year interval
        • the REST API
          • defaults to 100 items for pagination
    • by hour
      • should aggregate the stats for that period
    • by day
      • should aggregate the stats for that period
    • by month
      • should aggregate the stats for that period
    • when argument start is after end
      • should raise an exception

Ably::Rest::Presence

(see lib/submodules/ably-ruby/spec/acceptance/rest/presence_spec.rb)

• using JSON protocol
  • tested against presence fixture data set up in test app
    • #get
      • returns current members on the channel with their action set to :present
      • with :limit option
        • returns a paged response limiting number of members per page
      • default :limit
        • defaults to a limit of 100
      • with :client_id option
        • returns a list members filtered by the provided client ID
      • with :connection_id option
        • returns a list members filtered by the provided connection ID
        • returns a list members filtered by the provided connection ID
      • with a non ASCII channel name
        • stubbed
          • correctly encodes the channel name
    • #history
      • returns recent presence activity
      • default behaviour
        • uses backwards direction
      • with options
        • direction: :forwards
          • returns recent presence activity forwards with most recent history last
        • direction: :backwards
          • returns recent presence activity backwards with most recent history first
  • #history
    • with options
      • limit options
        • default
          • is set to 100
        • set to 1000
          • is passes the limit query param value 1000
      • with time range options
        • :start
          • with milliseconds since epoch value
            • uses this value in the history request
          • with Time object value
            • converts the value to milliseconds since epoch in the hisotry request
        • :end
          • with milliseconds since epoch value
            • uses this value in the history request
          • with Time object value
            • converts the value to milliseconds since epoch in the hisotry request
        • when argument start is after end
          • should raise an exception
  • decoding
    • with encoded fixture data
      • #history
        • decodes encoded and encryped presence fixture data automatically
      • #get
        • decodes encoded and encryped presence fixture data automatically
  • decoding permutations using mocked #history
    • valid decodeable content
      • #get
        • automaticaly decodes presence messages
      • #history
        • automaticaly decodes presence messages
    • invalid data
      • #get
        • returns the messages still encoded
        • logs a cipher error
      • #history
        • returns the messages still encoded
        • logs a cipher error
• using MsgPack protocol
  • tested against presence fixture data set up in test app
    • #get
      • returns current members on the channel with their action set to :present
      • with :limit option
        • returns a paged response limiting number of members per page
      • default :limit
        • defaults to a limit of 100
      • with :client_id option
        • returns a list members filtered by the provided client ID
      • with :connection_id option
        • returns a list members filtered by the provided connection ID
        • returns a list members filtered by the provided connection ID
      • with a non ASCII channel name
        • stubbed
          • correctly encodes the channel name
    • #history
      • returns recent presence activity
      • default behaviour
        • uses backwards direction
      • with options
        • direction: :forwards
          • returns recent presence activity forwards with most recent history last
        • direction: :backwards
          • returns recent presence activity backwards with most recent history first
  • #history
    • with options
      • limit options
        • default
          • is set to 100
        • set to 1000
          • is passes the limit query param value 1000
      • with time range options
        • :start
          • with milliseconds since epoch value
            • uses this value in the history request
          • with Time object value
            • converts the value to milliseconds since epoch in the hisotry request
        • :end
          • with milliseconds since epoch value
            • uses this value in the history request
          • with Time object value
            • converts the value to milliseconds since epoch in the hisotry request
        • when argument start is after end
          • should raise an exception
  • decoding
    • with encoded fixture data
      • #history
        • decodes encoded and encryped presence fixture data automatically
      • #get
        • decodes encoded and encryped presence fixture data automatically
  • decoding permutations using mocked #history
    • valid decodeable content
      • #get
        • automaticaly decodes presence messages
      • #history
        • automaticaly decodes presence messages
    • invalid data
      • #get
        • returns the messages still encoded
        • logs a cipher error
      • #history
        • returns the messages still encoded
        • logs a cipher error

Ably::Rest::Channels

(see lib/submodules/ably-ruby/spec/acceptance/rest/channels_spec.rb)

• using JSON protocol
  • using shortcut method #channel on the client object
    • behaves like a channel
      • returns a channel object
      • returns channel object and passes the provided options
  • using #get method on client#channels
    • behaves like a channel
      • returns a channel object
      • returns channel object and passes the provided options
  • accessing an existing channel object with different options
    • overrides the existing channel options and returns the channel object
  • accessing an existing channel object without specifying any channel options
    • returns the existing channel without modifying the channel options
  • using undocumented array accessor [] method on client#channels
    • behaves like a channel
      • returns a channel object
      • returns channel object and passes the provided options
• using MsgPack protocol
  • using shortcut method #channel on the client object
    • behaves like a channel
      • returns a channel object
      • returns channel object and passes the provided options
  • using #get method on client#channels
    • behaves like a channel
      • returns a channel object
      • returns channel object and passes the provided options
  • accessing an existing channel object with different options
    • overrides the existing channel options and returns the channel object
  • accessing an existing channel object without specifying any channel options
    • returns the existing channel without modifying the channel options
  • using undocumented array accessor [] method on client#channels
    • behaves like a channel
      • returns a channel object
      • returns channel object and passes the provided options

Ably::Rest::Channel messages

(see lib/submodules/ably-ruby/spec/acceptance/rest/message_spec.rb)

• using JSON protocol
  • publishing with an ASCII_8BIT message name
    • is converted into UTF_8
  • with supported data payload content type
    • JSON Object (Hash)
      • is encoded and decoded to the same hash
    • JSON Array
      • is encoded and decoded to the same Array
    • String
      • is encoded and decoded to the same Array
    • Binary
      • is encoded and decoded to the same Array
  • with supported extra payload content type (#RSL1h, #RSL6a2)
    • JSON Object (Hash)
      • is encoded and decoded to the same hash
    • JSON Array
      • is encoded and decoded to the same deep multi-type object
    • nil
      • is encoded and decoded to the same Array
  • with unsupported data payload content type
    • Integer
      • is raises an UnsupportedDataType 40011 exception
    • Float
      • is raises an UnsupportedDataType 40011 exception
    • Boolean
      • is raises an UnsupportedDataType 40011 exception
    • False
      • is raises an UnsupportedDataType 40011 exception
  • encryption and encoding
    • with #publish and #history
      • with AES-128-CBC using crypto-data-128.json fixtures (#RTL7d)
        • item 0 with encrypted encoding utf-8/cipher+aes-128-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 1 with encrypted encoding cipher+aes-128-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 2 with encrypted encoding json/utf-8/cipher+aes-128-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 3 with encrypted encoding json/utf-8/cipher+aes-128-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
      • with AES-256-CBC using crypto-data-256.json fixtures (#RTL7d)
        • item 0 with encrypted encoding utf-8/cipher+aes-256-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 1 with encrypted encoding cipher+aes-256-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 2 with encrypted encoding json/utf-8/cipher+aes-256-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 3 with encrypted encoding json/utf-8/cipher+aes-256-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
      • when publishing lots of messages
        • encrypts on #publish and decrypts on #history
      • when retrieving #history with a different protocol
        • delivers a String ASCII-8BIT payload to the receiver
        • delivers a String UTF-8 payload to the receiver
        • delivers a Hash payload to the receiver
      • when publishing on an unencrypted channel and retrieving with #history on an encrypted channel
        • does not attempt to decrypt the message
      • when publishing on an encrypted channel and retrieving with #history on an unencrypted channel
        • retrieves the message that remains encrypted with an encrypted encoding attribute (#RTL7e)
        • logs a Cipher exception (#RTL7e)
      • publishing on an encrypted channel and retrieving #history with a different algorithm on another client (#RTL7e)
        • retrieves the message that remains encrypted with an encrypted encoding attribute (#RTL7e)
        • logs a Cipher exception (#RTL7e)
      • publishing on an encrypted channel and subscribing with a different key on another client
        • retrieves the message that remains encrypted with an encrypted encoding attribute
        • logs a Cipher exception
• using MsgPack protocol
  • publishing with an ASCII_8BIT message name
    • is converted into UTF_8
  • with supported data payload content type
    • JSON Object (Hash)
      • is encoded and decoded to the same hash
    • JSON Array
      • is encoded and decoded to the same Array
    • String
      • is encoded and decoded to the same Array
    • Binary
      • is encoded and decoded to the same Array
  • with supported extra payload content type (#RSL1h, #RSL6a2)
    • JSON Object (Hash)
      • is encoded and decoded to the same hash
    • JSON Array
      • is encoded and decoded to the same deep multi-type object
    • nil
      • is encoded and decoded to the same Array
  • with unsupported data payload content type
    • Integer
      • is raises an UnsupportedDataType 40011 exception
    • Float
      • is raises an UnsupportedDataType 40011 exception
    • Boolean
      • is raises an UnsupportedDataType 40011 exception
    • False
      • is raises an UnsupportedDataType 40011 exception
  • encryption and encoding
    • with #publish and #history
      • with AES-128-CBC using crypto-data-128.json fixtures (#RTL7d)
        • item 0 with encrypted encoding utf-8/cipher+aes-128-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 1 with encrypted encoding cipher+aes-128-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 2 with encrypted encoding json/utf-8/cipher+aes-128-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 3 with encrypted encoding json/utf-8/cipher+aes-128-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
      • with AES-256-CBC using crypto-data-256.json fixtures (#RTL7d)
        • item 0 with encrypted encoding utf-8/cipher+aes-256-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 1 with encrypted encoding cipher+aes-256-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 2 with encrypted encoding json/utf-8/cipher+aes-256-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
        • item 3 with encrypted encoding json/utf-8/cipher+aes-256-cbc/base64
          • behaves like an Ably encrypter and decrypter
            • encrypts message automatically when published (#RTL7d)
            • sends and retrieves messages that are encrypted & decrypted by the Ably library (#RTL7d)
      • when publishing lots of messages
        • encrypts on #publish and decrypts on #history
      • when retrieving #history with a different protocol
        • delivers a String ASCII-8BIT payload to the receiver
        • delivers a String UTF-8 payload to the receiver
        • delivers a Hash payload to the receiver
      • when publishing on an unencrypted channel and retrieving with #history on an encrypted channel
        • does not attempt to decrypt the message
      • when publishing on an encrypted channel and retrieving with #history on an unencrypted channel
        • retrieves the message that remains encrypted with an encrypted encoding attribute (#RTL7e)
        • logs a Cipher exception (#RTL7e)
      • publishing on an encrypted channel and retrieving #history with a different algorithm on another client (#RTL7e)
        • retrieves the message that remains encrypted with an encrypted encoding attribute (#RTL7e)
        • logs a Cipher exception (#RTL7e)
      • publishing on an encrypted channel and subscribing with a different key on another client
        • retrieves the message that remains encrypted with an encrypted encoding attribute
        • logs a Cipher exception

Ably::Models::MessageEncoders

(see lib/submodules/ably-ruby/spec/acceptance/rest/encoders_spec.rb)

• with binary transport protocol
  • without encryption
    • with UTF-8 data
      • does not apply any encoding
    • with binary data
      • does not apply any encoding
    • with JSON data
      • stringifies the JSON and sets the encoding attribute to "json"
  • with encryption
    • with UTF-8 data
      • applies utf-8 and cipher encoding and sets the encoding attribute to "utf-8/cipher+aes-128-cbc"
    • with binary data
      • applies cipher encoding and sets the encoding attribute to "cipher+aes-128-cbc"
    • with JSON data
      • applies json, utf-8 and cipher encoding and sets the encoding attribute to "json/utf-8/cipher+aes-128-cbc"
• with text transport protocol
  • without encryption
    • with UTF-8 data
      • does not apply any encoding
    • with binary data
      • applies a base64 encoding and sets the encoding attribute to "base64"
    • with JSON data
      • stringifies the JSON and sets the encoding attribute to "json"
  • with encryption
    • with UTF-8 data
      • applies utf-8, cipher and base64 encodings and sets the encoding attribute to "utf-8/cipher+aes-128-cbc/base64"
    • with binary data
      • applies cipher and base64 encoding and sets the encoding attribute to "cipher+aes-128-cbc/base64"
    • with JSON data
      • applies json, utf-8, cipher and base64 encoding and sets the encoding attribute to "json/utf-8/cipher+aes-128-cbc/base64"

Ably::Rest::Channel

(see lib/submodules/ably-ruby/spec/acceptance/rest/channel_spec.rb)

• using JSON protocol
  • #publish
    • with name and data arguments
      • publishes the message and return true indicating success
      • and additional attributes
        • publishes the message with the attributes and return true indicating success
    • with a client_id configured in the ClientOptions
      • publishes the message without a client_id
      • expects a client_id to be added by the realtime service
    • with an array of Hash objects with :name and :data attributes
      • publishes an array of messages in one HTTP request
    • with an array of Message objects
      • publishes an array of messages in one HTTP request
    • without adequate permissions on the channel
      • raises a permission error when publishing
    • null attributes
      • when name is null
        • publishes the message without a name attribute in the payload
      • when data is null
        • publishes the message without a data attribute in the payload
      • with neither name or data attributes
        • publishes the message without any attributes in the payload
    • identified clients
      • when authenticated with a wildcard client_id
        • with a valid client_id in the message
          • succeeds
        • with a wildcard client_id in the message
          • throws an exception
        • with an empty client_id in the message
          • succeeds and publishes without a client_id
      • when authenticated with a Token string with an implicit client_id
        • without having a confirmed identity
          • with a valid client_id in the message
            • succeeds
          • with an invalid client_id in the message
            • succeeds in the client library but then fails when published to Ably
          • with an empty client_id in the message
            • succeeds and publishes with an implicit client_id
      • when authenticated with TokenDetails with a valid client_id
        • with a valid client_id in the message
          • succeeds
        • with a wildcard client_id in the message
          • throws an exception
        • with an invalid client_id in the message
          • throws an exception
        • with an empty client_id in the message
          • succeeds and publishes with an implicit client_id
      • when anonymous and no client_id
        • with a client_id in the message
          • throws an exception
        • with a wildcard client_id in the message
          • throws an exception
        • with an empty client_id in the message
          • succeeds and publishes with an implicit client_id
    • with a non ASCII channel name
      • stubbed
        • correctly encodes the channel name
  • #history
    • returns a PaginatedResult model
    • returns the current message history for the channel
    • returns paged history using the PaginatedResult model
    • message timestamps
      • are after the messages were published
    • message IDs
      • is unique
    • direction
      • returns paged history backwards by default
      • returns history forward if specified in the options
    • limit
      • defaults to 100
  • #history option
    • :start
      • with milliseconds since epoch value
        • uses this value in the history request
      • with a Time object value
        • converts the value to milliseconds since epoch in the hisotry request
    • :end
      • with milliseconds since epoch value
        • uses this value in the history request
      • with a Time object value
        • converts the value to milliseconds since epoch in the hisotry request
    • when argument start is after end
      • should raise an exception
  • #presence
    • returns a REST Presence object
• using MsgPack protocol
  • #publish
    • with name and data arguments
      • publishes the message and return true indicating success
      • and additional attributes
        • publishes the message with the attributes and return true indicating success
    • with a client_id configured in the ClientOptions
      • publishes the message without a client_id
      • expects a client_id to be added by the realtime service
    • with an array of Hash objects with :name and :data attributes
      • publishes an array of messages in one HTTP request
    • with an array of Message objects
      • publishes an array of messages in one HTTP request
    • without adequate permissions on the channel
      • raises a permission error when publishing
    • null attributes
      • when name is null
        • publishes the message without a name attribute in the payload
      • when data is null
        • publishes the message without a data attribute in the payload
      • with neither name or data attributes
        • publishes the message without any attributes in the payload
    • identified clients
      • when authenticated with a wildcard client_id
        • with a valid client_id in the message
          • succeeds
        • with a wildcard client_id in the message
          • throws an exception
        • with an empty client_id in the message
          • succeeds and publishes without a client_id
      • when authenticated with a Token string with an implicit client_id
        • without having a confirmed identity
          • with a valid client_id in the message
            • succeeds
          • with an invalid client_id in the message
            • succeeds in the client library but then fails when published to Ably
          • with an empty client_id in the message
            • succeeds and publishes with an implicit client_id
      • when authenticated with TokenDetails with a valid client_id
        • with a valid client_id in the message
          • succeeds
        • with a wildcard client_id in the message
          • throws an exception
        • with an invalid client_id in the message
          • throws an exception
        • with an empty client_id in the message
          • succeeds and publishes with an implicit client_id
      • when anonymous and no client_id
        • with a client_id in the message
          • throws an exception
        • with a wildcard client_id in the message
          • throws an exception
        • with an empty client_id in the message
          • succeeds and publishes with an implicit client_id
    • with a non ASCII channel name
      • stubbed
        • correctly encodes the channel name
  • #history
    • returns a PaginatedResult model
    • returns the current message history for the channel
    • returns paged history using the PaginatedResult model
    • message timestamps
      • are after the messages were published
    • message IDs
      • is unique
    • direction
      • returns paged history backwards by default
      • returns history forward if specified in the options
    • limit
      • defaults to 100
  • #history option
    • :start
      • with milliseconds since epoch value
        • uses this value in the history request
      • with a Time object value
        • converts the value to milliseconds since epoch in the hisotry request
    • :end
      • with milliseconds since epoch value
        • uses this value in the history request
      • with a Time object value
        • converts the value to milliseconds since epoch in the hisotry request
    • when argument start is after end
      • should raise an exception
  • #presence
    • returns a REST Presence object

Ably::Auth

(see lib/submodules/ably-ruby/spec/acceptance/rest/auth_spec.rb)

• using JSON protocol
  • has immutable options
  • #request_token
    • creates a TokenRequest automatically and sends it to Ably to obtain a token
    • returns a valid TokenDetails object in the expected format with valid issued and expires attributes
    • with token_param :client_id
      • overrides default and uses camelCase notation for attributes
    • with token_param :capability
      • overrides default and uses camelCase notation for attributes
    • with token_param :nonce
      • overrides default and uses camelCase notation for attributes
    • with token_param :timestamp
      • overrides default and uses camelCase notation for attributes
    • with token_param :ttl
      • overrides default and uses camelCase notation for attributes
    • with :key option
      • key_name is used in request and signing uses key_secret
    • with :key_name & :key_secret options
      • key_name is used in request and signing uses key_secret
    • with :query_time option
      • queries the server for the time (#RSA10k)
    • without :query_time option
      • does not query the server for the time
    • with :auth_url option merging
      • with existing configured auth options
        • using unspecified :auth_method
          • requests a token using a GET request with provided headers, and merges client_id into auth_params
          • with provided token_params
            • merges provided token_params with existing auth_params and client_id
          • with provided auth option auth_params and auth_headers
            • replaces any preconfigured auth_params
        • using :get :auth_method and query params in the URL
          • requests a token using a GET request with provided headers, and merges client_id into auth_params and existing URL querystring into new URL querystring
        • using :post :auth_method
          • requests a token using a POST request with provided headers, and merges client_id into auth_params as form-encoded post data
    • with :auth_url option
      • when response from :auth_url is a valid token request
        • requests a token from :auth_url using an HTTP GET request
        • returns a valid token generated from the token request
        • with :query_params
          • requests a token from :auth_url with the :query_params
        • with :headers
          • requests a token from :auth_url with the HTTP headers set
        • with POST
          • requests a token from :auth_url using an HTTP POST instead of the default GET
      • when response from :auth_url is a token details object
        • returns TokenDetails created from the token JSON
      • when response from :auth_url is text/plain content type and a token string
        • returns TokenDetails created from the token JSON
      • when response is invalid
        • 500
          • raises ServerError
        • XML
          • raises InvalidResponseBody
    • with a Proc for the :auth_callback option
      • that returns a TokenRequest
        • calls the Proc with token_params when authenticating to obtain the request token
        • uses the token request returned from the callback when requesting a new token
        • when authorized
          • sets Auth#client_id to the new token's client_id
          • sets Client#client_id to the new token's client_id
      • that returns a TokenDetails JSON object
        • calls the lambda when authenticating to obtain the request token
        • uses the token request returned from the callback when requesting a new token
        • when authorized
          • sets Auth#client_id to the new token's client_id
          • sets Client#client_id to the new token's client_id
      • that returns a TokenDetails object
        • uses the token request returned from the callback when requesting a new token
      • that returns a Token string
        • uses the token request returned from the callback when requesting a new token
    • with auth_option :client_id
      • returns a token with the client_id
    • with token_param :client_id
      • returns a token with the client_id
  • before #authorize has been called
    • has no current_token_details
  • #authorize (#RSA10, #RSA10j)
    • updates the persisted token params that are then used for subsequent authorize requests
    • updates the persisted auth options that are then used for subsequent authorize requests
    • when called for the first time since the client has been instantiated
      • passes all auth_options and token_params to #request_token
      • returns a valid token
      • issues a new token every time (#RSA10a)
    • query_time: true with authorize
      • only queries the server time once and then works out the offset, query_time option is never persisted (#RSA10k)
    • query_time: true ClientOption when instanced
      • only queries the server time once and then works out the offset, query_time option is never persisted (#RSA10k)
    • TokenParams argument
      • has no effect on the defaults when null and TokenParam defaults remain the same
      • updates defaults when present and all previous configured TokenParams are discarded (#RSA10g)
      • updates Auth#token_params attribute with an immutable hash
      • uses TokenParams#timestamp for this request but obtains a new timestamp for subsequence requests (#RSA10g)
    • AuthOptions argument
      • has no effect on the defaults when null and AuthOptions defaults remain the same
      • updates defaults when present and all previous configured AuthOptions are discarded (#RSA10g)
      • updates Auth#options attribute with an immutable hash
      • uses AuthOptions#query_time for this request and will not query_time for subsequent requests (#RSA10g)
      • uses AuthOptions#query_time for this request and will query_time again if provided subsequently
    • with previous authorisation
      • requests a new token if token is expired
      • issues a new token every time #authorize is called
    • with a lambda for the :auth_callback option
      • calls the lambda
      • uses the token request returned from the callback when requesting a new token
      • for every subsequent #request_token
        • without a :auth_callback lambda
          • calls the originally provided block
        • with a provided block
          • does not call the originally provided lambda and calls the new #request_token :auth_callback lambda
    • with an explicit token string that expires
      • and a lambda for the :auth_callback option to provide a means to renew the token
        • calls the lambda once the token has expired and the new token is used
    • with an explicit ClientOptions client_id
      • and an incompatible client_id in a TokenDetails object passed to the auth callback
        • rejects a TokenDetails object with an incompatible client_id and raises an exception
      • and an incompatible client_id in a TokenRequest object passed to the auth callback and raises an exception
        • rejects a TokenRequests object with an incompatible client_id and raises an exception
      • and a token string without any retrievable client_id
        • rejects a TokenRequests object with an incompatible client_id and raises an exception
  • #create_token_request
    • returns a TokenRequest object
    • returns a TokenRequest that can be passed to a client that can use it for authentication without an API key
    • uses the key name from the client
    • specifies no TTL (#RSA5)
    • specifies no capability (#RSA6)
    • with a :ttl option below the Token expiry buffer that ensures tokens are renewed 15s before they expire as they are considered expired
      • uses the Token expiry buffer default + 10s to allow for a token request in flight
    • the nonce
      • is unique for every request
      • is at least 16 characters
    • with token param :ttl
      • overrides default
    • with token param :nonce
      • overrides default
    • with token param :client_id
      • overrides default
    • when specifying capability
      • overrides the default
      • uses these capabilities when Ably issues an actual token
    • with additional invalid attributes
      • are ignored
    • when required fields are missing
      • should raise an exception if key secret is missing
      • should raise an exception if key name is missing
    • timestamp attribute
      • is a Time object in Ruby and is set to the local time
      • with :query_time auth_option
        • queries the server for the timestamp
      • with :timestamp option
        • uses the provided timestamp in the token request
    • signing
      • generates a valid HMAC
      • lexicographic ordering of channels and operations
        • HMAC is lexicographic ordered and thus the HMAC is identical
        • is valid when used for authentication
  • using token authentication
    • with :token option
      • authenticates successfully using the provided :token
      • disallows publishing on unspecified capability channels
      • fails if timestamp is invalid
      • cannot be renewed automatically
      • and the token expires
        • should indicate an error and not retry the request (#RSA4a)
    • when implicit as a result of using :client_id
      • and requests to the Ably server are mocked
        • will send a token request to the server
      • a token is created
        • before a request is made
        • when a message is published
        • with capability and TTL defaults (#TK2a, #TK2b)
        • #client_id contains the client_id
    • when token expires
      • automatically renews the token (#RSA4b)
      • fails if the token renewal fails (#RSA4b)
    • when :client_id is provided in a token
      • #client_id contains the client_id
  • #client_id_validated?
    • when using basic auth
      • is false as basic auth users do not have an identity
    • when using a token auth string for a token with a client_id
      • is false as identification is not possible from an opaque token string
    • when using a token
      • with a client_id
        • is true
      • with no client_id (anonymous)
        • is true
      • with a wildcard client_id (anonymous)
        • is false
    • when using a token request with a client_id
      • is not true as identification is not confirmed until authenticated
      • after authentication
        • is true as identification is completed during implicit authentication
  • when using a :key and basic auth
    • #using_token_auth? is false
    • #key attribute contains the key string
    • #using_basic_auth? is true
  • deprecated #authorise
    • FAILED: logs a deprecation warning (#RSA10l)
    • FAILED: returns a valid token (#RSA10l)
• using MsgPack protocol
  • has immutable options
  • #request_token
    • creates a TokenRequest automatically and sends it to Ably to obtain a token
    • returns a valid TokenDetails object in the expected format with valid issued and expires attributes
    • with token_param :client_id
      • overrides default and uses camelCase notation for attributes
    • with token_param :capability
      • overrides default and uses camelCase notation for attributes
    • with token_param :nonce
      • overrides default and uses camelCase notation for attributes
    • with token_param :timestamp
      • overrides default and uses camelCase notation for attributes
    • with token_param :ttl
      • overrides default and uses camelCase notation for attributes
    • with :key option
      • key_name is used in request and signing uses key_secret
    • with :key_name & :key_secret options
      • key_name is used in request and signing uses key_secret
    • with :query_time option
      • queries the server for the time (#RSA10k)
    • without :query_time option
      • does not query the server for the time
    • with :auth_url option merging
      • with existing configured auth options
        • using unspecified :auth_method
          • requests a token using a GET request with provided headers, and merges client_id into auth_params
          • with provided token_params
            • merges provided token_params with existing auth_params and client_id
          • with provided auth option auth_params and auth_headers
            • replaces any preconfigured auth_params
        • using :get :auth_method and query params in the URL
          • requests a token using a GET request with provided headers, and merges client_id into auth_params and existing URL querystring into new URL querystring
        • using :post :auth_method
          • requests a token using a POST request with provided headers, and merges client_id into auth_params as form-encoded post data
    • with :auth_url option
      • when response from :auth_url is a valid token request
        • requests a token from :auth_url using an HTTP GET request
        • returns a valid token generated from the token request
        • with :query_params
          • requests a token from :auth_url with the :query_params
        • with :headers
          • requests a token from :auth_url with the HTTP headers set
        • with POST
          • requests a token from :auth_url using an HTTP POST instead of the default GET
      • when response from :auth_url is a token details object
        • returns TokenDetails created from the token JSON
      • when response from :auth_url is text/plain content type and a token string
        • returns TokenDetails created from the token JSON
      • when response is invalid
        • 500
          • raises ServerError
        • XML
          • raises InvalidResponseBody
    • with a Proc for the :auth_callback option
      • that returns a TokenRequest
        • calls the Proc with token_params when authenticating to obtain the request token
        • uses the token request returned from the callback when requesting a new token
        • when authorized
          • sets Auth#client_id to the new token's client_id
          • sets Client#client_id to the new token's client_id
      • that returns a TokenDetails JSON object
        • calls the lambda when authenticating to obtain the request token
        • uses the token request returned from the callback when requesting a new token
        • when authorized
          • sets Auth#client_id to the new token's client_id
          • sets Client#client_id to the new token's client_id
      • that returns a TokenDetails object
        • uses the token request returned from the callback when requesting a new token
      • that returns a Token string
        • uses the token request returned from the callback when requesting a new token
    • with auth_option :client_id
      • returns a token with the client_id
    • with token_param :client_id
      • returns a token with the client_id
  • before #authorize has been called
    • has no current_token_details
  • #authorize (#RSA10, #RSA10j)
    • updates the persisted token params that are then used for subsequent authorize requests
    • updates the persisted auth options that are then used for subsequent authorize requests
    • when called for the first time since the client has been instantiated
      • passes all auth_options and token_params to #request_token
      • returns a valid token
      • issues a new token every time (#RSA10a)
    • query_time: true with authorize
      • only queries the server time once and then works out the offset, query_time option is never persisted (#RSA10k)
    • query_time: true ClientOption when instanced
      • only queries the server time once and then works out the offset, query_time option is never persisted (#RSA10k)
    • TokenParams argument
      • has no effect on the defaults when null and TokenParam defaults remain the same
      • updates defaults when present and all previous configured TokenParams are discarded (#RSA10g)
      • updates Auth#token_params attribute with an immutable hash
      • uses TokenParams#timestamp for this request but obtains a new timestamp for subsequence requests (#RSA10g)
    • AuthOptions argument
      • has no effect on the defaults when null and AuthOptions defaults remain the same
      • updates defaults when present and all previous configured AuthOptions are discarded (#RSA10g)
      • updates Auth#options attribute with an immutable hash
      • uses AuthOptions#query_time for this request and will not query_time for subsequent requests (#RSA10g)
      • uses AuthOptions#query_time for this request and will query_time again if provided subsequently
    • with previous authorisation
      • requests a new token if token is expired
      • issues a new token every time #authorize is called
    • with a lambda for the :auth_callback option
      • calls the lambda
      • uses the token request returned from the callback when requesting a new token
      • for every subsequent #request_token
        • without a :auth_callback lambda
          • calls the originally provided block
        • with a provided block
          • does not call the originally provided lambda and calls the new #request_token :auth_callback lambda
    • with an explicit token string that expires
      • and a lambda for the :auth_callback option to provide a means to renew the token
        • calls the lambda once the token has expired and the new token is used
    • with an explicit ClientOptions client_id
      • and an incompatible client_id in a TokenDetails object passed to the auth callback
        • rejects a TokenDetails object with an incompatible client_id and raises an exception
      • and an incompatible client_id in a TokenRequest object passed to the auth callback and raises an exception
        • rejects a TokenRequests object with an incompatible client_id and raises an exception
      • and a token string without any retrievable client_id
        • rejects a TokenRequests object with an incompatible client_id and raises an exception
  • #create_token_request
    • returns a TokenRequest object
    • returns a TokenRequest that can be passed to a client that can use it for authentication without an API key
    • uses the key name from the client
    • specifies no TTL (#RSA5)
    • specifies no capability (#RSA6)
    • with a :ttl option below the Token expiry buffer that ensures tokens are renewed 15s before they expire as they are considered expired
      • uses the Token expiry buffer default + 10s to allow for a token request in flight
    • the nonce
      • is unique for every request
      • is at least 16 characters
    • with token param :ttl
      • overrides default
    • with token param :nonce
      • overrides default
    • with token param :client_id
      • overrides default
    • when specifying capability
      • overrides the default
      • uses these capabilities when Ably issues an actual token
    • with additional invalid attributes
      • are ignored
    • when required fields are missing
      • should raise an exception if key secret is missing
      • should raise an exception if key name is missing
    • timestamp attribute
      • is a Time object in Ruby and is set to the local time
      • with :query_time auth_option
        • queries the server for the timestamp
      • with :timestamp option
        • uses the provided timestamp in the token request
    • signing
      • generates a valid HMAC
      • lexicographic ordering of channels and operations
        • HMAC is lexicographic ordered and thus the HMAC is identical
        • is valid when used for authentication
  • using token authentication
    • with :token option
      • authenticates successfully using the provided :token
      • disallows publishing on unspecified capability channels
      • fails if timestamp is invalid
      • cannot be renewed automatically
      • and the token expires
        • should indicate an error and not retry the request (#RSA4a)
    • when implicit as a result of using :client_id
      • and requests to the Ably server are mocked
        • will send a token request to the server
      • a token is created
        • before a request is made
        • when a message is published
        • FAILED: with capability and TTL defaults (#TK2a, #TK2b)
        • #client_id contains the client_id
    • when token expires
      • automatically renews the token (#RSA4b)
      • fails if the token renewal fails (#RSA4b)
    • when :client_id is provided in a token
      • #client_id contains the client_id
  • #client_id_validated?
    • when using basic auth
      • is false as basic auth users do not have an identity
    • when using a token auth string for a token with a client_id
      • is false as identification is not possible from an opaque token string
    • when using a token
      • with a client_id
        • is true
      • with no client_id (anonymous)
        • is true
      • with a wildcard client_id (anonymous)
        • is false
    • when using a token request with a client_id
      • is not true as identification is not confirmed until authenticated
      • after authentication
        • is true as identification is completed during implicit authentication
  • when using a :key and basic auth
    • #using_token_auth? is false
    • #key attribute contains the key string
    • #using_basic_auth? is true
  • deprecated #authorise
    • FAILED: logs a deprecation warning (#RSA10l)
    • FAILED: returns a valid token (#RSA10l)

Ably::Rest

(see lib/submodules/ably-ruby/spec/acceptance/rest/base_spec.rb)

• transport protocol
  • when protocol is not defined it defaults to :msgpack
    • uses MsgPack
  • when option {:protocol=>:json} is used
    • uses JSON
  • when option {:use_binary_protocol=>false} is used
    • uses JSON
  • when option {:protocol=>:msgpack} is used
    • uses MsgPack
  • when option {:use_binary_protocol=>true} is used
    • uses MsgPack
• using JSON protocol
  • failed requests
    • due to invalid Auth
      • should raise an InvalidRequest exception with a valid error message and code
    • server error with JSON error response body
      • should raise a ServerError exception
    • 500 server error without a valid JSON response body
      • should raise a ServerError exception
  • token authentication failures
    • when auth#token_renewable?
      • should automatically reissue a token
    • when NOT auth#token_renewable?
      • should raise an TokenExpired exception
• using MsgPack protocol
  • failed requests
    • due to invalid Auth
      • should raise an InvalidRequest exception with a valid error message and code
    • server error with JSON error response body
      • should raise a ServerError exception
    • 500 server error without a valid JSON response body
      • should raise a ServerError exception
  • token authentication failures
    • when auth#token_renewable?
      • should automatically reissue a token
    • when NOT auth#token_renewable?
      • should raise an TokenExpired exception

Ably::Logger

(see lib/submodules/ably-ruby/spec/unit/logger_spec.rb)

• uses the language provided Logger by default
• with a custom Logger
  • with an invalid interface
    • raises an exception
  • with a valid interface
    • FAILED: is used
• with blocks
  • does not call the block unless the log level is met
  • with an exception in the logger block
    • catches the error and continues

Ably::Auth

(see lib/submodules/ably-ruby/spec/unit/auth_spec.rb)

• client_id option
  • with nil value
    • is permitted
  • as UTF_8 string
    • is permitted
    • remains as UTF-8
  • as SHIFT_JIS string
    • gets converted to UTF-8
    • is compatible with original encoding
  • as ASCII_8BIT string
    • gets converted to UTF-8
    • is compatible with original encoding
  • as Integer
    • raises an argument error
• defaults
  • should have no default TTL
  • should have no default capability

Ably::Models::AuthDetails

(see lib/submodules/ably-ruby/spec/unit/models/auth_details_spec.rb)

• behaves like a model
  • attributes
    • #access_token
      • retrieves attribute :access_token
  • #==
    • is true when attributes are the same
    • is false when attributes are not the same
    • is false when class type differs
  • is immutable
    • prevents changes
    • dups options
• ==
  • is true when attributes are the same
  • is false when attributes are not the same
  • is false when class type differs

Ably::Models::Stats

(see lib/submodules/ably-ruby/spec/unit/models/stats_spec.rb)

• #all stats
  • returns a MessageTypes object
  • returns value for message counts
  • returns value for all data transferred
  • returns zero for empty values
  • raises an exception for unknown attributes
  • #all
    • is a MessageCount object
  • #presence
    • is a MessageCount object
  • #messages
    • is a MessageCount object
• #persisted stats
  • returns a MessageTypes object
  • returns value for message counts
  • returns value for all data transferred
  • returns zero for empty values
  • raises an exception for unknown attributes
  • #all
    • is a MessageCount object
  • #presence
    • is a MessageCount object
  • #messages
    • is a MessageCount object
• #inbound stats
  • returns a MessageTraffic object
  • returns value for realtime message counts
  • returns value for all presence data
  • raises an exception for unknown attributes
  • #realtime
    • is a MessageTypes object
  • #rest
    • is a MessageTypes object
  • #webhook
    • is a MessageTypes object
  • #all
    • is a MessageTypes object
• #outbound stats
  • returns a MessageTraffic object
  • returns value for realtime message counts
  • returns value for all presence data
  • raises an exception for unknown attributes
  • #realtime
    • is a MessageTypes object
  • #rest
    • is a MessageTypes object
  • #webhook
    • is a MessageTypes object
  • #all
    • is a MessageTypes object
• #connections stats
  • returns a ConnectionTypes object
  • returns value for tls opened counts
  • returns value for all peak connections
  • returns zero for empty values
  • raises an exception for unknown attributes
  • #tls
    • is a ResourceCount object
  • #plain
    • is a ResourceCount object
  • #all
    • is a ResourceCount object
• #channels stats
  • returns a ResourceCount object
  • returns value for opened counts
  • returns value for peak channels
  • returns zero for empty values
  • raises an exception for unknown attributes
  • #opened
    • is a Integer object
  • #peak
    • is a Integer object
  • #mean
    • is a Integer object
  • #min
    • is a Integer object
  • #refused
    • is a Integer object
• #api_requests stats
  • returns a RequestCount object
  • returns value for succeeded
  • returns value for failed
  • raises an exception for unknown attributes
  • #succeeded
    • is a Integer object
  • #failed
    • is a Integer object
  • #refused
    • is a Integer object
• #token_requests stats
  • returns a RequestCount object
  • returns value for succeeded
  • returns value for failed
  • raises an exception for unknown attributes
  • #succeeded
    • is a Integer object
  • #failed
    • is a Integer object
  • #refused
    • is a Integer object
• #interval_granularity
  • returns the granularity of the interval_id
• #interval_time
  • returns a Time object representing the start of the interval
• class methods
  • #to_interval_id
    • when time zone of time argument is UTC
      • converts time 2014-02-03:05:06 with granularity :month into 2014-02
      • converts time 2014-02-03:05:06 with granularity :day into 2014-02-03
      • converts time 2014-02-03:05:06 with granularity :hour into 2014-02-03:05
      • converts time 2014-02-03:05:06 with granularity :minute into 2014-02-03:05:06
      • fails with invalid granularity
      • fails with invalid time
    • when time zone of time argument is +02:00
      • converts time 2014-02-03:06 with granularity :hour into 2014-02-03:04 at UTC +00:00
  • #from_interval_id
    • converts a month interval_id 2014-02 into a Time object in UTC 0
    • converts a day interval_id 2014-02-03 into a Time object in UTC 0
    • converts an hour interval_id 2014-02-03:05 into a Time object in UTC 0
    • converts a minute interval_id 2014-02-03:05:06 into a Time object in UTC 0
    • fails with an invalid interval_id 14-20
  • #granularity_from_interval_id
    • returns a :month interval_id for 2014-02
    • returns a :day interval_id for 2014-02-03
    • returns a :hour interval_id for 2014-02-03:05
    • returns a :minute interval_id for 2014-02-03:05:06
    • fails with an invalid interval_id 14-20

Ably::Models::HttpPaginatedResponse: #HP1 -> #HP8

(see lib/submodules/ably-ruby/spec/unit/models/http_paginated_result_spec.rb)

• #items
  • returns correct length from body
  • is Enumerable
  • is iterable
  • provides [] accessor method
  • #first gets the first item in page
  • #last gets the last item in page
  • #each
    • returns an enumerator
    • yields each item
• with non paged http response
  • is the last page
  • does not have next page
  • does not support pagination
  • returns nil when accessing next page
  • returns nil when accessing first page
• with paged http response
  • has next page
  • is not the last page
  • supports pagination
  • accessing next page
    • returns another HttpPaginatedResponse
    • retrieves the next page of results
    • does not have a next page
    • is the last page
    • returns nil when trying to access the last page when it is the last page
    • and then first page
      • returns a HttpPaginatedResponse
      • retrieves the first page of results
• response metadata
  • successful response
    • #success? is true
    • #status_code reflects status code
    • #error_code to be empty
    • #error_message to be empty
    • #headers to be a hash
  • failed response
    • #success? is false
    • #status_code reflects status code
    • #error_code to be populated
    • #error_message to be populated
    • #headers to be present
• #items Array conversion and nil handling #HP3
  • with Json Array
    • is an array
  • with Json Object
    • is an array
  • with empty response
    • is an array
  • with nil response
    • is an array

Ably::Models::TokenRequest

(see lib/submodules/ably-ruby/spec/unit/models/token_request_spec.rb)

• behaves like a model
  • attributes
    • #key_name
      • retrieves attribute :key_name
    • #client_id
      • retrieves attribute :client_id
    • #nonce
      • retrieves attribute :nonce
    • #mac
      • retrieves attribute :mac
  • #==
    • is true when attributes are the same
    • is false when attributes are not the same
    • is false when class type differs
  • is immutable
    • prevents changes
    • dups options
• attributes
  • #capability
    • retrieves attribute :capability as parsed JSON
  • #timestamp
    • with :timestamp option as milliseconds in constructor
      • retrieves attribute :timestamp as Time
    • with :timestamp option as Time in constructor
      • retrieves attribute :timestamp as Time
    • when converted to JSON
      • is in milliseconds since epoch
  • #ttl
    • with :ttl option as milliseconds in constructor
      • retrieves attribute :ttl as seconds
    • when converted to JSON
      • is in milliseconds since epoch
• ==
  • is true when attributes are the same
  • is false when attributes are not the same
  • is false when class type differs
• from_json (#TE6)
  • with Ruby idiomatic Hash object
    • returns a valid TokenRequest object
  • with JSON-like object
    • returns a valid TokenRequest object
  • with JSON string
    • returns a valid TokenRequest object

Ably::Models::ConnectionDetails

(see lib/submodules/ably-ruby/spec/unit/models/connection_details_spec.rb)

• behaves like a model
  • attributes
    • #client_id
      • retrieves attribute :client_id
    • #connection_key
      • retrieves attribute :connection_key
    • #max_message_size
      • retrieves attribute :max_message_size
    • #max_frame_size
      • retrieves attribute :max_frame_size
    • #max_inbound_rate
      • retrieves attribute :max_inbound_rate
  • #==
    • is true when attributes are the same
    • is false when attributes are not the same
    • is false when class type differs
  • is immutable
    • prevents changes
    • dups options
• attributes
  • #connection_state_ttl (#CD2f)
    • retrieves attribute :connection_state_ttl and converts it from ms to s
  • #max_idle_interval (#CD2h)
    • retrieves attribute :max_idle_interval and converts it from ms to s
• ==
  • is true when attributes are the same
  • is false when attributes are not the same
  • is false when class type differs

Ably::Models::PresenceMessage

(see lib/submodules/ably-ruby/spec/unit/models/presence_message_spec.rb)

• behaves like a model
  • attributes
    • #id
      • retrieves attribute :id
    • #client_id
      • retrieves attribute :client_id
    • #data
      • retrieves attribute :data
    • #encoding
      • retrieves attribute :encoding
  • #==
    • is true when attributes are the same
    • is false when attributes are not the same
    • is false when class type differs
  • is immutable
    • prevents changes
    • dups options
• #connection_id attribute
  • when this model has a connectionId attribute
    • but no protocol message
      • uses the model value
    • with a protocol message with a different connectionId
      • uses the model value
  • when this model has no connectionId attribute
    • and no protocol message
      • uses the model value
    • with a protocol message with a connectionId
      • uses the model value
• #member_key attribute
  • is string in format connection_id:client_id
  • with the same client id across multiple connections
    • is unique
  • with a single connection and different client_ids
    • is unique
• #timestamp
  • retrieves attribute :timestamp as a Time object from ProtocolMessage
• initialized with
  • :client_id
    • as UTF_8 string
      • is permitted
      • remains as UTF-8
    • as SHIFT_JIS string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as ASCII_8BIT string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as Integer
      • raises an argument error
    • as Nil
      • is permitted
  • :connection_id
    • as UTF_8 string
      • is permitted
      • remains as UTF-8
    • as SHIFT_JIS string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as ASCII_8BIT string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as Integer
      • raises an argument error
    • as Nil
      • is permitted
  • :encoding
    • as UTF_8 string
      • is permitted
      • remains as UTF-8
    • as SHIFT_JIS string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as ASCII_8BIT string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as Integer
      • raises an argument error
    • as Nil
      • is permitted
• #from_encoded (#TP4)
  • with no encoding
    • returns a presence message object
    • with a block
      • does not call the block
  • with an encoding
    • returns a presence message object
  • with a custom encoding
    • returns a presence message object with the residual incompatible transforms left in the encoding property
  • with a Cipher encoding
    • returns a presence message object with the residual incompatible transforms left in the encoding property
  • with invalid Cipher encoding
    • without a block
      • raises an exception
    • with a block
      • calls the block with the exception
• #from_encoded_array (#TP4)
  • with no encoding
    • returns an Array of presence message objects
• #shallow_clone
  • with inherited attributes from ProtocolMessage
    • creates a duplicate of the message without any ProtocolMessage dependency
  • with embedded attributes for all fields
    • creates a duplicate of the message without any ProtocolMessage dependency
  • with new attributes passed in to the method
    • creates a duplicate of the message without any ProtocolMessage dependency
    • with an invalid ProtocolMessage (missing an ID)
      • allows an ID to be passed in to the shallow clone that takes precedence
    • with mixing of cases
      • resolves case issues and can use camelCase or snake_case

Ably::Models::ErrorInfo

(see lib/submodules/ably-ruby/spec/unit/models/error_info_spec.rb)

• behaves like a model
  • attributes
    • #code
      • retrieves attribute :code
    • #status_code
      • retrieves attribute :status_code
    • #message
      • retrieves attribute :message
  • #==
    • is true when attributes are the same
    • is false when attributes are not the same
    • is false when class type differs
  • is immutable
    • prevents changes
    • dups options
• #status
  • is an alias for #status_code

Ably::Models::Message

(see lib/submodules/ably-ruby/spec/unit/models/message_spec.rb)

• behaves like a model
  • attributes
    • #id
      • retrieves attribute :id
    • #name
      • retrieves attribute :name
    • #client_id
      • retrieves attribute :client_id
    • #data
      • retrieves attribute :data
    • #encoding
      • retrieves attribute :encoding
  • #==
    • is true when attributes are the same
    • is false when attributes are not the same
    • is false when class type differs
  • is immutable
    • prevents changes
    • dups options
• #timestamp
  • retrieves attribute :timestamp as Time object from ProtocolMessage
• #extras (#TM2i)
  • when missing
    • is nil
  • when a string
    • raises an exception
  • when a Hash
    • contains a Hash Json object
  • when a Json Array
    • contains a Json Array object
• #connection_id attribute
  • when this model has a connectionId attribute
    • but no protocol message
      • uses the model value
    • with a protocol message with a different connectionId
      • uses the model value
  • when this model has no connectionId attribute
    • and no protocol message
      • uses the model value
    • with a protocol message with a connectionId
      • uses the model value
• initialized with
  • :name
    • as UTF_8 string
      • is permitted
      • remains as UTF-8
    • as SHIFT_JIS string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as ASCII_8BIT string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as Integer
      • raises an argument error
    • as Nil
      • is permitted
  • :client_id
    • as UTF_8 string
      • is permitted
      • remains as UTF-8
    • as SHIFT_JIS string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as ASCII_8BIT string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as Integer
      • raises an argument error
    • as Nil
      • is permitted
  • :encoding
    • as UTF_8 string
      • is permitted
      • remains as UTF-8
    • as SHIFT_JIS string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as ASCII_8BIT string
      • gets converted to UTF-8
      • is compatible with original encoding
    • as Integer
      • raises an argument error
    • as Nil
      • is permitted
• #from_encoded (#TM3)
  • with no encoding
    • returns a message object
    • with a block
      • does not call the block
  • with an encoding
    • returns a message object
  • with a custom encoding
    • returns a message object with the residual incompatible transforms left in the encoding property
  • with a Cipher encoding
    • returns a message object with the residual incompatible transforms left in the encoding property
  • with invalid Cipher encoding
    • without a block
      • raises an exception
    • with a block
      • calls the block with the exception
• #from_encoded_array (#TM3)
  • with no encoding
    • returns an Array of message objects

Ably::Models::ProtocolMessage

(see lib/submodules/ably-ruby/spec/unit/models/protocol_message_spec.rb)

• behaves like a model
  • attributes
    • #id
      • retrieves attribute :id
    • #channel
      • retrieves attribute :channel
    • #channel_serial
      • retrieves attribute :channel_serial
    • #connection_id
      • retrieves attribute :connection_id
    • #connection_key
      • retrieves attribute :connection_key
  • #==
    • is true when attributes are the same
    • is false when attributes are not the same
    • is false when class type differs
  • is immutable
    • prevents changes
    • dups options
• attributes
  • #timestamp
    • retrieves attribute :timestamp as Time object
  • #count
    • when missing
      • is 1
    • when non numeric
      • is 1
    • when greater than 1
      • is the value of count
  • #message_serial
    • converts :msg_serial to an Integer
  • #has_message_serial?
    • without msg_serial
      • returns false
    • with msg_serial
      • returns true
  • #connection_serial
    • converts :connection_serial to an Integer
  • #flags (#TR4i)
    • when nil
      • is zero
    • when numeric
      • is an Integer
    • when presence flag present
      • #has_presence_flag? is true
      • #has_channel_resumed_flag? is false
    • when channel resumed flag present
      • #has_channel_resumed_flag? is true
      • #has_presence_flag? is false
    • when channel resumed and presence flags present
      • #has_channel_resumed_flag? is true
      • #has_presence_flag? is true
    • when has another future flag
      • #has_presence_flag? is false
      • #has_backlog_flag? is true
  • #has_connection_serial?
    • without connection_serial
      • returns false
    • with connection_serial
      • returns true
  • #serial
    • with underlying msg_serial
      • converts :msg_serial to an Integer
    • with underlying connection_serial
      • converts :connection_serial to an Integer
    • with underlying connection_serial and msg_serial
      • prefers connection_serial and converts :connection_serial to an Integer
  • #has_serial?
    • without msg_serial or connection_serial
      • returns false
    • with msg_serial
      • returns true
    • with connection_serial
      • returns true
  • #error
    • with no error attribute
      • returns nil
    • with nil error
      • returns nil
    • with error
      • returns a valid ErrorInfo object
  • #messages (#TR4k)
    • contains Message objects
  • #presence (#TR4l)
    • contains PresenceMessage objects
  • #connection_details (#TR4o)
    • with a JSON value
      • contains a ConnectionDetails object
      • contains the attributes from the JSON connectionDetails
    • without a JSON value
      • contains an empty ConnectionDetails object
  • #auth (#TR4p)
    • with a JSON value
      • contains a AuthDetails object
      • contains the attributes from the JSON auth details
    • without a JSON value
      • contains an empty AuthDetails object
  • #connection_key (#TR4e)
    • existing only in #connection_details.connection_key
      • is returned
    • existing in both #connection_key and #connection_details.connection_key
      • returns #connection_details.connection_key as #connection_key will be deprecated > 0.8

Ably::Models::ConnectionStateChange

(see lib/submodules/ably-ruby/spec/unit/models/connection_state_change_spec.rb)

• #current (#TA2)
  • is required
  • is an attribute
• #previous(#TA2)
  • is required
  • is an attribute
• #event(#TA5)
  • is not required
  • is an attribute
• #retry_in (#TA2)
  • is not required
  • is an attribute
• #reason (#TA3)
  • is not required
  • is an attribute
• invalid attributes
  • raises an argument error

Ably::Models::TokenDetails

(see lib/submodules/ably-ruby/spec/unit/models/token_details_spec.rb)

• behaves like a model
  • attributes
    • #token
      • retrieves attribute :token
    • #key_name
      • retrieves attribute :key_name
    • #client_id
      • retrieves attribute :client_id
  • #==
    • is true when attributes are the same
    • is false when attributes are not the same
    • is false when class type differs
  • is immutable
    • prevents changes
    • dups options
• attributes
  • #capability
    • retrieves attribute :capability as parsed JSON
  • • #issued with :issued option as milliseconds in constructor
      • retrieves attribute :issued as Time
    • #issued with :issued option as a Time in constructor
      • retrieves attribute :issued as Time
    • #issued when converted to JSON
      • is in milliseconds
    • #expires with :expires option as milliseconds in constructor
      • retrieves attribute :expires as Time
    • #expires with :expires option as a Time in constructor
      • retrieves attribute :expires as Time
    • #expires when converted to JSON
      • is in milliseconds
  • #expired?
    • once grace period buffer has passed
      • is true
    • within grace period buffer
      • is false
    • when expires is not available (i.e. string tokens)
      • is always false
• ==
  • is true when attributes are the same
  • is false when attributes are not the same
  • is false when class type differs
• to_json
  • with all attributes and values
    • returns all attributes
  • with only a token string
    • returns populated attributes
• from_json (#TD7)
  • with Ruby idiomatic Hash object
    • returns a valid TokenDetails object
  • with JSON-like object
    • returns a valid TokenDetails object
  • with JSON string
    • returns a valid TokenDetails object

Ably::Models::PaginatedResult

(see lib/submodules/ably-ruby/spec/unit/models/paginated_result_spec.rb)

• #items
  • returns correct length from body
  • is Enumerable
  • is iterable
  • provides [] accessor method
  • #first gets the first item in page
  • #last gets the last item in page
  • #each
    • returns an enumerator
    • yields each item
• with non paged http response
  • is the last page
  • does not have next page
  • does not support pagination
  • returns nil when accessing next page
  • returns nil when accessing first page
• with paged http response
  • has next page
  • is not the last page
  • supports pagination
  • accessing next page
    • returns another PaginatedResult
    • retrieves the next page of results
    • does not have a next page
    • is the last page
    • returns nil when trying to access the last page when it is the last page
    • and then first page
      • returns a PaginatedResult
      • retrieves the first page of results

Ably::Models::ChannelStateChange

(see lib/submodules/ably-ruby/spec/unit/models/channel_state_change_spec.rb)

• #current (#TH1)
  • is required
  • is an attribute
• #previous (#TH2)
  • is required
  • is an attribute
• #event (#TH5)
  • is not required
  • is an attribute
• #reason (#TH3)
  • is not required
  • is an attribute
• #resumed (#TH4)
  • is false when ommitted
  • is true when provided
• invalid attributes
  • raises an argument error

Ably::Models::CipherParams

(see lib/submodules/ably-ruby/spec/unit/models/cipher_params_spec.rb)

• :key missing from constructor
  • raises an exception
• #key
  • with :key in constructor
    • as nil
      • raises an exception
    • as a base64 encoded string
      • is a binary representation of the base64 encoded string
    • as a URL safe base64 encoded string
      • is a binary representation of the URL safe base64 encoded string
    • as a binary encoded string
      • contains the binary string
    • with an incompatible :key_length constructor param
      • raises an exception
    • with an unsupported :key_length for aes-cbc encryption
      • raises an exception
    • with an invalid type
      • raises an exception
• with specified params in the constructor
  • #cipher_type
    • contains the complete algorithm string as an upper case string
  • #mode
    • contains the mode
  • #algorithm
    • contains the algorithm
  • #key_length
    • contains the key_length
• with combined param in the constructor
  • #cipher_type
    • contains the complete algorithm string as an upper case string
  • #mode
    • contains the mode
  • #algorithm
    • contains the algorithm
  • #key_length
    • contains the key_length

Ably::Rest::Client

(see lib/submodules/ably-ruby/spec/unit/rest/client_spec.rb)

• behaves like a client initializer
  • with invalid arguments
    • empty hash
      • raises an exception
    • nil
      • raises an exception
    • key: "invalid"
      • raises an exception
    • key: "invalid:asdad"
      • raises an exception
    • key and key_name
      • raises an exception
    • key and key_secret
      • raises an exception
    • client_id as only option
      • requires a valid key
  • with valid arguments
    • key only
      • connects to the Ably service
      • uses basic auth
    • with a string key instead of options hash
      • sets the key
      • sets the key_name
      • sets the key_secret
      • uses basic auth
    • with a string token key instead of options hash
      • sets the token
    • with token
      • sets the token
    • with token_details
      • sets the token
    • with token_params
      • configures default_token_params
    • endpoint
      • defaults to production
      • with environment option
        • uses an alternate endpoint
      • with rest_host option
        • uses an alternate endpoint for REST clients
      • with realtime_host option
        • PENDING: uses an alternate endpoint for Realtime clients
      • with port option and non-TLS connections
        • uses the custom port for non-TLS requests
      • with tls_port option and a TLS connection
        • uses the custom port for TLS requests
    • tls
      • defaults to TLS
      • set to false
        • uses plain text
        • uses HTTP
    • logger
      • default
        • uses Ruby Logger
        • specifies Logger::WARN log level
      • with log_level :none
        • silences all logging with a NilLogger
      • with custom logger and log_level
        • FAILED: uses the custom logger
        • FAILED: sets the custom log level
  • delegators
    • delegates :client_id to .auth
    • delegates :auth_options to .auth
• initializer options
  • TLS
    • disabled
      • fails for any operation with basic auth and attempting to send an API key over a non-secure connection (#RSA1)
  • :use_token_auth
    • set to false
      • with a key and :tls => false
        • fails for any operation with basic auth and attempting to send an API key over a non-secure connection
      • without a key
        • fails as a key is required if not using token auth
    • set to true
      • without a key or token
        • fails as a key is required to issue tokens
• request_id generation
  • includes request_id in URL

Ably::Rest::Channels

(see lib/submodules/ably-ruby/spec/unit/rest/channels_spec.rb)

• creating channels
  • #get creates a channel
  • #get will reuse the channel object
  • [] creates a channel
• #fetch
  • retrieves a channel if it exists
  • calls the block if channel is missing
• destroying channels
  • #release releases the channel resoures
• is Enumerable
  • allows enumeration
  • provides #length
  • #each
    • returns an enumerator
    • yields each channel

Ably::Rest

(see lib/submodules/ably-ruby/spec/unit/rest/rest_spec.rb)

• constructor returns an Ably::Rest::Client

Ably::Rest::Channel

(see lib/submodules/ably-ruby/spec/unit/rest/channel_spec.rb)

• #initializer
  • as UTF_8 string
    • is permitted
    • remains as UTF-8
  • as frozen UTF_8 string
    • is permitted
    • remains as UTF-8
  • as SHIFT_JIS string
    • gets converted to UTF-8
    • is compatible with original encoding
  • as ASCII_8BIT string
    • gets converted to UTF-8
    • is compatible with original encoding
  • as Integer
    • raises an argument error
  • as Nil
    • raises an argument error
• #publish name argument
  • as UTF_8 string
    • is permitted
  • as frozen UTF_8 string
    • is permitted
  • as SHIFT_JIS string
    • is permitted
  • as ASCII_8BIT string
    • is permitted
  • as Integer
    • raises an argument error

Ably::Util::Crypto

(see lib/submodules/ably-ruby/spec/unit/util/crypto_spec.rb)

• defaults
  • match other client libraries
• get_default_params
  • with just a :key param
    • uses the defaults
    • contains the provided key
    • returns a CipherParams object
  • without a :key param
    • raises an exception
  • with a base64-encoded :key param
    • converts the key to binary
  • with provided params
    • overrides the defaults
• encrypts & decrypt
  • #encrypt encrypts a string
  • #decrypt decrypts a string
• encrypting an empty string
  • raises an ArgumentError
• using shared client lib fixture data
  • with AES-128-CBC
    • behaves like an Ably encrypter and decrypter (#RTL7d)
      • text payload
        • encrypts exactly the same binary data as other client libraries
        • decrypts exactly the same binary data as other client libraries
  • with AES-256-CBC
    • behaves like an Ably encrypter and decrypter (#RTL7d)
      • text payload
        • encrypts exactly the same binary data as other client libraries
        • decrypts exactly the same binary data as other client libraries

---

Test summary

• Passing tests: 1186
• Pending tests: 1
• Failing tests: 0