ably 0.1.0

data/spec/acceptance/rest/base_spec.rb

@@ -0,0 +1,113 @@
+require "spec_helper"
+require "securerandom"
+
+describe "REST" do
+  let(:client) do
+    Ably::Rest::Client.new(api_key: api_key, environment: environment)
+  end
+
+  describe "invalid requests in middleware" do
+    it "should raise a InvalidRequest exception with a valid message" do
+      invalid_client = Ably::Rest::Client.new(api_key: 'appid.keyuid:keysecret')
+      expect { invalid_client.channel('test').publish('foo', 'choo') }.to raise_error do |error|
+        expect(error).to be_a(Ably::InvalidRequest)
+        expect(error.message).to match(/invalid credentials/)
+        expect(error.code).to eql(40100)
+        expect(error.status).to eql(401)
+      end
+    end
+
+    describe "server error with JSON response", webmock: true do
+      let(:error_response) { '{ "error": { "statusCode": 500, "code": 50000, "message": "Internal error" } }' }
+
+      before do
+        stub_request(:get, "#{client.endpoint}/time").to_return(:status => 500, :body => error_response, :headers => { 'Content-Type' => 'application/json' })
+      end
+
+      it "should raise a ServerError exception" do
+        expect { client.time }.to raise_error(Ably::ServerError, /Internal error/)
+      end
+    end
+
+    describe "server error", webmock: true do
+      before do
+        stub_request(:get, "#{client.endpoint}/time").to_return(:status => 500)
+      end
+
+      it "should raise a ServerError exception" do
+        expect { client.time }.to raise_error(Ably::ServerError, /Unknown/)
+      end
+    end
+  end
+
+  describe Ably::Rest::Client do
+    context '#initialize' do
+      context 'with an auth block' do
+        let(:client) { Ably::Rest::Client.new(environment: environment) { token_request } }
+        let(:token_request) { client.auth.create_token_request(key_id: key_id, key_secret: key_secret, client_id: client_id) }
+        let(:client_id) { 'unique_client_id' }
+
+        it 'calls the block to get a new token' do
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(client_id)
+        end
+      end
+
+      context 'with an auth URL' do
+        let(:client) { Ably::Rest::Client.new(environment: environment, auth_url: token_request_url, auth_method: :get) }
+        let(:token_request_url) { 'http://get.token.request.com/' }
+        let(:token_request) { client.auth.create_token_request(key_id: key_id, key_secret: key_secret, client_id: client_id) }
+        let(:client_id) { 'unique_client_id' }
+
+        before do
+          allow(client.auth).to receive(:token_request_from_auth_url).with(token_request_url, :auth_method => :get).and_return(token_request)
+        end
+
+        it 'sends an HTTP request to get a new token' do
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(client_id)
+        end
+      end
+    end
+
+    context 'token expiry' do
+      let(:client) do
+        Ably::Rest::Client.new(environment: environment) do
+          @request_index ||= 0
+          @request_index += 1
+          send("token_request_#{@request_index}")
+        end
+      end
+      let(:token_request_1) { client.auth.create_token_request(token_request_options.merge(client_id: SecureRandom.hex)) }
+      let(:token_request_2) { client.auth.create_token_request(token_request_options.merge(client_id: SecureRandom.hex)) }
+
+      context 'when expired' do
+        let(:token_request_options) { { key_id: key_id, key_secret: key_secret, ttl: Ably::Token::TOKEN_EXPIRY_BUFFER } }
+
+        it 'creates a new token automatically when the old token expires' do
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(token_request_1[:client_id])
+
+          sleep 1
+
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(token_request_2[:client_id])
+        end
+      end
+
+      context 'token authentication with long expiry token' do
+        let(:token_request_options) { { key_id: key_id, key_secret: key_secret, ttl: 3600 } }
+
+        it 'creates a new token automatically when the old token expires' do
+          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(token_request_1[:client_id])
+
+          sleep 1
+
+          expect { client.channel('channel_name').publish('event', 'message') }.to_not change { client.auth.current_token }
+          expect(client.auth.current_token.client_id).to eql(token_request_1[:client_id])
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/rest/channel_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+require "securerandom"
+
+describe "REST" do
+  let(:client) do
+    Ably::Rest::Client.new(api_key: api_key, environment: environment)
+  end
+
+  describe "publishing messages" do
+    let(:channel) { client.channel("test") }
+    let(:event)   { "foo" }
+    let(:message) { "woop!" }
+
+    it "should publish the message ok" do
+      expect(channel.publish(event, message)).to eql(true)
+    end
+  end
+
+  describe "fetching channel history" do
+    let(:channel) { client.channel("persisted:#{SecureRandom.hex(4)}") }
+    let(:expected_history) do
+      [
+        { :name => "test1", :data => "foo" },
+        { :name => "test2", :data => "bar" },
+        { :name => "test3", :data => "baz" }
+      ]
+    end
+
+    before(:each) do
+      expected_history.each do |message|
+        channel.publish(message[:name], message[:data]) || raise("Unable to publish message")
+      end
+    end
+
+    it "should return all the history for the channel" do
+      actual_history = channel.history
+
+      expect(actual_history.size).to eql(3)
+
+      expected_history.each do |message|
+        expect(actual_history).to include(message)
+      end
+    end
+
+    it "should return paged history" do
+      page_1 = channel.history(limit: 1)
+      page_2 = page_1.next
+      page_3 = page_2.next
+
+      all_items = [page_1[0], page_2[0], page_3[0]]
+      expect(all_items.uniq).to eql(all_items)
+
+      expect(page_1.size).to eql(1)
+      expect(page_1).to_not be_last
+      expect(page_1).to be_first
+
+      # Page 2
+      expect(page_2.size).to eql(1)
+      expect(page_2).to_not be_last
+      expect(page_2).to_not be_first
+
+      # Page 3
+      expect(page_3.size).to eql(1)
+      expect(page_3).to be_last
+      expect(page_3).to_not be_first
+    end
+  end
+end

