spec/acceptance/rest/channel_spec.rb in ably-0.1.6 vs spec/acceptance/rest/channel_spec.rb in ably-0.2.0

@@ -1,55 +1,71 @@
-require "spec_helper"
-require "securerandom"
+require 'spec_helper'
+require 'securerandom'
 
-describe "REST" do
+describe Ably::Rest::Channel do
   include Ably::Modules::Conversions
 
   [: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
+        it 'should publish the message ok' do
           expect(channel.publish(event, message)).to eql(true)
         end
       end
 
-      describe "fetching channel history" do
+      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" }
+            { :name => 'test1', :data => 'foo' },
+            { :name => 'test2', :data => 'bar' },
+            { :name => 'test3', :data => 'baz' }
           ]
         end
+        let!(:before_published) { client.time }
 
         before(:each) do
           expected_history.each do |message|
-            channel.publish(message[:name], message[:data]) || raise("Unable to publish message")
+            channel.publish(message[:name], message[:data]) || raise('Unable to publish message')
           end
         end
 
-        it "should return all the history for the channel" do
+        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(Ably::Models::Message.new(message))
-            expect(actual_history.map(&:hash)).to include(message)
+            message_name, message_data = message[:name], message[:data]
+            matching_message = actual_history.find { |message| message.name == message_name && message.data == message_data }
+            expect(matching_message).to be_a(Ably::Models::Message)
           end
         end
 
-        it "should return paged history" do
+        context 'timestamps' do
+          it 'should be greater than the time before the messages were published' do
+            channel.history.each do |message|
+              expect(before_published.to_f).to be < message.timestamp.to_f
+            end
+          end
+        end
+
+        it 'should return messages with unique IDs' do
+          message_ids = channel.history.map(&:id).compact
+          expect(message_ids.count).to eql(3)
+          expect(message_ids.uniq.count).to eql(3)
+        end
+
+        it 'should return paged history' do
           page_1 = channel.history(limit: 1)
           page_2 = page_1.next_page
           page_3 = page_2.next_page
 
           all_items = [page_1[0].id, page_2[0].id, page_3[0].id]
@@ -69,21 +85,21 @@
           expect(page_3).to be_last_page
           expect(page_3).to_not be_first_page
         end
       end
 
-      describe "options" do
+      describe 'history 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
 
         [:start, :end].each do |option|
-          describe ":{option}", webmock: true do
+          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' })
             }