ruby_rabbitmq_janus 3.0.0.pre.336 → 3.0.0.pre.351

data/spec/config/initializer.rb

@@ -4,13 +4,13 @@
 class EventTest
   def actions
     lambda do |reason, payload|
-      RubyRabbitmqJanus::Tools::Log.instance.info "Reason : #{reason}"
-      RubyRabbitmqJanus::Tools::Log.instance.info "Payload : #{payload}"
+      ::Log.info "Reason : #{reason}"
+      ::Log.info "Payload : #{payload}"
     end
   end
 end
 
 # Initialize listener
-actions = EventTest.new.actions
-@event = RubyRabbitmqJanus::Process::Concurrencies::Event.new
-@event.run(&actions)
+# actions = EventTest.new.actions
+# @event = RubyRabbitmqJanus::Process::Concurrencies::Event.new
+# @event.run(&actions)

data/spec/rrj/ruby_rabbitmq_janus_spec.rb

@@ -27,7 +27,7 @@ describe RubyRabbitmqJanus, type: :config, name: :describe do
     it_behaves_like 'constant is', Array
   end
 
-  context 'with a license' do
+  context 'with a license', type: :aruba do
     let(:data) { RubyRabbitmqJanus::LICENSE }
     let(:licence) { '../../LICENSE' }
 

