ruby_rabbitmq_janus 2.7.2.pre.312 → 2.7.2.pre.314

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eeaab1ae4e6c2b315a48d3dae5779098d70749ca0426fd7a7752dd95d0914bfe
-  data.tar.gz: 71f20a5706f6021718bf0491e3cea0afd1e84b308f03bfc61289286f6ec1c2e0
+  metadata.gz: 55ec8d50d1bce0633eaa064cfe14a12107e214423b133246d22a684edd6c52ce
+  data.tar.gz: 074e93f780f98a747ffdbeece4d5ec0f28fa2e898372a426546f9115f4f02506
 SHA512:
-  metadata.gz: bfb041a82fc30acae2b546cf1455609b7b6e7bf5bd0bd509a6157860ae184232a9bfce67c509924aa1136e1b4e24a9ea63c11fc044f8f3094ce2329af65cf733
-  data.tar.gz: 8fed4a682590c5699402da12c9cedd700d2fe150ea48febcfdc1e16906bb0c50d95612914b2c57773fb0711bd45d0802dff74742c5ae2ce77c664d1af35569ca
+  metadata.gz: 2407c36de8b7d0bee62bf06575e8ceaba9266d3481c332d9d15fd7d3861e42504c07fd40dac9271a156bc937cbf4c42ec84f4326b013ed22e981edfcb8ee9fae
+  data.tar.gz: c47053c454305a155a58ba6cacecef9fd0b7074e85d667fb8a264e061eaee3db1330c6aa3fbcf4134d07862c40da1937d631e5bd219624b57f82799a430965dc

data/lib/rrj/models/active_record.rb

@@ -9,8 +9,6 @@ module RubyRabbitmqJanus
     # Store instance information for MongoID database
     class JanusInstance < ::ActiveRecord::Base
       include RubyRabbitmqJanus::Models::Instances
-      # include RubyRabbitmqJanus::Models::Methods
-      # include RubyRabbitmqJanus::Models::Callbacks
       include RubyRabbitmqJanus::Models::Validations
 
       self.primary_key = :id
@@ -18,12 +16,6 @@ module RubyRabbitmqJanus
       alias_attribute :instance,        :id
       alias_attribute :title,           :name
       alias_attribute :session_id,      :session
-      alias_attribute :thread_id,       :thread
-      alias_attribute :thread_id_adm,   :thread_adm
-
-      # after_create      { callback_create_after }
-      # after_update      { callback_update_after }
-      # after_destroy     { callback_destroy_after }
 
       # Update attributes to document
       #

data/lib/rrj/models/mongoid.rb

@@ -8,21 +8,13 @@ module RubyRabbitmqJanus
     class JanusInstance
       include Mongoid::Document
       include RubyRabbitmqJanus::Models::Instances
-      # include RubyRabbitmqJanus::Models::Methods
-      # include RubyRabbitmqJanus::Models::Callbacks
       include RubyRabbitmqJanus::Models::Validations
 
       field :name,        type: String,  as: :title
       field :session,     type: Integer, as: :session_id
       field :enable,      type: Boolean
-      field :thread,      type: Integer, as: :thread_id
-      field :thread_adm,  type: Integer, as: :thread_id_adm
 
       alias_attribute :instance, :_id
-
-      # set_callback(:create,     :after)   { callback_create_after }
-      # set_callback(:update,     :after)   { callback_update_after }
-      # set_callback(:destroy,    :after)   { callback_destroy_after }
     end
   end
 end

data/lib/rrj/process/concurrency.rb

@@ -8,8 +8,9 @@ module RubyRabbitmqJanus
       #
       # # Class for manage threads
       #
-      # @abstract Manage thread in this gem for keepalive message and listen
-      #   standard queue.
+      # @abstract Manage thread for listener to queue :
+      #   from-janus
+      #   from-janus-admin
       class Concurrency
         # Initialize class with elements for thread communication
         def initialize
@@ -40,6 +41,5 @@ module RubyRabbitmqJanus
   end
 end
 
-require 'rrj/process/keepalive/keepalive_initializer'
 require 'rrj/process/event'
 require 'rrj/process/event_admin'

data/lib/rrj/tools/bin/init.rb

