ably-rest 0.7.5 → 0.8.1

data/lib/submodules/ably-ruby/spec/resources/crypto-data-128.json

@@ -1,56 +0,0 @@
-{
-  "algorithm": "aes",
-  "mode": "cbc",
-  "keylength": 128,
-  "key": "WUP6u0K7MXI5Zeo0VppPwg==",
-  "iv": "HO4cYSP8LybPYBPZPHQOtg==",
-  "items": [
-    {
-      "encoded": {
-        "name": "example",
-        "data": "The quick brown fox jumped over the lazy dog"
-      },
-      "encrypted": {
-        "name": "example",
-        "data": "HO4cYSP8LybPYBPZPHQOtmHItcxYdSvcNUC6kXVpMn0VFL+9z2/5tJ6WFbR0SBT1xhFRuJ+MeBGTU3yOY9P5ow==",
-        "encoding": "utf-8/cipher+aes-128-cbc/base64"
-      }
-    },
-    {
-      "encoded": {
-        "name": "example",
-        "data": "AAECAwQFBgcICQoLDA0ODw==",
-        "encoding": "base64"
-      },
-      "encrypted": {
-        "name": "example",
-        "data": "HO4cYSP8LybPYBPZPHQOtuB3dfKG08yw7J4qx3kkjxdW0eoZv+nGAp76OKqYQ327",
-        "encoding": "cipher+aes-128-cbc/base64"
-      }
-    },
-    {
-      "encoded": {
-        "name": "example",
-        "data": "{\"example\":{\"json\":\"Object\"}}",
-        "encoding": "json"
-      },
-      "encrypted": {
-        "name": "example",
-        "data": "HO4cYSP8LybPYBPZPHQOtuD53yrD3YV3NBoTEYBh4U0N1QXHbtkfsDfTspKeLQFt",
-        "encoding": "json/utf-8/cipher+aes-128-cbc/base64"
-      }
-    },
-    {
-      "encoded": {
-        "name": "example",
-        "data": "[\"example\",\"json\",\"array\"]",
-        "encoding": "json"
-      },
-      "encrypted": {
-        "name": "example",
-        "data": "HO4cYSP8LybPYBPZPHQOtvmStzmExkdjvrn51J6cmaTZrGl+EsJ61sgxmZ6j6jcA",
-        "encoding": "json/utf-8/cipher+aes-128-cbc/base64"
-      }
-    }
-  ]
-}

data/lib/submodules/ably-ruby/spec/resources/crypto-data-256.json

@@ -1,56 +0,0 @@
-{
-  "algorithm": "aes",
-  "mode": "cbc",
-  "keylength": 256,
-  "key": "o9qXZoPGDNla50VnRwH7cGqIrpyagTxGsRgimKJbY40=",
-  "iv": "NMDl1Acnel8HVdu1cEWdrw==",
-  "items": [
-    {
-      "encoded": {
-        "name": "example",
-        "data": "The quick brown fox jumped over the lazy dog"
-      },
-      "encrypted": {
-        "name": "example",
-        "data": "NMDl1Acnel8HVdu1cEWdr9CGPYFoBoLgJCzoybbQbnyfwx3UQ8CGuKyP/g56Za/JB3xW6XGkNzrHYvZwad4fvA==",
-        "encoding": "utf-8/cipher+aes-256-cbc/base64"
-      }
-    },
-    {
-      "encoded": {
-        "name": "example",
-        "data": "AAECAwQFBgcICQoLDA0ODw==",
-        "encoding": "base64"
-      },
-      "encrypted": {
-        "name": "example",
-        "data": "NMDl1Acnel8HVdu1cEWdr8UFEi56Ms0zPHszbppM61BC8Yf6ndq+kiCj9xXW97/O",
-        "encoding": "cipher+aes-256-cbc/base64"
-      }
-    },
-    {
-      "encoded": {
-        "name": "example",
-        "data": "{\"example\":{\"json\":\"Object\"}}",
-        "encoding": "json"
-      },
-      "encrypted": {
-        "name": "example",
-        "data": "NMDl1Acnel8HVdu1cEWdr21pS5//hdtQf3QqQzZM/jWAtn09Vh52E6jMdC3mWS98",
-        "encoding": "json/utf-8/cipher+aes-256-cbc/base64"
-      }
-    },
-    {
-      "encoded": {
-        "name": "example",
-        "data": "[\"example\",\"json\",\"array\"]",
-        "encoding": "json"
-      },
-      "encrypted": {
-        "name": "example",
-        "data": "NMDl1Acnel8HVdu1cEWdr4J5sVAFpnXsz0fTtsuwOaTRU+6P5GaWlNjePWwiOZCQ",
-        "encoding": "json/utf-8/cipher+aes-256-cbc/base64"
-      }
-    }
-  ]
-}