data/spec/ruby_rabbitmq_janus/janus/responses/admin_handles_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
+                                                     name: :admin do
+  let(:response) { described_class.new(message) }
+
+  describe '#handles' do
+    context 'with no handles' do
+      let(:message) { {} }
+
+      it { expect { response.handles }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Admin::Handles) }
+    end
+
+    context 'with handles' do
+      let(:message) { { 'handles' => [(rand * 10_000).to_i] * 5 } }
+
+      it { expect(response.handles).to be_kind_of(Array) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/admin_info_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
+                                                     name: :admin do
+  let(:response) { described_class.new(message) }
+
+  describe '#info' do
+    context 'with no info' do
+      let(:message) { {} }
+
+      it { expect { response.info }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Admin::Info) }
+    end
+
+    context 'with info' do
+      let(:message) { { 'info' => {} } }
+
+      it { expect(response.info).to be_kind_of(Hash) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/admin_level_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
+                                                     name: :admin do
+  let(:response) { described_class.new(message) }
+
+  describe '#level' do
+    context 'with no level' do
+      let(:message) { {} }
+
+      it { expect { response.level }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Admin::Level) }
+    end
+
+    context 'with level' do
+      let(:message) { { 'level' => (rand * 10_000).to_i } }
+
+      it { expect(response.level).to be_kind_of(Integer) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/admin_libnice_debug_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
+                                                     name: :admin do
+  let(:response) { described_class.new(message) }
+
+  describe '#libnice_debug' do
+    context 'with no libnice_debug' do
+      let(:message) { {} }
+
+      it { expect { response.libnice_debug }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Admin::LibniceDebug) }
+    end
+
+    context 'with libnice_debug' do
+      let(:message) { { 'libnice_debug' => true } }
+
+      it { expect(response.libnice_debug).to be_kind_of(TrueClass) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/admin_locking_debug_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
+                                                     name: :admin do
+  let(:response) { described_class.new(message) }
+
+  describe '#locking_debug' do
+    context 'with no locking_debug' do
+      let(:message) { {} }
+
+      it { expect { response.locking_debug }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Admin::LockingDebug) }
+    end
+
+    context 'with locking_debug' do
+      let(:message) { { 'locking_debug' => true } }
+
+      it { expect(response.locking_debug).to be_kind_of(TrueClass) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/admin_log_colors_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
+                                                     name: :admin do
+  let(:response) { described_class.new(message) }
+
+  describe '#log_colors' do
+    context 'with no log_colors' do
+      let(:message) { {} }
+
+      it { expect { response.log_colors }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Admin::LogColors) }
+    end
+
+    context 'with log_colors' do
+      let(:message) { { 'log_colors' => true } }
+
+      it { expect(response.log_colors).to be_kind_of(TrueClass) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/admin_log_timestamps_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
+                                                     name: :admin do
+  let(:response) { described_class.new(message) }
+
+  describe '#log_timestamps' do
+    context 'with no log_timestamps' do
+      let(:message) { {} }
+
+      it { expect { response.log_timestamps }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Admin::LogTimestamps) }
+    end
+
+    context 'with log_timestamps' do
+      let(:message) { { 'log_timestamps' => true } }
+
+      it { expect(response.log_timestamps).to be_kind_of(TrueClass) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/admin_max_nack_queue_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
+                                                     name: :admin do
+  let(:response) { described_class.new(message) }
+
+  describe '#max_nack_queue' do
+    context 'with no max_nack_queue' do
+      let(:message) { {} }
+
+      it { expect { response.max_nack_queue }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Admin::MaxNackQueue) }
+    end
+
+    context 'with max_nack_queue' do
+      let(:message) { { 'max_nack_queue' => (rand * 10_000).to_i } }
+
+      it { expect(response.max_nack_queue).to be_kind_of(Integer) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/admin_no_media_timer_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
+                                                     name: :admin do
+  let(:response) { described_class.new(message) }
+
+  describe '#no_media_timer' do
+    context 'with no no_media_timer' do
+      let(:message) { {} }
+
+      it { expect { response.no_media_timer }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Admin::NoMediaTimer) }
+    end
+
+    context 'with no_media_timer' do
+      let(:message) { { 'no_media_timer' => (rand * 10_000).to_i } }
+
+      it { expect(response.no_media_timer).to be_kind_of(Integer) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/admin_sessions_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
+                                                     name: :admin do
+  let(:response) { described_class.new(message) }
+
+  describe '#sessions' do
+    context 'with no sessions' do
+      let(:message) { {} }
+
+      it { expect { response.sessions }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Admin::Sessions) }
+    end
+
+    context 'with sessions' do
+      let(:message) { { 'sessions' => [(rand * 10_000).to_i] * 5 } }
+
+      it { expect(response.sessions).to be_kind_of(Array) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/admin_spec.rb

@@ -3,39 +3,6 @@
 require 'spec_helper'
 
 describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
-                                                     level: :admin,
-                                                     broken: true,
                                                      name: :admin do
-  let(:message) do
-    @gateway.admin_endpoint do |transaction|
-      @response = transaction.publish_message(type)
-    end
-  end
-
-  describe '#sessions' do
-    let(:type) { 'admin::sessions' }
-    let(:response) { @response.sessions }
-
-    include_examples 'response is', Array
-  end
-
-  describe '#handles' do
-    let(:type) { 'admin::handles' }
-    let(:response) { @response.handles }
-
-    include_examples 'response is', Array
-  end
-
-  describe '#info' do
-    before do
-      @gateway.session_endpoint_private do |transaction|
-        @response = transaction.publish_message('base::attach')
-      end
-    end
-
-    let(:type) { 'admin::handle_info' }
-    let(:response) { @response.info }
-
-    include_examples 'admin response with sender is', Hash
-  end
+  let(:response) { described_class.new(message) }
 end

data/spec/ruby_rabbitmq_janus/janus/responses/admin_timeout_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Admin, type: :responses,
+                                                     name: :admin do
+  let(:response) { described_class.new(message) }
+
+  describe '#timeout' do
+    context 'with no timeout' do
+      let(:message) { {} }
+
+      it { expect { response.timeout }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Admin::Timeout) }
+    end
+
+    context 'with timeout' do
+      let(:message) { { 'timeout' => (rand * 10_000).to_i } }
+
+      it { expect(response.timeout).to be_kind_of(Integer) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/event_data_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Event, type: :responses,
+                                                     name: :event do
+  let(:response) { described_class.new(message) }
+
+  describe '#data' do
+    context 'with no data' do
+      let(:message) { {} }
+
+      it { expect { response.data }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Event::Data) }
+    end
+
+    context 'with data' do
+      let(:message) { { 'plugindata' => { 'plugin' => 'fake', 'data' => { 'echotest' => 'event' } } } }
+
+      it { expect(response.data).to be_kind_of(Hash) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/event_event_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Event, type: :responses,
+                                                     name: :event do
+  let(:response) { described_class.new(message) }
+
+  describe '#event' do
+    context 'with no event' do
+      let(:message) { {} }
+
+      it { expect { response.event }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Event::Event) }
+    end
+
+    context 'with event' do
+      let(:message) { { 'janus' => 'event' } }
+
+      it { expect(response.event).to be_kind_of(String) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/event_jsep_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Event, type: :responses,
+                                                     name: :event do
+  let(:response) { described_class.new(message) }
+
+  describe '#jsep' do
+    context 'with no jsep' do
+      let(:message) { {} }
+
+      it { expect { response.jsep }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Event::Jsep) }
+    end
+
+    context 'with jsep' do
+      let(:message) { { 'jsep' => { 'type' => %w[offer answer].sample, 'sdp' => '.....' } } }
+
+      it { expect(response.jsep).to be_kind_of(Hash) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/event_keys_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyRabbitmqJanus::Janus::Responses::Event, type: :responses,
+                                                     name: :event do
+  let(:response) { described_class.new(message) }
+
+  describe '#keys' do
+    context 'with no session_id' do
+      let(:message) { { 'sender' => (rand * 10_000).to_i } }
+
+      it { expect { response.keys }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Event::Keys) }
+    end
+
+    context 'with no sender' do
+      let(:message) { { 'session_id' => (rand * 10_000).to_i } }
+
+      it { expect { response.keys }.to raise_error(RubyRabbitmqJanus::Errors::Janus::Responses::Event::Keys) }
+    end
+
+    context 'with session_id & sender' do
+      let(:message) { { 'session_id' => (rand * 10_000).to_i, 'sender' => (rand * 10_000).to_i } }
+
+      it { expect(response.keys).to be_kind_of(Array) }
+    end
+  end
+end

