updating rspec tests

Author: Esity

.github/workflows/rspec.yml

@@ -0,0 +1,53 @@
+name: RSpec
+on: [push, pull_request]
+
+jobs:
+  rspec:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        ruby: [2.7]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: RSpec run
+        run: |
+          bash -c "
+            bundle exec rspec
+            [[ $? -ne 2 ]]
+          "
+  rspec-mri:
+    needs: rspec
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-latest ]
+        ruby: [2.5, 2.6, '3.0', head]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rspec
+  rspec-truffleruby:
+    needs: rspec
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-latest ]
+        ruby: [truffleruby]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rspec

lib/telemetry/logger/builder.rb

@@ -1,6 +1,12 @@
+require 'logger'
+
 module Telemetry
   module Logger
     module Builder
+      def opts
+        @opts ||= {}
+      end
+
       def format(include_pid: false, **)
         log.formatter = proc do |severity, datetime, _progname, msg|
           string = "[#{datetime}]"
@@ -11,11 +17,17 @@ def format(include_pid: false, **)
       end
 
       def log
-        @log ||= output
+        @log ||= output(**opts)
       end
 
       def output(**options)
+        return @log unless @log.nil?
+
         @log = ::Logger.new(options[:log_file] || $stdout)
+        self.log_level = options[:level] if options.key? :level
+        self.format
+
+        @log
       end
 
       def level

lib/telemetry/logger/defaults.rb

@@ -1,3 +1,5 @@
+require 'socket'
+
 module Telemetry
   module Logger
     module Defaults
@@ -6,15 +8,19 @@ def socket_hostname
       end
 
       def env_prefix
-        @opts[:env_prefix] || 'telemetry'
+        opts[:env_prefix] || 'telemetry'
       end
 
       def application
-        opts.key?(:application) ? @opts[:application] : 'telemetry'
+        opts[:application] || 'telemetry'
       end
 
       def app_version
-        opts.key?(:app_version) ? @opts[:app_version] : Telemetry::Telemetry::VERSION
+        opts[:app_version] || Telemetry::Logger::VERSION
+      end
+
+      def opts
+        @opts ||= {}
       end
     end
   end

lib/telemetry/logger/methods.rb

@@ -1,26 +1,14 @@
 module Telemetry
   module Logger
     module Methods
-      def opts
-        @opts ||= {}
-      end
-
       def colorize
-        opts[:color] || opts[:logfile].is_a?(String) || true
-      end
-
-      def trace(raw_message = nil, size: @trace_size, log_caller: true) # rubocop:disable  Metrics/AbcSize
-        return unless @trace_enabled
-
-        raw_message = yield if raw_message.nil? && block_given?
-        message = Rainbow('Tracing: ').cyan
-        message.concat Rainbow("#{raw_message} ").cyan
-        if log_caller && size.nil?
-          message.concat Rainbow(caller_locations).cyan.underline
-        elsif log_caller
-          message.concat Rainbow(caller_locations[0..size]).cyan.underline
-        end
-        log.unknown(message)
+        @colorize ||= if opts[:logfile].is_a?(String)
+                        false
+                      elsif opts.key? :color
+                        opts[:color]
+                      else
+                        true
+                      end
       end
 
       def debug(message = nil)

spec/builder_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'telemetry/logger/version'
+require 'telemetry/logger/builder'
+
+RSpec.describe Telemetry::Logger::Builder do
+  it { should be_a Module }
+  before :all do
+    @class = Class.new do
+      def initialize(**opts)
+        @opts = opts
+      end
+      include Telemetry::Logger::Builder
+    end
+  end
+
+  it 'should respond to log' do
+    expect(@class.new(level: 'debug').level).to eq 0
+    expect(@class.new(level: 'info').level).to eq 1
+    expect(@class.new(level: 'warn').level).to eq 2
+    expect(@class.new(level: 'error').level).to eq 3
+    expect(@class.new(level: 'fatal').level).to eq 4
+  end
+
+  it 'should respond to level' do
+    expect(@class.new.log_level = 'warn').to eq 'warn'
+    expect(@class.new.level).to eq 0
+    new_class = @class.new(level: 'warn')
+    new_class.log_level = 'warn'
+    expect(new_class.level).to eq 2
+  end
+
+  it 'can modify the log level' do
+    modify_level = @class.new
+    expect(modify_level.level).to eq 0
+    expect { modify_level.log_level = 'debug' }.not_to raise_exception
+    expect(modify_level.level).to eq 0
+    expect { modify_level.log_level = 'info' }.not_to raise_exception
+    expect(modify_level.level).to eq 1
+    expect { modify_level.log_level = 'warn' }.not_to raise_exception
+    expect(modify_level.level).to eq 2
+    expect { modify_level.log_level = 'error' }.not_to raise_exception
+    expect(modify_level.level).to eq 3
+    expect { modify_level.log_level = 'fatal' }.not_to raise_exception
+    expect(modify_level.level).to eq 4
+
+    expect(modify_level.log_level = nil).to eq nil
+    expect(modify_level.level).to eq 42
+
+    expect(modify_level.log_level = 'foobar').to eq 'foobar'
+    expect(modify_level.level).to eq 0
+
+    expect(modify_level.log_level = 111).to eq 111
+    expect(modify_level.level).to eq 111
+  end
+
+  it 'can call the formatter' do
+    expect(@class.new.format).to be_a Proc
+    expect(@class.new.format(include_pid: true)).to be_a Proc
+  end
+end