data/lib/submodules/ably-ruby/spec/unit/models/stat_spec.rb

@@ -1,113 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'shared/model_behaviour'
-
-describe Ably::Models::Stat do
-  include Ably::Modules::Conversions
-
-  subject { Ably::Models::Stat }
-
-  it_behaves_like 'a model', with_simple_attributes: %w(interval_id all inbound outbound persisted connections channels api_requests token_requests) do
-    let(:model_args) { [] }
-  end
-
-  describe '#interval_granularity' do
-    subject { Ably::Models::Stat.new(interval_id: '2004-02') }
-
-    it 'returns the granularity of the interval_id' do
-      expect(subject.interval_granularity).to eq(:month)
-    end
-  end
-
-  describe '#interval_time' do
-    subject { Ably::Models::Stat.new(interval_id: '2004-02-01:05:06') }
-
-    it 'returns a Time object representing the start of the interval' do
-      expect(subject.interval_time.to_i).to eql(Time.new(2004, 02, 01, 05, 06, 00, '+00:00').to_i)
-    end
-  end
-
-  context 'class methods' do
-    describe '#to_interval_id' do
-      context 'when time zone of time argument is UTC' do
-        it 'converts time 2014-02-03:05:06 with granularity :month into 2014-02' do
-          expect(subject.to_interval_id(Time.new(2014, 2, 1, 0, 0, 0, '+00:00'), :month)).to eql('2014-02')
-        end
-
-        it 'converts time 2014-02-03:05:06 with granularity :day into 2014-02-03' do
-          expect(subject.to_interval_id(Time.new(2014, 2, 3, 0, 0, 0, '+00:00'), :day)).to eql('2014-02-03')
-        end
-
-        it 'converts time 2014-02-03:05:06 with granularity :hour into 2014-02-03:05' do
-          expect(subject.to_interval_id(Time.new(2014, 2, 3, 5, 0, 0, '+00:00'), :hour)).to eql('2014-02-03:05')
-        end
-
-        it 'converts time 2014-02-03:05:06 with granularity :minute into 2014-02-03:05:06' do
-          expect(subject.to_interval_id(Time.new(2014, 2, 3, 5, 6, 0, '+00:00'), :minute)).to eql('2014-02-03:05:06')
-        end
-
-        it 'fails with invalid granularity' do
-          expect { subject.to_interval_id(Time.now, :invalid) }.to raise_error KeyError
-        end
-
-        it 'fails with invalid time' do
-          expect { subject.to_interval_id(nil, :month) }.to raise_error ArgumentError
-        end
-      end
-
-      context 'when time zone of time argument is +02:00' do
-        it 'converts time 2014-02-03:06 with granularity :hour into 2014-02-03:04 at UTC +00:00' do
-          expect(subject.to_interval_id(Time.new(2014, 2, 3, 6, 0, 0, '+02:00'), :hour)).to eql('2014-02-03:04')
-        end
-      end
-    end
-
-    describe '#from_interval_id' do
-      it 'converts a month interval_id 2014-02 into a Time object in UTC 0' do
-        expect(subject.from_interval_id('2014-02')).to eql(Time.gm(2014, 2))
-        expect(subject.from_interval_id('2014-02').utc_offset).to eql(0)
-      end
-
-      it 'converts a day interval_id 2014-02-03 into a Time object in UTC 0' do
-        expect(subject.from_interval_id('2014-02-03')).to eql(Time.gm(2014, 2, 3))
-        expect(subject.from_interval_id('2014-02-03').utc_offset).to eql(0)
-      end
-
-      it 'converts an hour interval_id 2014-02-03:05 into a Time object in UTC 0' do
-        expect(subject.from_interval_id('2014-02-03:05')).to eql(Time.gm(2014, 2, 3, 5))
-        expect(subject.from_interval_id('2014-02-03:05').utc_offset).to eql(0)
-      end
-
-      it 'converts a minute interval_id 2014-02-03:05:06 into a Time object in UTC 0' do
-        expect(subject.from_interval_id('2014-02-03:05:06')).to eql(Time.gm(2014, 2, 3, 5, 6))
-        expect(subject.from_interval_id('2014-02-03:05:06').utc_offset).to eql(0)
-      end
-
-      it 'fails with an invalid interval_id 14-20' do
-        expect { subject.from_interval_id('14-20') }.to raise_error ArgumentError
-      end
-    end
-
-    describe '#granularity_from_interval_id' do
-      it 'returns a :month interval_id for 2014-02' do
-        expect(subject.granularity_from_interval_id('2014-02')).to eq(:month)
-      end
-
-      it 'returns a :day interval_id for 2014-02-03' do
-        expect(subject.granularity_from_interval_id('2014-02-03')).to eq(:day)
-      end
-
-      it 'returns a :hour interval_id for 2014-02-03:05' do
-        expect(subject.granularity_from_interval_id('2014-02-03:05')).to eq(:hour)
-      end
-
-      it 'returns a :minute interval_id for 2014-02-03:05:06' do
-        expect(subject.granularity_from_interval_id('2014-02-03:05:06')).to eq(:minute)
-      end
-
-      it 'fails with an invalid interval_id 14-20' do
-        expect { subject.granularity_from_interval_id('14-20') }.to raise_error ArgumentError
-      end
-    end
-  end
-end

