tty-logger 0.2.0 → 0.3.0

data/spec/unit/handlers/stream_spec.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Logger, "#log" do
-  let(:output) { StringIO.new }
-
-  it "logs message with fields in text format" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [:stream]
-    end
-
-    logger.info("Successfully deployed", app: 'myapp', env: 'prod')
-
-    expect(output.string).to eq([
-      "level=info message=\"Successfully deployed\" ",
-      "app=myapp env=prod\n"
-    ].join)
-  end
-
-  it "logs message with all metadata in text format" do
-    time_now = Time.new(2019, 7, 21, 14, 04, 35, "+02:00")
-    allow(Time).to receive(:now).and_return(time_now)
-
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [:stream]
-      config.metadata = [:all]
-    end
-
-    logger.info("Successfully deployed", app: 'myapp', env: 'prod')
-
-    expect(output.string).to eq([
-      "pid=#{Process.pid} ",
-      "date=\"2019-07-21\" ",
-      "time=\"14:04:35.000\" ",
-      "path=\"#{__FILE__}:#{__LINE__ - 6}:in`<top (required)>`\" ",
-      "level=info message=\"Successfully deployed\" ",
-      "app=myapp env=prod\n"
-    ].join)
-  end
-
-  it "logs message with fields in JSON format" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [[:stream, formatter: :json]]
-    end
-
-    logger.info("Successfully deployed", app: 'myapp', env: 'prod')
-
-    expect(output.string).to eq([
-      "{\"level\":\"info\",\"message\":\"Successfully deployed\",",
-      "\"app\":\"myapp\",\"env\":\"prod\"}\n"
-    ].join)
-  end
-
-  it "logs message with all metadata in json format" do
-    time_now = Time.new(2019, 7, 21, 14, 04, 35, "+02:00")
-    allow(Time).to receive(:now).and_return(time_now)
-
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [[:stream, formatter: :json]]
-      config.metadata = [:all]
-    end
-
-    logger.info("Successfully deployed")
-
-    expect(output.string).to eq([
-      "{\"pid\":#{Process.pid},",
-      "\"date\":\"2019-07-21\",",
-      "\"time\":\"14:04:35.000\",",
-      "\"path\":\"#{__FILE__}:#{__LINE__ - 6}:in`<top (required)>`\",",
-      "\"level\":\"info\",\"message\":\"Successfully deployed\"}\n"
-    ].join)
-  end
-end

data/spec/unit/levels_spec.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Logger, 'levels' do
-  it "fails when unknown level" do
-    logger = TTY::Logger.new
-    expect {
-      logger.compare_levels(:error, :unknown)
-    }.to raise_error(ArgumentError, "Invalid level :unknown")
-  end
-
-  it "compares names with equal level" do
-    logger = TTY::Logger.new
-    expect(logger.compare_levels(:info, :info)).to eq(:eq)
-  end
-
-  it "compares names with equal level" do
-    logger = TTY::Logger.new
-    expect(logger.compare_levels("INFO", "INFO")).to eq(:eq)
-  end
-
-  it "compares numbers with equal level" do
-    logger = TTY::Logger.new
-    expect(logger.compare_levels(TTY::Logger::INFO_LEVEL, TTY::Logger::INFO_LEVEL)).to eq(:eq)
-  end
-
-  it "compares names with lower level" do
-    logger = TTY::Logger.new
-    expect(logger.compare_levels(:debug, :warn)).to eq(:lt)
-  end
-
-  it "compares numbers with lower level" do
-    logger = TTY::Logger.new
-    expect(logger.compare_levels(TTY::Logger::DEBUG_LEVEL, TTY::Logger::WARN_LEVEL)).to eq(:lt)
-  end
-
-  it "compares names with greater level" do
-    logger = TTY::Logger.new
-    expect(logger.compare_levels(:error, :info)).to eq(:gt)
-  end
-end

data/spec/unit/log_at_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Logger, "#log_at" do
-  let(:output) { StringIO.new }
-
-  it "logs temporarily at noisy level" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [:stream]
-    end
-
-    logger.debug("not logged")
-
-    logger.log_at :debug do
-      logger.debug("logged")
-    end
-
-    logger.debug("not logged")
-
-    expect(output.string).to eq("level=debug message=logged\n")
-  end
-
-  it "logs temporarily at quiet level" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [:stream]
-    end
-
-    logger.log_at TTY::Logger::ERROR_LEVEL do
-      logger.debug("not logged")
-      logger.error("logged")
-    end
-
-    expect(output.string).to eq("level=error message=logged\n")
-  end
-end

