Add unit test for lib

Added unit test for data_models, emitter, parser and sc_client

Author: maanavshah

spec/lib/data_models_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+RSpec.describe DataModels do
+  include DataModels
+
+  describe 'data_models' do
+    context 'get_ack_object' do
+      let(:error) { 'error' }
+      let(:data) { { key: 'value' } }
+      let(:cid) { [*1..6].sample }
+
+      before(:each) do
+        @ack_object = get_ack_object(error, data, cid)
+      end
+
+      it 'should return an ack object of type hash' do
+        expect(@ack_object.class).to eq(Hash)
+      end
+
+      it 'should return an error, data and cid in ack object' do
+        expect(@ack_object.keys.include?(:error)).to be(true)
+        expect(@ack_object[:error]).to eq(error)
+        expect(@ack_object.keys.include?(:data)).to be(true)
+        expect(@ack_object[:data]).to eq(data)
+        expect(@ack_object.keys.include?(:cid)).to be(true)
+        expect(@ack_object[:cid]).to eq(cid)
+      end
+    end
+
+    context 'get_emit_object' do
+      let(:event) { 'event' }
+      let(:data) { { key: 'value' } }
+
+      before(:each) do
+        @emit_object = get_emit_object(event, data)
+      end
+
+      it 'should return an emit object of type hash' do
+        expect(@emit_object.class).to eq(Hash)
+      end
+
+      it 'should return an event and data in emit object' do
+        expect(@emit_object.keys.include?(:event)).to be(true)
+        expect(@emit_object[:event]).to eq(event)
+        expect(@emit_object.keys.include?(:data)).to be(true)
+        expect(@emit_object[:data]).to eq(data)
+      end
+    end
+
+    context 'get_emit_ack_object' do
+      let(:event) { 'event' }
+      let(:data) { { key: 'value' } }
+      let(:cid) { [*1..6].sample }
+
+      before(:each) do
+        @emit_ack_object = get_emit_ack_object(event, data, cid)
+      end
+
+      it 'should return an emit ack object of type hash' do
+        expect(@emit_ack_object.class).to eq(Hash)
+      end
+
+      it 'should return an event, data and cid in emit ack object' do
+        expect(@emit_ack_object.keys.include?(:event)).to be(true)
+        expect(@emit_ack_object[:event]).to eq(event)
+        expect(@emit_ack_object.keys.include?(:data)).to be(true)
+        expect(@emit_ack_object[:data]).to eq(data)
+        expect(@emit_ack_object.keys.include?(:cid)).to be(true)
+        expect(@emit_ack_object[:cid]).to eq(cid)
+      end
+    end
+
+    context 'get_handshake_object' do
+      let(:cid) { [*1..6].sample }
+
+      before(:each) do
+        @handshake_object = get_handshake_object(cid)
+      end
+
+      it 'should return a handshake object of type hash' do
+        expect(@handshake_object.class).to eq(Hash)
+      end
+
+      it 'should return an event, data and cid in handshake object' do
+        expect(@handshake_object.keys.include?(:event)).to be(true)
+        expect(@handshake_object[:event]).to eq('#handshake')
+        expect(@handshake_object.keys.include?(:data)).to be(true)
+        expect(@handshake_object[:data].keys.include?(:authToken)).to be(true)
+        expect(@handshake_object.keys.include?(:cid)).to be(true)
+        expect(@handshake_object[:cid]).to eq(cid)
+      end
+    end
+
+    context 'get_publish_object' do
+      let(:channel) { 'channel' }
+      let(:data) { { key: 'value' } }
+      let(:cid) { [*1..6].sample }
+
+      before(:each) do
+        @publish_object = get_publish_object(channel, data, cid)
+      end
+
+      it 'should return a publish object of type hash' do
+        expect(@publish_object.class).to eq(Hash)
+      end
+
+      it 'should return an event, channel, data and cid in publish object' do
+        expect(@publish_object.keys.include?(:event)).to be(true)
+        expect(@publish_object[:event]).to eq('#publish')
+        expect(@publish_object.keys.include?(:data)).to be(true)
+        expect(@publish_object[:data].keys.include?(:channel)).to be(true)
+        expect(@publish_object[:data].class).to eq(Hash)
+        expect(@publish_object.keys.include?(:cid)).to be(true)
+        expect(@publish_object[:cid]).to be(cid)
+      end
+    end
+
+    context 'get_subscribe_object' do
+      let(:channel) { 'channel' }
+      let(:cid) { [*1..6].sample }
+
+      before(:each) do
+        @subscribe_object = get_subscribe_object(channel, cid)
+      end
+
+      it 'should return a subscribe object of type hash' do
+        expect(@subscribe_object.class).to eq(Hash)
+      end
+
+      it 'should return an event, data, channel and cid in subscribe object' do
+        expect(@subscribe_object.keys.include?(:event)).to be(true)
+        expect(@subscribe_object[:event]).to eq('#subscribe')
+        expect(@subscribe_object[:data].class).to eq(Hash)
+        expect(@subscribe_object.keys.include?(:data)).to be(true)
+        expect(@subscribe_object[:data].keys.include?(:channel)).to be(true)
+        expect(@subscribe_object[:data][:channel]).to eq(channel)
+        expect(@subscribe_object.keys.include?(:cid)).to be(true)
+        expect(@subscribe_object[:cid]).to be(cid)
+      end
+    end
+
+    context 'get_unsubscribe_object' do
+      let(:channel) { 'channel' }
+      let(:cid) { [*1..6].sample }
+
+      before(:each) do
+        @unsubscribe_object = get_unsubscribe_object(channel, cid)
+      end
+
+      it 'should return an unsubscribe object of type hash' do
+        expect(@unsubscribe_object.class).to eq(Hash)
+      end
+
+      it 'should return an event, data and cid in unsubscribe object' do
+        expect(@unsubscribe_object.keys.include?(:event)).to be(true)
+        expect(@unsubscribe_object[:event]).to eq('#unsubscribe')
+        expect(@unsubscribe_object.keys.include?(:data)).to be(true)
+        expect(@unsubscribe_object[:data]).to eq(channel)
+        expect(@unsubscribe_object.keys.include?(:cid)).to be(true)
+        expect(@unsubscribe_object[:cid]).to be(cid)
+      end
+    end
+  end
+end