@@ -1,32 +1,6 @@
 # frozen_string_literal: true
 
-# Loads files RRJ and write first message in log,
-# then initialize binary
+require 'rrj/rails' if defined?(::Rails::Engine)
 
-require 'rrj/rails' # defined?(::Rails::Engine)
-# require File.join(File.dirname(__FILE__), '..', '..', 'binary')
-
-begin
-  # bin = RubyRabbitmqJanus::Binary.new
-  # Log.info \
-  #   'Prepare to listen events in queue : ' + \
-  #   RubyRabbitmqJanus::Tools::Config.instance.queue_janus_instance
-  # rabbit = RubyRabbitmqJanus::Rabbit::Connect.new
-  # rabbit.start
-  # listener = RubyRabbitmqJanus::Rabbit::Listener::JanusInstance.new(rabbit)
-  # Log.info 'Loop events provided by Janus queues'
-  # loop do
-  #   listener.listen_events do |event, response|
-  #     Log.debug "Event : #{event}"
-  #     Log.debug "Response : #{response.to_hash}"
-  #     bin.update_instance(response.to_hash)
-  #   end
-  # end
-
-  Log.info 'Listen Public queue to Janus'
-  loop {}
-rescue => exception
-  Log.fatal '!! Fail to start RRJ Thread Janus Instance management !!'
-  Log.fatal exception
-  exit 1
-end
+Log.info 'Listen Public queue to Janus'
+loop {}

data/lib/rrj/tools/gem/config.rb

@@ -8,7 +8,6 @@ require 'erb'
 %w[gem rabbit queues janus].each do |file|
   require File.join('rrj', 'tools', 'gem', 'config', file)
 end
-# %w[callbacks methods instances validations].each do |file|
 %w[instances validations].each do |file|
   require File.join('rrj', 'models', 'concerns', file)
 end

data/spec/ruby_rabbitmq_janus/models/janus_instance_definition_spec.rb

@@ -9,8 +9,6 @@ describe RubyRabbitmqJanus::Models::JanusInstance, type: :model,
     {
       'id' => '_id',
       'session_id' => 'session',
-      'thread_id' => 'thread',
-      'thread_id_adm' => 'thread_adm',
       'instance' => '_id',
       'title' => 'name'
     }
@@ -19,8 +17,6 @@ describe RubyRabbitmqJanus::Models::JanusInstance, type: :model,
     {
       'instance' => 'id',
       'session_id' => 'session',
-      'thread_id_adm' => 'thread_adm',
-      'thread_id' => 'thread',
       'title' => 'name'
     }
   end

data/spec/ruby_rabbitmq_janus/models/janus_instance_spec.rb

@@ -36,7 +36,6 @@ describe RubyRabbitmqJanus::Models::JanusInstance, type: :model,
 
     it { expect(model.count).to eq(6) }
     it { expect(model.enabled.count).to eq(1) }
-    it { expect(model.find_by_session(one.session).thread).to eq(one.thread) }
     it { expect(model.find_by_instance(one.instance).session).to eq(one.session) }
   end
 
@@ -47,7 +46,6 @@ describe RubyRabbitmqJanus::Models::JanusInstance, type: :model,
     it { expect(janus.session).to be_nil }
     it { expect(janus.enable).to be_a(TrueClass) }
     it { expect(janus.enable).to eq(true) }
-    it { expect(janus.thread).to be_nil }
   end
 
   context 'when Janus Instance disable' do
@@ -57,6 +55,5 @@ describe RubyRabbitmqJanus::Models::JanusInstance, type: :model,
     it { expect(janus.session).to be_nil }
     it { expect(janus.enable).to be_a(FalseClass) }
     it { expect(janus.enable).to eq(false) }
-    it { expect(janus.thread).to be_nil }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_rabbitmq_janus
 version: !ruby/object:Gem::Version
-  version: 2.7.2.pre.312
+  version: 2.7.2.pre.314
 platform: ruby
 authors:
 - VAILLANT Jeremy
@@ -440,7 +440,6 @@ files:
 - lib/generators/ruby_rabbitmq_janus/templates/initializer.rb
 - lib/generators/ruby_rabbitmq_janus/templates/migration.rb
 - lib/rrj/admin.rb