data/spec/unit/log_metadata_spec.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Logger, "log metadata" do
-  let(:output) { StringIO.new }
-  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
-
-  it "outputs metadata" do
-    time_now = Time.new(2019, 7, 10, 19, 42, 35, "+02:00")
-    allow(Time).to receive(:now).and_return(time_now)
-
-    logger = TTY::Logger.new(output: output) do |config|
-      config.metadata = [:time, :date, :file]
-    end
-
-    logger.info("Deploying", app: "myapp", env: "prod")
-
-    expected_output = [
-      "\e[37m[19:42:35.000]\e[0m ",
-      "\e[37m[2019-07-10]\e[0m ",
-      "\e[37m[#{__FILE__}:#{__LINE__ - 5}:in`<top (required)>`]\e[0m",
-      " #{TTY::Logger::Handlers::Console::ARROW} ",
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Deploying                 ",
-      "\e[32mapp\e[0m=myapp \e[32menv\e[0m=prod\n"
-    ].join
-
-    expect(output.string).to eq(expected_output)
-  end
-
-  it "outputs all metadata when :all key used" do
-    time_now = Time.new(2019, 7, 10, 19, 42, 35, "+02:00")
-    allow(Time).to receive(:now).and_return(time_now)
-
-    logger = TTY::Logger.new(output: output) do |config|
-      config.metadata = [:all]
-    end
-
-    logger.info("Deploying", app: "myapp", env: "prod")
-
-    expected_output = [
-      "\e[37m[#{Process.pid}]\e[0m ",
-      "\e[37m[2019-07-10]\e[0m ",
-      "\e[37m[19:42:35.000]\e[0m ",
-      "\e[37m[#{__FILE__}:#{__LINE__ - 6}:in`<top (required)>`]\e[0m",
-      " #{TTY::Logger::Handlers::Console::ARROW} ",
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Deploying                 ",
-      "\e[32mapp\e[0m=myapp \e[32menv\e[0m=prod\n"
-    ].join
-
-    expect(output.string).to eq(expected_output)
-  end
-end