data/lib/submodules/ably-ruby/spec/unit/models/token_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe Ably::Models::Token do
-  subject { Ably::Models::Token }
-
-  it_behaves_like 'a model', with_simple_attributes: %w(id capability client_id nonce) do
-    let(:model_args) { [] }
-  end
-
-  context 'defaults' do
-    let(:one_hour)          { 60 * 60 }
-    let(:all_capabilities)  { { "*" => ["*"] } }
-
-    it 'should default TTL to 1 hour' do
-      expect(Ably::Models::Token::DEFAULTS[:ttl]).to eql(one_hour)
-    end
-
-    it 'should default capability to all' do
-      expect(Ably::Models::Token::DEFAULTS[:capability]).to eql(all_capabilities)
-    end
-
-    it 'should only have defaults for :ttl and :capability' do
-      expect(Ably::Models::Token::DEFAULTS.keys).to contain_exactly(:ttl, :capability)
-    end
-  end
-
-  context 'attributes' do
-    let(:unique_value) { 'unique_value' }
-
-    context '#key_id' do
-      subject { Ably::Models::Token.new({ key: unique_value }) }
-      it 'retrieves attribute :key' do
-        expect(subject.key_id).to eql(unique_value)
-      end
-    end
-
-    { :issued_at => :issued_at, :expires_at => :expires }.each do |method_name, attribute|
-      let(:time) { Time.now }
-      context "##{method_name}" do
-        subject { Ably::Models::Token.new({ attribute.to_sym => time.to_i }) }
-
-        it "retrieves attribute :#{attribute} as Time" do
-          expect(subject.public_send(method_name)).to be_a(Time)
-          expect(subject.public_send(method_name).to_i).to eql(time.to_i)
-        end
-      end
-    end
-
-    context '#expired?' do
-      let(:expire_time) { Time.now + Ably::Models::Token::TOKEN_EXPIRY_BUFFER }
-
-      context 'once grace period buffer has passed' do
-        subject { Ably::Models::Token.new(expires: expire_time - 1) }
-
-        it 'is true' do
-          expect(subject.expired?).to eql(true)
-        end
-      end
-
-      context 'within grace period buffer' do
-        subject { Ably::Models::Token.new(expires: expire_time + 1) }
-
-        it 'is false' do
-          expect(subject.expired?).to eql(false)
-        end
-      end
-    end
-  end
-
-  context '==' do
-    let(:token_attributes) { { id: 'unique' } }
-
-    it 'is true when attributes are the same' do
-      new_token = -> { Ably::Models::Token.new(token_attributes) }
-      expect(new_token[]).to eq(new_token[])
-    end
-
-    it 'is false when attributes are not the same' do
-      expect(Ably::Models::Token.new(id: 1)).to_not eq(Ably::Models::Token.new(id: 2))
-    end
-
-    it 'is false when class type differs' do
-      expect(Ably::Models::Token.new(id: 1)).to_not eq(nil)
-    end
-  end
-end