-- lib/rrj/binary.rb
 - lib/rrj/errors/base/admin.rb
 - lib/rrj/errors/base/base.rb
 - lib/rrj/errors/base/init.rb
@@ -512,10 +511,6 @@ files:
 - lib/rrj/process/concurrency.rb
 - lib/rrj/process/event.rb
 - lib/rrj/process/event_admin.rb
-- lib/rrj/process/keepalive/keepalive_initializer.rb
-- lib/rrj/process/keepalive/keepalive_message.rb
-- lib/rrj/process/keepalive/keepalive_thread.rb
-- lib/rrj/process/keepalive/keepalive_timer.rb
 - lib/rrj/rabbit/base_event.rb
 - lib/rrj/rabbit/connect.rb
 - lib/rrj/rabbit/listener/base.rb
@@ -611,9 +606,6 @@ files:
 - spec/ruby_rabbitmq_janus/models/janus_instance_definition_spec.rb
 - spec/ruby_rabbitmq_janus/models/janus_instance_spec.rb
 - spec/ruby_rabbitmq_janus/process/concurrencies/concurrency_spec.rb
-- spec/ruby_rabbitmq_janus/process/concurrencies/keepalive_initializer_spec.rb
-- spec/ruby_rabbitmq_janus/process/concurrencies/keepalive_thread_spec.rb
-- spec/ruby_rabbitmq_janus/process/concurrencies/keepalive_timer_spec.rb
 - spec/ruby_rabbitmq_janus/rabbit/connect_spec.rb
 - spec/ruby_rabbitmq_janus/rabbit/listener/from_spec.rb
 - spec/ruby_rabbitmq_janus/rabbit/propertie_2_spec.rb

data/lib/rrj/binary.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module RubyRabbitmqJanus
-  # :reek:InstanceVariableAssumption
-
-  # # RubyRabbitmqJanus Bynary
-  #
-  # Initialize tools for a standalone executable
-  # This class start all tool mandatory for
-  # survey new message about JanusInstance change state.
-  #
-  # When status enable change update document in database
-  # if enable become true a new session with janus is created
-  class Binary
-    def initialize
-      start_instances
-    end
-
-    def update_instance(data)
-      enable = data['enable']
-      @ji = RubyRabbitmqJanus::Models::JanusInstance.find(data['id'])
-
-      ::Log.info 'Update Janus Instance ...'
-      enable ? start_instance : stop_instance
-    end
-
-    private
-
-    def start_instances
-      ::Log.info 'Search Janus Instance'
-      instances = RubyRabbitmqJanus::Models::JanusInstance.enabled
-
-      ::Log.info "Find [#{instances.count}] instance(s) enable"
-      instances.each(&:create_keepalive) unless instances.empty?
-    end
-
-    def start_instance
-      ::Log.info "... create a session to Janus Instance with id : #{@ji.id}"
-      @ji.create_keepalive
-    end
-
-    def stop_instance
-      ::Log.info "... stop a session to Janus Instance with ID : #{@ji.id}"
-      @ji.stop_keepalive
-    end
-  end
-end