data/spec/ruby_rabbitmq_janus/janus/responses/response_spec.rb

@@ -1,31 +1,43 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-
 describe RubyRabbitmqJanus::Janus::Responses::Response, type: :responses,
                                                         name: :response do
-  let(:type) { 'base::info' }
-  let(:message) do
-    @gateway.session_endpoint_public do |transaction|
-      @response = transaction.publish_message(type)
-    end
+  let(:response) { described_class.new(message) }
+
+  context 'when ask json response' do
+    let(:message) { { 'data' => { 'id' => (rand * 10_000).to_i } } }
+
+    it { expect(response.to_json).to be_kind_of(String) }
+  end
+
+  context 'when ask nice json response' do
+    let(:message) { { 'data' => { 'id' => (rand * 10_000).to_i } } }
+
+    it { expect(response.to_json).to be_kind_of(String) }
+  end
+
+  context 'when ask hash response' do
+    let(:message) { { 'data' => { 'id' => (rand * 10_000).to_i } } }
+
+    it { expect(response.to_hash).to be_kind_of(Hash) }
   end
 
-  describe '#to_json', broken: true do
-    let(:response) { @response.to_json }
+  context 'when ask error code' do
+    let(:message) { { 'error' => { 'code' => (rand * 600).to_i, 'reason' => '...' } } }
 
-    include_examples 'response is', String
+    it { expect(response.error_code).to be_kind_of(Integer) }
   end
 
-  describe '#to_hash', broken: true do
-    let(:response) { @response.to_hash }
+  context 'when ask error reason' do
+    let(:message) { { 'error' => { 'code' => (rand * 600).to_i, 'reason' => '...' } } }
 
-    include_examples 'response is', Hash
+    it { expect(response.error_reason).to be_kind_of(String) }
   end
 
-  describe '#to_nice_json', broken: true do
-    let(:response) { @response.to_nice_json }
+  context 'when ask janus' do
+    let(:message) { { 'janus' => 'super' } }
 
-    include_examples 'response is', String
+    it { expect(response.janus).to be_kind_of(String) }
   end
 end