spec/lib/emitter_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+RSpec.describe Emitter do
+  include Emitter
+
+  describe 'emitter' do
+    context 'initialize_emitter' do
+      it 'should not have instance variables' do
+        expect(@events).to eq(nil)
+        expect(@events_ack).to eq(nil)
+      end
+
+      it 'should initialize instance variables' do
+        initialize_emitter
+
+        expect(@events).to_not eq(nil)
+        expect(@events_ack).to_not eq(nil)
+        expect(@events.class).to eq(Hash)
+        expect(@events_ack.class).to eq(Hash)
+      end
+    end
+
+    context 'on' do
+      before(:each) do
+        initialize_emitter
+      end
+
+      let(:key) { 'ping' }
+      let(:message) { ->(key, object) { "#{key} #{object}" } }
+
+      it 'should not have an event with key' do
+        expect(@events[key]).to eq(nil)
+      end
+
+      it 'should have an event with key' do
+        on(key, message)
+
+        expect(@events[key]).to be(message)
+      end
+    end
+
+    context 'onchannel' do
+      before(:each) do
+        initialize_emitter
+      end
+
+      let(:key) { 'ping' }
+      let(:message) { ->(key, object) { "#{key} #{object}" } }
+
+      it 'should not have an event with key' do
+        expect(@events[key]).to eq(nil)
+      end
+
+      it 'should have an event with key' do
+        onchannel(key, message)
+
+        expect(@events[key]).to be(message)
+      end
+    end
+
+    context 'onack' do
+      before(:each) do
+        initialize_emitter
+      end
+
+      let(:key) { 'ping' }
+      let(:message) { ->(key, object, ack_block) { ack_block.call(key, object) } }
+      let(:ack_message) { ->(key, object) { "#{key} #{object}" } }
+
+      it 'should not have an acknowledgement event with key' do
+        expect(@events_ack[key]).to eq(nil)
+      end
+
+      it 'should have an acknowledgement event with key' do
+        onack(key, ack_message)
+
+        expect(@events_ack[key]).to be(ack_message)
+      end
+    end
+
+    context 'execute' do
+      before(:each) do
+        initialize_emitter
+      end
+
+      let(:key) { 'ping' }
+      let(:message) { ->(key, object) { "#{key} #{object}" } }
+
+      it 'should not have an event with key' do
+        expect(@events[key]).to eq(nil)
+      end
+
+      it 'should execute event' do
+        on(key, message)
+
+        expect(execute(key, 'pong')).to eq('ping pong')
+      end
+    end
+
+    context 'haseventack' do
+      before(:each) do
+        initialize_emitter
+      end
+
+      let(:key) { 'ping' }
+      let(:message) { ->(key, object) { "#{key} #{object}" } }
+
+      it 'should not have an event with key' do
+        expect(@events_ack[key]).to eq(nil)
+      end
+
+      it 'should return an acknowledgment event from key' do
+        onack(key, message)
+
+        expect(haseventack(key)).to eq(message)
+      end
+    end
+
+    context 'onack' do
+      before(:each) do
+        initialize_emitter
+      end
+
+      let(:key) { 'ping' }
+      let(:message) { ->(key, object, ack_block) { ack_block.call(key, object) } }
+      let(:ack_message) { ->(key, object) { "#{key} #{object}" } }
+
+      it 'should not have an event with key' do
+        expect(@events_ack[key]).to eq(nil)
+      end
+
+      it 'should expect an acknowledgment event from key' do
+        onack(key, message)
+
+        expect(executeack(key, 'pong', ack_message)).to eq('ping pong')
+      end
+    end
+  end
+end