data/spec/unit/log_spec.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Logger, "#log" do
-  let(:output) { StringIO.new }
-  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
-
-  it "logs without a method name directly using level" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.level = :debug
-    end
-
-    logger.log(:debug, "Deploying...")
-
-    expect(output.string).to eq([
-      "\e[36m#{styles[:debug][:symbol]}\e[0m ",
-      "\e[36mdebug\e[0m   ",
-      "Deploying...             \n"
-    ].join)
-  end
-
-  it "logs a message at debug level" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.level = :debug
-    end
-
-    logger.debug("Successfully", "deployed")
-
-    expect(output.string).to eq([
-      "\e[36m#{styles[:debug][:symbol]}\e[0m ",
-      "\e[36mdebug\e[0m   ",
-      "Successfully deployed    \n"].join)
-  end
-
-  it "logs a message at info level" do
-    logger = TTY::Logger.new(output: output)
-
-    logger.info("Successfully", "deployed")
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Successfully deployed    \n"].join)
-  end
-
-  it "logs a message at warn level" do
-    logger = TTY::Logger.new(output: output)
-
-    logger.warn("Failed to", "deploy")
-
-    expect(output.string).to eq([
-      "\e[33m#{styles[:warn][:symbol]}\e[0m ",
-      "\e[33mwarning\e[0m ",
-      "Failed to deploy         \n"].join)
-  end
-
-  it "logs a message at error level" do
-    logger = TTY::Logger.new(output: output)
-
-    logger.error("Failed to", "deploy")
-
-    expect(output.string).to eq([
-      "\e[31m#{styles[:error][:symbol]}\e[0m ",
-      "\e[31merror\e[0m   ",
-      "Failed to deploy         \n"].join)
-  end
-
-  it "logs a message at fatal level" do
-    logger = TTY::Logger.new(output: output)
-
-    logger.fatal("Failed to", "deploy")
-
-    expect(output.string).to eq([
-      "\e[31m#{styles[:fatal][:symbol]}\e[0m ",
-      "\e[31mfatal\e[0m   ",
-      "Failed to deploy         \n"].join)
-  end
-
-  it "logs a success message at info level" do
-    logger = TTY::Logger.new(output: output)
-
-    logger.success("Deployed", "successfully")
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:success][:symbol]}\e[0m ",
-      "\e[32msuccess\e[0m ",
-      "Deployed successfully    \n"].join)
-  end
-
-  it "logs a wait message at info level" do
-    logger = TTY::Logger.new(output: output)
-
-    logger.wait("Waiting for", "deploy")
-
-    expect(output.string).to eq([
-      "\e[36m#{styles[:wait][:symbol]}\e[0m ",
-      "\e[36mwaiting\e[0m ",
-      "Waiting for deploy       \n"].join)
-  end
-
-  it "logs a message in a block" do
-    logger = TTY::Logger.new(output: output)
-
-    logger.info { "Successfully deployed" }
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Successfully deployed    \n"].join)
-  end
-
-  it "logs a message in a block as an array of elements" do
-    logger = TTY::Logger.new(output: output)
-
-    logger.info { ["Successfully", "deployed"] }
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Successfully deployed    \n"].join)
-  end
-
-  it "logs a message in a block with metadata" do
-    logger = TTY::Logger.new(output: output)
-
-    logger.info { ["Successfully", "deployed", {app: "myapp", env: "prod"}] }
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Successfully deployed     ",
-      "\e[32mapp\e[0m=myapp \e[32menv\e[0m=prod\n"
-    ].join)
-  end
-
-  it "doesn't log when lower level" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.level = :warn
-    end
-
-    logger.debug("Successfully deployed")
-
-    expect(output.string).to eq("")
-  end
-
-  it "logs message with global fields" do
-    logger = TTY::Logger.new(output: output, fields: {app: 'myapp', env: 'prod'})
-
-    logger.info("Successfully deployed")
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Successfully deployed     ",
-      "\e[32mapp\e[0m=myapp \e[32menv\e[0m=prod\n"].join)
-  end
-
-  it "logs message with scoped fields" do
-    logger = TTY::Logger.new(output: output)
-
-    logger.info("Successfully deployed", app: 'myapp', env: 'prod')
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Successfully deployed     ",
-      "\e[32mapp\e[0m=myapp \e[32menv\e[0m=prod\n"].join)
-  end
-
-  it "adds new custom log type" do
-    heart = "❤"
-    logger = TTY::Logger.new(output: output) do |config|
-      config.types = {thanks: {level: :info}}
-      config.handlers = [
-        [:console, {
-          styles: {
-            thanks: {
-              symbol: heart,
-              label: "thanks",
-              color: :red,
-              levelpad: 1
-            }
-          }
-        }]
-      ]
-    end
-
-    logger.thanks("Great work!", app: "myapp", env: "prod")
-
-    expect(output.string).to eq([
-      "\e[31m#{heart}\e[0m ",
-      "\e[31mthanks\e[0m  ",
-      "Great work!               ",
-      "\e[31mapp\e[0m=myapp \e[31menv\e[0m=prod\n"].join)
-  end
-
-  it "fails to add already defined log type" do
-    expect {
-      TTY::Logger.new do |config|
-        config.types = {success: {level: :info}}
-      end
-    }.to raise_error(TTY::Logger::Error, "Already defined log type :success")
-  end
-end

data/spec/unit/output_spec.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Logger, "outputs" do
-  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
-
-  it "outputs to multiple streams of the same handler" do
-    stream = StringIO.new
-
-    logger = TTY::Logger.new do |config|
-      config.handlers = [[:stream, formatter: :text]]
-      config.output = [stream, stream]
-    end
-
-    logger.info("logging")
-
-    expect(stream.string).to eq([
-      "level=info message=logging\n",
-      "level=info message=logging\n"
-    ].join)
-  end
-
-  it "outputs each handler to a different stream" do
-    stream = StringIO.new
-
-    logger = TTY::Logger.new do |config|
-      config.handlers = [
-        [:console, output: stream],
-        [:stream, output: stream]
-      ]
-    end
-
-    logger.info("logging")
-
-    expect(stream.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m \e[32minfo\e[0m    ",
-      "logging                  \n",
-      "level=info message=logging\n"
-    ].join)
-  end
-end