data/lib/rrj/process/keepalive/keepalive_initializer.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require 'rrj/process/keepalive/keepalive_timer'
-require 'rrj/process/keepalive/keepalive_message'
-require 'rrj/process/keepalive/keepalive_thread'
-
-module RubyRabbitmqJanus
-  module Process
-    module Concurrencies
-      # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-      #
-      # # Manage keepalive message
-      #
-      # Create a thread for sending a message with type keepalive to session
-      # created by this instanciate gem
-      class KeepaliveInitializer < Concurrency
-        # Initialize a singleton object for sending keepalive to janus
-        def initialize(instance)
-          super()
-          @thread = KeepaliveThread.new(instance, rabbit) { initialize_thread }
-        rescue
-          raise Errors::Process::KeepaliveInitializer::Initializer
-        end
-
-        # Get thread with Ruby ID
-        def self.thread(thread)
-          ObjectSpace._id2ref(thread)
-        rescue RangeError
-          raise Errors::Process::KeepaliveInitializer::ID2Ref, thread
-        end
-
-        # Give a session Integer  his gem is instantiate.
-        # Is waiting a thread return a response to message created sending.
-        #
-        # @example Ask session
-        #   KeepaliveInitializer.new(123).session
-        #   => 852803383803249
-        #
-        # @return [Fixnum] Identifier to session created by Janus
-        def session
-          @thread.timer.session do
-            lock.synchronize do
-              condition.wait(lock)
-              @thread.session
-            end
-          end
-        rescue
-          raise Errors::Process::KeepaliveInitializer::Session
-        end
-
-        # Ask Object ID to thread managing keepalive message
-        #
-        # @example Ask ID
-        #   KeepaliveInitializer.new(123).thread
-        #   => 70233080652140
-        #
-        # @return [Integer] Identifier to thread in Ruby
-        def thread_id
-          @thread.__id__
-        rescue
-          raise Errors::Process::KeepaliveInitializer::Thread
-        end
-
-        private
-
-        def transaction_running
-          @thread.initialize_janus_session
-          lock.synchronize { condition.signal }
-          @thread.start
-        end
-      end
-    end
-  end
-end

data/lib/rrj/process/keepalive/keepalive_message.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-# :reek:UtilityFunction
-
-module RubyRabbitmqJanus
-  module Process
-    module Concurrencies
-      # Manage message used for keepalive thread
-      #
-      # @attribute [r] instance
-      #   @return [String] ID to Janus Instance
-      class KeepaliveMessage
-        attr_reader :instance
-
-        def initialize(instance)
-          @instance = instance.id
-        end
-
-        def session
-          Janus::Messages::Standard.new('base::create', param_instance)
-        end
-
-        def response_session(message)
-          RubyRabbitmqJanus::Janus::Responses::Standard.new(message).session
-        end
-
-        def keepalive(session)
-          parameter = param_session(session)
-          Janus::Messages::Standard.new('base::keepalive', parameter)
-        end
-
-        def response_acknowledgement(message)
-          RubyRabbitmqJanus::Janus::Responses::Standard.new(message).error?
-        end
-
-        def destroy(session)
-          parameter = param_session(session)
-          Janus::Messages::Standard.new('base::destroy', parameter)
-        end
-
-        def response_destroy(message)
-          RubyRabbitmqJanus::Janus::Responses::Standard.new(message)
-        end
-
-        private
-
-        def param_instance
-          { 'instance' => @instance }
-        end
-
-        def param_session(session)
-          { 'session_id' => session }.merge(param_instance)
-        end
-      end
-    end
-  end
-end

