channel_spec.rb in ably-0.1.6

- old
+ new
@@ -2,110 +2,115 @@
 require "securerandom"
 
 describe "REST" do
   include Ably::Modules::Conversions
 
-  let(:client) do
-    Ably::Rest::Client.new(api_key: api_key, environment: environment)
-  end
+  [:msgpack, :json].each do |protocol|
+    context "over #{protocol}" do
+      let(:client) do
+        Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+      end
 
-  describe "publishing messages" do
-    let(:channel) { client.channel("test") }
-    let(:event)   { "foo" }
-    let(:message) { "woop!" }
+      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")
+        it "should publish the message ok" do
+          expect(channel.publish(event, message)).to eql(true)
+        end
       end
-    end
 
-    it "should return all the history for the channel" do
-      actual_history = channel.history
+      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
 
-      expect(actual_history.size).to eql(3)
+        before(:each) do
+          expected_history.each do |message|
+            channel.publish(message[:name], message[:data]) || raise("Unable to publish message")
+          end
+        end
 
-      expected_history.each do |message|
-        expect(actual_history).to include(Ably::Rest::Models::Message.new(message))
-        expect(actual_history.map(&:json)).to include(message)
-      end
-    end
+        it "should return all the history for the channel" do
+          actual_history = channel.history
 
-    it "should return paged history" do
-      page_1 = channel.history(limit: 1)
-      page_2 = page_1.next_page
-      page_3 = page_2.next_page
+          expect(actual_history.size).to eql(3)
 
-      all_items = [page_1[0], page_2[0], page_3[0]]
-      expect(all_items.uniq).to eql(all_items)
+          expected_history.each do |message|
+            expect(actual_history).to include(Ably::Models::Message.new(message))
+            expect(actual_history.map(&:hash)).to include(message)
+          end
+        end
 
-      expect(page_1.size).to eql(1)
-      expect(page_1).to_not be_last_page
-      expect(page_1).to be_first_page
+        it "should return paged history" do
+          page_1 = channel.history(limit: 1)
+          page_2 = page_1.next_page
+          page_3 = page_2.next_page
 
-      # Page 2
-      expect(page_2.size).to eql(1)
-      expect(page_2).to_not be_last_page
-      expect(page_2).to_not be_first_page
+          all_items = [page_1[0].id, page_2[0].id, page_3[0].id]
+          expect(all_items.uniq).to eql(all_items)
 
-      # Page 3
-      expect(page_3.size).to eql(1)
-      expect(page_3).to be_last_page
-      expect(page_3).to_not be_first_page
-    end
-  end
+          expect(page_1.size).to eql(1)
+          expect(page_1).to_not be_last_page
+          expect(page_1).to be_first_page
 
-  describe "options" do
-    let(:channel_name) { "persisted:#{SecureRandom.hex(4)}" }
-    let(:channel) { client.channel(channel_name) }
-    let(:endpoint) do
-      client.endpoint.tap do |client_end_point|
-        client_end_point.user = key_id
-        client_end_point.password = key_secret
-      end
-    end
+          # Page 2
+          expect(page_2.size).to eql(1)
+          expect(page_2).to_not be_last_page
+          expect(page_2).to_not be_first_page
 
-    [:start, :end].each do |option|
-      describe ":{option}", webmock: true do
-        let!(:history_stub) {
-          stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/messages?live=true&#{option}=#{milliseconds}").to_return(:body => '{}')
-        }
-
-        before do
-          channel.history(options)
+          # Page 3
+          expect(page_3.size).to eql(1)
+          expect(page_3).to be_last_page
+          expect(page_3).to_not be_first_page
         end
+      end
 
-        context 'with milliseconds since epoch' do
-          let(:milliseconds) { as_since_epoch(Time.now) }
-          let(:options) { { option => milliseconds } }
-
-          specify 'are left unchanged' do
-            expect(history_stub).to have_been_requested
+      describe "options" do
+        let(:channel_name) { "persisted:#{SecureRandom.hex(4)}" }
+        let(:channel) { client.channel(channel_name) }
+        let(:endpoint) do
+          client.endpoint.tap do |client_end_point|
+            client_end_point.user = key_id
+            client_end_point.password = key_secret
           end
         end
 
-        context 'with Time' do
-          let(:time) { Time.now }
-          let(:milliseconds) { as_since_epoch(time) }
-          let(:options) { { option => time } }
+        [:start, :end].each do |option|
+          describe ":{option}", webmock: true do
+            let!(:history_stub) {
+              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/messages?live=true&#{option}=#{milliseconds}").
+                to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
+            }
 
-          specify 'are left unchanged' do
-            expect(history_stub).to have_been_requested
+            before do
+              channel.history(options)
+            end
+
+            context 'with milliseconds since epoch' do
+              let(:milliseconds) { as_since_epoch(Time.now) }
+              let(:options) { { option => milliseconds } }
+
+              specify 'are left unchanged' do
+                expect(history_stub).to have_been_requested
+              end
+            end
+
+            context 'with Time' do
+              let(:time) { Time.now }
+              let(:milliseconds) { as_since_epoch(time) }
+              let(:options) { { option => time } }
+
+              specify 'are left unchanged' do
+                expect(history_stub).to have_been_requested
+              end
+            end
           end
         end
       end
     end
   end