spec/defaults_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'telemetry/logger/version'
+require 'telemetry/logger/defaults'
+
+RSpec.describe Telemetry::Logger::Defaults do
+  it { should be_a Module }
+  before :all do
+    @class = Class.new do
+      def initialize(**opts)
+        @opts = opts
+      end
+      include Telemetry::Logger::Defaults
+    end
+  end
+
+  it 'should have an env_prefix' do
+    expect(@class.new.env_prefix).to eq 'telemetry'
+    expect(@class.new(env_prefix: 'foobar').env_prefix).to eq 'foobar'
+  end
+
+  it 'should have a socket_hostname' do
+    expect(@class.new.socket_hostname).to be_a String
+  end
+
+  it 'should have an application' do
+    expect(@class.new.application).to eq 'telemetry'
+    expect(@class.new(application: 'foobar').application).to eq 'foobar'
+  end
+
+  it 'should have an app_version' do
+    expect(@class.new.app_version).to eq Telemetry::Logger::VERSION
+    expect(@class.new(app_version: 'foobar').app_version).to eq 'foobar'
+  end
+end

spec/logger_spec.rb

@@ -1,8 +1,41 @@
 require 'spec_helper'
+require 'telemetry/logger'
 
 RSpec.describe Telemetry::Logger do
   it { should be_a Module }
+
+  # before :all do
+  #   Telemetry::Logger.setup(level: 'debug')
+  # end
   it 'should have a version number' do
-    expect(described_class::VERSION).to be_a String
+    expect(Telemetry::Logger::VERSION).to be_a String
+  end
+
+  it 'should have a setup command' do
+    expect(Telemetry::Logger).to respond_to :setup
+  end
+
+  it 'should be able to log debug' do
+    expect { Telemetry::Logger.debug('testing') }.to output(/DEBUG/).to_stdout_from_any_process
+  end
+
+  it 'should be able to log info' do
+    expect { Telemetry::Logger.info('testing') }.to output(/INFO/).to_stdout_from_any_process
+  end
+
+  it 'should be able to log warn' do
+    expect { Telemetry::Logger.warn('testing') }.to output(/WARN/).to_stdout_from_any_process
+  end
+
+  it 'should be able to log error' do
+    expect { Telemetry::Logger.error('testing') }.to output(/ERROR/).to_stdout_from_any_process
+  end
+
+  it 'should be able to log fatal' do
+    expect { Telemetry::Logger.fatal('testing') }.to output(/FATAL/).to_stdout_from_any_process
+  end
+
+  it 'should be able to log unknown' do
+    expect { Telemetry::Logger.unknown('testing') }.to output(/ANY/).to_stdout_from_any_process
   end
 end

spec/methods_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'telemetry/logger/version'
+require 'telemetry/logger/methods'
+
+RSpec.describe Telemetry::Logger::Methods do
+  it { should be_a Module }
+  before :all do
+    @class = Class.new do
+      include Telemetry::Logger::Methods
+      include Telemetry::Logger::Builder
+
+      def initialize(**opts)
+        @opts = opts
+      end
+
+      def opts
+        @opts ||= {}
+      end
+    end
+  end
+
+  it 'can colorize' do
+    expect(@class.new(color: false).colorize).to eq false
+    expect(@class.new(color: true).colorize).to eq true
+    expect(@class.new.colorize).to eq true
+    expect(@class.new(color: true, logfile: './test.log').colorize).to eq false
+  end
+
+  it 'can debug' do
+    expect { @class.new.debug('testing') }.to output(/DEBUG/).to_stdout_from_any_process
+    expect { @class.new(level: 'debug').debug('testing') }.to output(/DEBUG/).to_stdout_from_any_process
+    expect { @class.new(level: 'info').debug('testing') }.not_to output(/DEBUG/).to_stdout_from_any_process
+    expect { @class.new(level: 'warn').debug('testing') }.not_to output(/DEBUG/).to_stdout_from_any_process
+    expect { @class.new(level: 'error').debug('testing') }.not_to output(/DEBUG/).to_stdout_from_any_process
+    expect { @class.new(level: 'fatal').debug('testing') }.not_to output(/DEBUG/).to_stdout_from_any_process
+  end
+
+  it 'can info' do
+    expect { @class.new.info('testing') }.to output(/INFO/).to_stdout_from_any_process
+    expect { @class.new(level: 'info').info('testing') }.to output(/INFO/).to_stdout_from_any_process
+    expect { @class.new(level: 'info').debug('testing') }.not_to output(/DEBUG/).to_stdout_from_any_process
+  end
+
+  it 'can warn' do
+    expect { @class.new.warn('testing') }.to output(/WARN/).to_stdout_from_any_process
+    expect { @class.new(level: 'warn').warn('testing') }.to output(/WARN/).to_stdout_from_any_process
+  end
+
+  it 'can error' do
+    expect { @class.new.error('testing') }.to output(/ERROR/).to_stdout_from_any_process
+    expect { @class.new(level: 'error').error('testing') }.to output(/ERROR/).to_stdout_from_any_process
+  end
+
+  it 'can fatal' do
+    expect { @class.new.fatal('testing') }.to output(/FATAL/).to_stdout_from_any_process
+    expect { @class.new(level: 'fatal').fatal('testing') }.to output(/FATAL/).to_stdout_from_any_process
+  end
+
+  it 'can unknown' do
+    expect { @class.new.unknown('testing') }.to output(/ANY/).to_stdout_from_any_process
+  end
+
+  it 'can return thread info' do
+    expect(@class.new.thread).to be_a String
+    expect(@class.new.thread(kvl: false)).to be_a String
+    expect(@class.new.thread(kvl: true)).to be_a String
+  end
+
+  it 'has an opts hash' do
+    expect(@class.new.opts).to eq({})
+  end
+end