spec/lib/parser_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+RSpec.describe Parser do
+  CHECK_AUTHENTICATION  = 1
+  PUBLISH               = 2
+  REMOVE_AUTHENTICATION = 3
+  SET_AUTHENTICATION    = 4
+  EVENT                 = 5
+  ACKNOWLEDGEMENT       = 6
+
+  describe 'parser'
+  describe 'parse'
+  context 'check authentication' do
+    let(:event) { '' }
+    let(:response_id) { 1 }
+
+    it 'should check if client is authenticated' do
+      result = Parser.parse(event, response_id)
+      expect(result).to eq(CHECK_AUTHENTICATION)
+    end
+  end
+
+  context 'publish' do
+    let(:event) { '#publish' }
+    let(:response_id) { [*1..6].sample }
+
+    it 'should check if event is publish' do
+      result = Parser.parse(event, response_id)
+      expect(result).to eq(PUBLISH)
+    end
+  end
+
+  context 'remove authentication token' do
+    let(:event) { '#removeAuthToken' }
+    let(:response_id) { [*1..6].sample }
+
+    it 'should remove authentication token' do
+      result = Parser.parse(event, response_id)
+      expect(result).to eq(REMOVE_AUTHENTICATION)
+    end
+  end
+
+  context 'set authentication' do
+    let(:event) { '#setAuthToken' }
+    let(:response_id) { [*1..6].sample }
+
+    it 'should set authentication token' do
+      result = Parser.parse(event, response_id)
+      expect(result).to eq(SET_AUTHENTICATION)
+    end
+  end
+
+  context 'random event' do
+    let(:event) { '#event' }
+    let(:response_id) { [*1..6].sample }
+
+    it 'should check if event is publish' do
+      result = Parser.parse(event, response_id)
+      expect(result).to eq(EVENT)
+    end
+  end
+
+  context 'acknowledgment' do
+    let(:event) { '' }
+    let(:response_id) { 6 }
+
+    it 'should acknowledge the event' do
+      result = Parser.parse(event, response_id)
+      expect(result).to eq(ACKNOWLEDGEMENT)
+    end
+  end
+end