data/spec/acceptance/rest/presence_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+require "securerandom"
+
+describe "REST" do
+  let(:client) do
+    Ably::Rest::Client.new(api_key: api_key, environment: environment)
+  end
+
+  describe "fetching presence" do
+    let(:channel) { client.channel("persisted:presence_fixtures") }
+    let(:presence) { channel.presence.get }
+
+    it "should return current members on the channel" do
+      expect(presence.size).to eql(4)
+
+      TestApp::APP_SPEC['channels'].first['presence'].each do |presence_hash|
+        presence_match = presence.find { |client| client['clientId'] == presence_hash['clientId'] }
+        expect(presence_match['clientData']).to eql(presence_hash['clientData'])
+      end
+    end
+  end
+end

data/spec/acceptance/rest/stats_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+require "securerandom"
+
+describe "REST" do
+  let(:client) do
+    Ably::Rest::Client.new(api_key: api_key, environment: environment)
+  end
+
+  describe "fetching application stats" do
+    def number_of_channels()             3 end
+    def number_of_messages_per_channel() 5 end
+
+    before(:context) do
+      @context_client = Ably::Rest::Client.new(api_key: api_key, environment: environment)
+
+      # Wait until the start of the next minute according to the service
+      # time because stats are created in 1 minute intervals
+      service_time    = @context_client.time
+      @interval_start = (service_time.to_i / 60 + 1) * 60
+      sleep_time      = @interval_start - Time.now.to_i
+
+      if sleep_time > 30
+        @interval_start -= 60 # there is enough time to generate the stats in this minute interval
+      elsif sleep_time > 0
+        sleep sleep_time
+      end
+
+      number_of_channels.times do |i|
+        channel = @context_client.channel("stats-#{i}")
+
+        number_of_messages_per_channel.times do |j|
+          channel.publish("event-#{j}", "data-#{j}") || raise("Unable to publish message")
+        end
+      end
+
+      sleep(10)
+    end
+
+    [:minute, :hour, :day, :month].each do |interval|
+      context "by #{interval}" do
+        it "should return all the stats for the application" do
+          stats = @context_client.stats(start: @interval_start * 1000, by: interval.to_s, direction: 'forwards')
+
+          expect(stats.size).to eql(1)
+
+          stat = stats.first
+
+          expect(stat[:inbound][:all][:all][:count]).to eql(number_of_channels * number_of_messages_per_channel)
+          expect(stat[:inbound][:rest][:all][:count]).to eql(number_of_channels * number_of_messages_per_channel)
+
+          # TODO: Review number of Channels opened issue for intervals other than minute
+          expect(stat[:channels][:opened]).to eql(number_of_channels) if interval == :minute
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/rest/time_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "securerandom"
+
+describe "REST" do
+  let(:client) do
+    Ably::Rest::Client.new(api_key: api_key, environment: environment)
+  end
+
+  describe "fetching the service time" do
+    it "should return the service time as a Time object" do
+      expect(client.time).to be_within(2).of(Time.now)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'webmock/rspec'
+
+require "ably"
+
+require "support/api_helper"
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.before(:example) do
+    WebMock.disable!
+  end
+
+  config.before(:example, :webmock => true) do
+    WebMock.enable!
+  end
+end