data/lib/rrj/process/keepalive/keepalive_thread.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Metrics/ClassLength
-# rubocop:disable Metrics/MethodLength
-
-# :reek:TooManyInstanceVariables
-# :reek:TooManyStatements
-# :reek:UncommunicativeVariableName
-# :reek:TooManyMethods
-
-module RubyRabbitmqJanus
-  module Process
-    module Concurrencies
-      # Object thread for manage keep a live with Janus Instance
-      #
-      # @!attribute [r] session
-      #   @return [Integer] Number to session linked to Janus Instance
-      class KeepaliveThread < Thread
-        attr_reader :timer, :session
-
-        def initialize(instance, rabbit, &block)
-          @publisher = @session = nil
-          @rabbit = rabbit
-          @timer = KeepaliveTimer.new
-          @message = KeepaliveMessage.new(instance)
-          instance.set(thread: __id__)
-          ::Log.info "Keepalive thread id is #{__id__}"
-          super(&block)
-        rescue
-          raise Errors::Process::KeepaliveThread::Initializer
-        end
-
-        # Initialize a transaction with Janus Instance.
-        # Create a session and save response
-        def initialize_janus_session
-          @publisher = publisher
-          @session = response_session
-        rescue
-          raise Errors::Process::KeepaliveThread::InitializeJanusSession
-        end
-
-        # Restart session
-        # :reek:TooManyStatements
-        def restart_session
-          ::Log.warn 'Restart session ...'
-          janus = find_model
-          if janus.present?
-            send_messages_restart
-            janus.set(session: @session)
-          else
-            ::Log.error 'Janus Instance Model is gone, giving up'
-          end
-        rescue
-          raise Errors::Process::KeepaliveThread::RestartSession
-        end
-
-        # Start a timer for TTL
-        # rubocop:disable Metrics/AbcSize
-        # :reek:TooManyStatements
-        def start
-          @timer.loop_keepalive do
-            if detached?(find_model)
-              ::Log.info \
-                "Thread #{__id__} no longer attached to Janus Instance, " \
-                'exiting...'
-              @timer.stop_timer
-              cleanup
-              exit
-            else
-              ::Log.info msg_send_ttl(__id__,
-                                      @message.instance,
-                                      @timer.time_to_live)
-              response_keepalive
-            end
-          end
-        rescue
-          raise Errors::Process::KeepaliveThread::Start
-        end
-        # rubocop:enable Metrics/AbcSize
-
-        # Kill session and disable instance
-        def kill
-          cleanup
-          super
-        rescue
-          raise Errors::Process::KeepaliveThread::Kill
-        end
-
-        # :reek:TooManyStatements
-        def instance_is_down
-          janus = find_model
-          @session = @message = nil
-          if detached?(janus)
-            ::Log.error\
-              "Thread [#{__id__}] no longer attached to Janus Instance " \
-              '(should be dead).'
-          else
-            janus.set(enable: false).unset(%I[thread session])
-            ::Log.fatal \
-              "Janus Instance [#{janus.instance}] is down, " \
-              "thread [#{__id__}] will die."
-          end
-        rescue
-          raise Errors::Process::KeepaliveThread::InstanceIsDown
-        end
-
-        private
-
-        attr_reader :instance
-
-        def send_messages_restart
-          @session = response_session
-          response_keepalive
-        end
-
-        def cleanup
-          response_destroy if @session.present? && @message.present?
-          @rabbit.close
-        end
-
-        def find_model
-          if @message.present?
-            Models::JanusInstance.find(@message.instance)
-          else
-            ::Log.warn \
-              "Lookup Janus Instance model by session [#{@session}]"
-            Models::JanusInstance.find_by_session(@session)
-          end
-        rescue StandardError => exception
-          ::Log.debug exception
-          ::Log.warn \
-            "find_model: rescuing from error #{e.message}"
-          nil
-        end
-
-        # :reek:FeatureEnvy
-        def detached?(janus)
-          janus.blank? || janus.thread != __id__
-        end
-
-        def publisher
-          Rabbit::Publisher::Keepalive.new(@rabbit.channel)
-        end
-
-        def response_session
-          @message.response_session(publish(@message.session))
-        end
-
-        def response_keepalive
-          keepalive = @message.keepalive(@session)
-          @message.response_acknowledgement(publish(keepalive))
-        end
-
-        def response_destroy
-          destroy = @message.destroy(@session)
-          @message.response_destroy(publish(destroy))
-        end
-
-        def publish(message)
-          @publisher.publish(message)
-        end
-
-        def msg_send_ttl(id, inst, ttl)
-          "Thread #{id} sending keepalive to instance #{inst} with TTL #{ttl}"
-        end
-      end
-    end
-  end
-end
-
-# rubocop:enable Metrics/ClassLength
-# rubocop:enable Metrics/MethodLength

