Unit tests for socketclusterclient and commands.txt

.rspec

@@ -0,0 +1 @@
+--color

.simplecov

@@ -0,0 +1,3 @@
+SimpleCov.start do
+  add_group 'lib', 'lib'
+end

.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.3
+before_install: gem install bundler -v 1.16.1

Gemfile

@@ -1,5 +1,8 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
+git_source(:github) {|repo_name| "https://github.com/opensocket" }
+
+# Specify your gem's dependencies in socketclusterclient.gemspec
 gemspec
 
 gem 'websocket-eventmachine-client'

Gemfile.lock

@@ -0,0 +1,54 @@
+PATH
+  remote: .
+  specs:
+    socketclusterclient (1.0.0)
+      websocket-eventmachine-client (~> 1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    docile (1.3.1)
+    eventmachine (1.2.7)
+    json (2.1.0)
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    websocket (1.2.8)
+    websocket-eventmachine-base (1.2.0)
+      eventmachine (~> 1.0)
+      websocket (~> 1.0)
+      websocket-native (~> 1.0)
+    websocket-eventmachine-client (1.2.0)
+      websocket-eventmachine-base (~> 1.0)
+    websocket-native (1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  simplecov
+  socketclusterclient!
+  websocket-eventmachine-client
+
+BUNDLED WITH
+   1.16.1

Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "socketclusterclient"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

lib/socketclusterclient.rb

@@ -1,9 +1,11 @@
+require 'socketclusterclient/version'
+
 require_relative './sc_client'
 
 #
 # Module SocketclusterClient provides an interface for Socketcluster Client
 #
 # @author Maanav Shah <shahmaanav07@gmail.com>
 #
-module SocketclusterClient
+module Socketclusterclient
 end

lib/socketclusterclient/version.rb

@@ -1,3 +1,3 @@
-module SocketClusterClient
+module Socketclusterclient
   VERSION = '1.0.0'.freeze
 end

socketclusterclient.gemspec

@@ -1,23 +1,32 @@
-require 'rake'
 
-$LOAD_PATH.push File.expand_path('lib', __dir__)
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'socketclusterclient/version'
 
-Gem::Specification.new do |s|
-  s.name        = 'socketclusterclient'
-  s.version     = SocketClusterClient::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.licenses    = ['MIT']
-  s.summary     = 'Ruby client for socketcluster'
-  s.homepage    = 'https://socketcluster.io/'
-  s.description = 'A socketcluster client designed in ruby'
-  s.email       = %w[shahmaanav07@gmail.com piyushwww13@gmail.com sachinshinde7676@gmail.com]
-  s.authors     = ['Maanav Shah', 'Piyush Wani', 'Sachin Shinde']
+Gem::Specification.new do |spec|
+  spec.name        = 'socketclusterclient'
+  spec.version     = Socketclusterclient::VERSION
+  spec.platform    = Gem::Platform::RUBY
+  spec.licenses    = ['MIT']
+  spec.summary     = 'Ruby client for socketcluster'
+  spec.homepage    = 'https://socketcluster.io/'
+  spec.description = 'A socketcluster client designed in ruby'
+  spec.email       = %w[shahmaanav07@gmail.com piyushwww13@gmail.com sachinshinde7676@gmail.com]
+  spec.authors     = ['Maanav Shah', 'Piyush Wani', 'Sachin Shinde']
 
-  s.files         = Rake::FileList['lib/**/*.rb']
-  s.require_paths = ['lib']
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
 
-  s.required_ruby_version = '>= 2.2.0'
+  spec.required_ruby_version = '>= 2.2.0'
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_dependency('websocket-eventmachine-client', '~> 1.2')
 
-  s.add_dependency('websocket-eventmachine-client', '~> 1.2')
 end

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