data/spec/support/api_helper.rb

@@ -0,0 +1,41 @@
+require "support/test_app"
+
+module ApiHelper
+  def app_id
+    TestApp.instance.app_id
+  end
+
+  def key_id
+    TestApp.instance.key_id
+  end
+
+  def key_secret
+    api_key.split(':')[1]
+  end
+
+  def api_key
+    TestApp.instance.api_key
+  end
+
+  def environment
+    TestApp.instance.environment
+  end
+
+  def encode64(text)
+    Base64.encode64(text).gsub("\n", '')
+  end
+end
+
+RSpec.configure do |config|
+  config.include ApiHelper
+
+  config.before(:suite) do
+    WebMock.disable!
+    TestApp.instance
+  end
+
+  config.after(:suite) do
+    WebMock.disable!
+    TestApp.instance.delete
+  end
+end

data/spec/support/test_app.rb

@@ -0,0 +1,77 @@
+require "singleton"
+
+class TestApp
+  APP_SPEC = {
+    'keys' => [
+      {}
+    ],
+    'namespaces' => [
+      { 'id' => 'persisted', 'persisted' => true }
+    ]
+    # ],
+    # 'channels' => [
+    #   {
+    #     'name' => 'persisted:presence_fixtures',
+    #     'presence' => [
+    #       { 'clientId' => 'client_bool',    'clientData' => true },
+    #       { 'clientId' => 'client_int',     'clientData' => 24 },
+    #       { 'clientId' => 'client_string',  'clientData' => 'This is a string clientData payload' },
+    #       { 'clientId' => 'client_json',    'clientData' => { "test" => 'This is a JSONObject clientData payload'} }
+    #     ]
+    #   }
+    # ]
+  }.to_json
+
+  include Singleton
+
+  def initialize
+    url = "#{sandbox_client.endpoint}/apps"
+
+    headers = {
+      "Accept"       => "application/json",
+      "Content-Type" => "application/json"
+    }
+
+    response = Faraday.post(url, APP_SPEC, headers)
+
+    @attributes = JSON.parse(response.body)
+  end
+
+  def app_id
+    @attributes["id"]
+  end
+
+  def key
+    @attributes["keys"].first
+  end
+
+  def key_id
+    "#{app_id}.#{key["id"]}"
+  end
+
+  def key_value
+    key["value"]
+  end
+
+  def api_key
+    "#{key_id}:#{key_value}"
+  end
+
+  def delete
+    url = "#{sandbox_client.endpoint}/apps/#{app_id}"
+
+    basic_auth = Base64.encode64(api_key).chomp
+    headers    = { "Authorization" => "Basic #{basic_auth}" }
+
+    Faraday.delete(url, nil, headers)
+  end
+
+  def environment
+    'sandbox'
+  end
+
+  private
+  def sandbox_client
+    @sandbox_client ||= Ably::Rest::Client.new(api_key: 'app.key:secret', tls: true, environment: environment)
+  end
+end

data/spec/unit/auth.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Ably::Auth do
+  let(:client) { Ably::Rest::Client.new(key_id: 'id', key_secret: 'secret') }
+
+  it "should not allow changes to the options" do
+    expect { client.auth.options['key_id'] = 'new_id' }.to raise_error RuntimeError, /can't modify frozen Hash/
+  end
+end

data/spec/unit/realtime_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe Ably::Realtime do
+  let(:options) { { api_key: 'app.key:secret' } }
+
+  specify 'constructor returns an Ably::Realtime::Client' do
+    expect(Ably::Realtime.new(options)).to be_instance_of(Ably::Realtime::Client)
+  end
+end