data/lib/rrj/process/keepalive/keepalive_timer.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require 'timeout'
-require 'timers'
-
-# :reek:DuplicateMethodCall
-
-module RubyRabbitmqJanus
-  module Process
-    module Concurrencies
-      # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-      #
-      # # Manage time for thread
-      #
-      # Configure all timer used in keepalive class
-      #
-      # @!attribute [r] time_to_live
-      #   @return [Integer] Time for interval between keepalive message
-      # @!attribute [r] time_to_die
-      #   @return [Integer] Time before timer stop it
-      class KeepaliveTimer
-        attr_reader :time_to_live, :time_to_die
-
-        # Initialize timer to keeaplive thread.
-        def initialize
-          @time_to_live = Tools::Config.instance.ttl
-          @time_to_die = test_time_to_die >= 60 ? 59 : test_time_to_die
-          @timers = Timers::Group.new
-          @timer = nil
-        rescue
-          raise Errors::Process::KeepaliveTimer::Initializer
-        end
-
-        # Execute a loop with timer for sending keepalive message
-        # to Janus Instance
-        def loop_keepalive(&block)
-          @timer = @timers.now_and_every(@time_to_live) { prepare_loop(&block) }
-          loop { @timers.wait }
-        rescue
-          raise Errors::Process::KeepaliveTimer::LoopKeepalive
-        end
-
-        # Test if session is present/exist in Janus Instance
-        def session(&block)
-          Timeout.timeout(@time_to_die) { yield }
-        rescue Timeout::Error
-          block.binding.receiver.instance_is_down
-        rescue
-          raise Errors::Process::KeepaliveTimer::Session
-        end
-
-        # Stop timer to keepalive thread
-        def stop_timer
-          @timer.cancel
-          @timer = nil
-        rescue
-          raise Errors::Process::KeepaliveTimer::StopTimer
-        end
-
-        private
-
-        # :reek:FeatureEnvy
-        def prepare_loop(&block)
-          Timeout.timeout(@time_to_die) do
-            block.binding.receiver.restart_session if yield
-          end
-        rescue Timeout::Error
-          block.binding.receiver.instance_is_down
-        end
-
-        def test_time_to_die
-          @time_to_live + 5
-        end
-      end
-    end
-  end
-end

data/spec/ruby_rabbitmq_janus/process/concurrencies/keepalive_initializer_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe RubyRabbitmqJanus::Process::Concurrencies::KeepaliveInitializer, type: :thread, name: :keepalive_initializer do
-  let(:instance) { RubyRabbitmqJanus::Models::JanusInstance.find((ENV['MONGO'].match?('true') ? %w[1 2] : [1, 2]).sample) }
-  let(:concurrency) { described_class.new(instance) }
-
-  it { expect(concurrency.send(:rabbit)).to be_a(RubyRabbitmqJanus::Rabbit::Connect) }
-  it { expect(concurrency.send(:lock)).to be_a(Mutex) }
-  it { expect(concurrency.send(:condition)).to be_a(ConditionVariable) }
-  it { expect(concurrency.instance_variable_get(:@thread)).to be_a(RubyRabbitmqJanus::Process::Concurrencies::KeepaliveThread) }
-end

data/spec/ruby_rabbitmq_janus/process/concurrencies/keepalive_thread_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe RubyRabbitmqJanus::Process::Concurrencies::KeepaliveThread, type: :thread, name: :keepalive_thread do
-  let(:instance) { RubyRabbitmqJanus::Models::JanusInstance.find((ENV['MONGO'].match?('true') ? %w[1 2] : [1, 2]).sample) }
-  let(:rabbit) { RubyRabbitmqJanus::Process::Concurrencies::Concurrency.new.send(:rabbit) }
-  let(:concurrency) { described_class.new(instance, rabbit) { nil } }
-
-  it { expect(concurrency.instance_variable_get(:@session)).to be(nil) }
-  it { expect(concurrency.instance_variable_get(:@publisher)).to be(nil) }
-  it { expect(concurrency.instance_variable_get(:@rabbit)).to be_a(RubyRabbitmqJanus::Rabbit::Connect) }
-  it { expect(concurrency.instance_variable_get(:@timer)).to be_a(RubyRabbitmqJanus::Process::Concurrencies::KeepaliveTimer) }
-  it { expect(concurrency.instance_variable_get(:@message)).to be_a(RubyRabbitmqJanus::Process::Concurrencies::KeepaliveMessage) }
-end

data/spec/ruby_rabbitmq_janus/process/concurrencies/keepalive_timer_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe RubyRabbitmqJanus::Process::Concurrencies::KeepaliveTimer, type: :thread, name: :keepalive_timer do
-  let(:concurrency) { described_class.new }
-
-  it { expect(concurrency.send(:time_to_live)).to be_a(Integer) }
-  it { expect(concurrency.send(:time_to_die)).to be_a(Integer) }
-  it { expect(concurrency.instance_variable_get(:@timers)).to be_a(Timers::Group) }
-  it { expect(concurrency.instance_variable_get(:@time_to_live)).to eql(RubyRabbitmqJanus::Tools::Config.instance.options['janus']['session']['keepalive']) }
-end