knapsack_pro 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3adef039c046de79db164cd38d3084cbc96a65e1
-  data.tar.gz: b6ab9ea861472ca04d953d6bbf5a31fe3b43d773
+  metadata.gz: 897d3324c8c5701fb4508d0382716c3bbbe6ed0c
+  data.tar.gz: 6ebf2904dde98152e80e12dfd855e5080f41233a
 SHA512:
-  metadata.gz: f578b2712ed63a8cbb76636c52b5e5968c5a9231b6e54dc75daebc77e91de4e9e33012db345d621be61cc8f44f39a35706a69019cb929b0ced1430568db61ca6
-  data.tar.gz: fe8550b52c912e8e6330dd36c4ad9ca4868028c3ead2375982875437650b6ef59cef89fdcc476039921ed4f0fc4ab8bb37f77e64ae665ae12bb1dcb7c446b466
+  metadata.gz: 9c23494c6858da7833fea766e2f3de502967150219657b3b35cb1fc6b4eb0481bbc6062a76c0a0944092d2b70585443cc3d99954d3a11eed676cba12d01c743d
+  data.tar.gz: f89bf84f3194baacf28b3396ed701d20a2b83d22ece58d2debd8cae591d599ec85605f39b5d9884d9c79e321de04b7d789751924f9a6db20ccbd75374e012730

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 * TODO
 
+### 0.31.0
+
+* Add supported for log levels `fatal` and `error` by `KNAPSACK_PRO_LOG_LEVEL` environment variable.
+* Allow `KNAPSACK_PRO_LOG_LEVEL` case insensitive.
+* Move all messages related to requests to Knapsack Pro API in log `debug` level and keep `info` level only for important messages like how to retry tests in development or info why something works this way or the other (for instance why tests were not executed on the CI node).
+
+    https://github.com/KnapsackPro/knapsack_pro-ruby/pull/29
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v0.30.0...v0.31.0
+
 ### 0.30.0
 
 * Update license to MIT.

data/README.md

@@ -45,7 +45,7 @@ The knapsack_pro has also [queue mode](#queue-mode) to get most optimal test sui
 
 # Requirements
 
-* >= Ruby 2.0.0
+`>= Ruby 2.0.0`
 
 # Table of Contents
 
@@ -119,6 +119,10 @@ The knapsack_pro has also [queue mode](#queue-mode) to get most optimal test sui
   - [How many API keys I need?](#how-many-api-keys-i-need)
   - [What is optimal order of test commands?](#what-is-optimal-order-of-test-commands)
   - [Why my tests are executed twice in queue mode? Why CI node runs whole test suite again?](#why-my-tests-are-executed-twice-in-queue-mode-why-ci-node-runs-whole-test-suite-again)
+  - [How to set `before(:suite)` and `after(:suite)` RSpec hooks in Queue Mode (Percy.io example)?](#how-to-set-beforesuite-and-aftersuite-rspec-hooks-in-queue-mode-percyio-example)
+  - [How to call `before(:suite)` and `after(:suite)` RSpec hooks only once in Queue Mode?](#how-to-call-beforesuite-and-aftersuite-rspec-hooks-only-once-in-queue-mode)
+  - [How to fix capybara-screenshot fail with `SystemStackError: stack level too deep` when using Queue Mode for RSpec?](#how-to-fix-capybara-screenshot-fail-with-systemstackerror-stack-level-too-deep-when-using-queue-mode-for-rspec)
+  - [How to run knapsack_pro with parallel_tests gem?](#how-to-run-knapsack_pro-with-parallel_tests-gem)
 - [Gem tests](#gem-tests)
   - [Spec](#spec)
 - [Contributing](#contributing)
@@ -255,9 +259,11 @@ You can change default Knapsack Pro configuration for RSpec, Cucumber, Minitest
 # you can use your own logger
 require 'logger'
 KnapsackPro.logger = Logger.new(STDOUT)
-KnapsackPro.logger.level = Logger::INFO
+KnapsackPro.logger.level = Logger::DEBUG
 ```
 
+Debug is default log level and it is recommended as default. [Read more](#how-can-i-change-log-level).
+
 ### Setup your CI server (How to set up 2 of 3)
 
 #### Set API key token
@@ -349,12 +355,7 @@ If above command fails then you may need to explicitly pass an argument to requi
 Note if you will run queue mode command for the first time it might be slower.
 The second build should have better optimal test suite split.
 
-If you will encounter problem with stack level too deep then you may want to ensure you load your dependencies only once in `spec/rails_helper.rb` or `spec/spec_helper.rb`. The Queue Mode may load multiple times the `rails_helper.rb` hence the problem. For instance the problem occurs for capybara-screenshot gem. Here is the example how you should load the gem.
-
-    unless ENV['KNAPSACK_PRO_RSPEC_DEPENDENCIES_LOADED']
-      ENV['KNAPSACK_PRO_RSPEC_DEPENDENCIES_LOADED'] = 'true'
-      require 'capybara-screenshot/rspec'
-    end
+If you use capybara-screenshot gem then please [follow this step](#how-to-fix-capybara-screenshot-fail-with-systemstackerror-stack-level-too-deep-when-using-queue-mode-for-rspec).
 
 ### Additional info about queue mode
 
@@ -549,6 +550,8 @@ If you are using circleci.com you can omit `KNAPSACK_PRO_CI_NODE_TOTAL` and `KNA
 Here is an example for test configuration in your `circleci.yml` file.
 
 ```yaml
+# CircleCI 1.0
+
 machine:
   environment:
     # Tokens should be set in CircleCI settings to avoid expose tokens in build logs
@@ -575,6 +578,20 @@ test:
         parallel: true # Caution: there are 8 spaces indentation!
 ```
 
+Here is another example for CircleCI 2.0 platform.
+
+```YAML
+# CircleCI 2.0
+
+# some tests that are not balanced and executed only on first CI node
+- run: case $CIRCLE_NODE_INDEX in 0) npm test ;; esac
+
+# auto-balancing CI build time execution to be flat and optimal (as fast as possible).
+# Queue Mode does dynamic tests allocation so the previous not balanced run command won't
+# create a bottleneck on the CI node
+- run: bundle exec rake knapsack_pro:queue:rspec
+```
+
 Please remember to add additional containers for your project in CircleCI settings.
 
 #### Info for Travis users
@@ -662,6 +679,11 @@ Knapsack Pro supports buildkite ENVs `BUILDKITE_PARALLEL_JOB_COUNT` and `BUILDKI
 
 Please remember to set up token like `KNAPSACK_PRO_TEST_SUITE_TOKEN_RSPEC` as global environment.
 
+Here you can find article [how to set up a new pipeline for your project in Buildkite and configure Knapsack Pro](http://docs.knapsackpro.com/2017/auto-balancing-7-hours-tests-between-100-parallel-jobs-on-ci-buildkite-example) and 2 example repositories for Ruby/Rails projects:
+
+* [Buildkite Rails Parallel Example with Knapsack Pro](https://github.com/KnapsackPro/buildkite-rails-parallel-example-with-knapsack_pro)
+* [Buildkite Rails Docker Parallel Example with Knapsack Pro](https://github.com/KnapsackPro/buildkite-rails-docker-parallel-example-with-knapsack_pro)
+
 #### Info for snap-ci.com users
 
 Knapsack Pro supports snap-ci.com ENVs `SNAP_WORKER_TOTAL` and `SNAP_WORKER_INDEX`. The only thing you need to do is to configure number of workers for your project in configuration settings in order to enable parallelism. Next thing is to set below commands to be executed in your stage:
@@ -832,9 +854,14 @@ knapack_pro gem will retry requests to Knapsack Pro API multiple times every few
 
 You can change log level by specifying the `KNAPSACK_PRO_LOG_LEVEL` environment variable.
 
-    KNAPSACK_PRO_LOG_LEVEL=warn bundle exec rake knapsack_pro:rspec
+    KNAPSACK_PRO_LOG_LEVEL=info bundle exec rake knapsack_pro:rspec
+
+Available values are `debug` (default), `info`, `warn`, `error` and `fatal`.
+
+Recommended log levels you can use:
 
-Available values are `debug`, `info`, and `warn`. The default log level is `info`.
+* `debug` is default log level and it is recommended to log details about requests to Knapsack Pro API. Thanks to that you can debug things or ensure everything works. For instance in [user dashboard](https://knapsackpro.com/dashboard) you can find tips referring to debug logs.
+* `info` level shows message like how to retry tests in development or info why something works this way or the other (for instance why tests were not executed on the CI node). You can use `info` level when you really don't want to see all debug messages from default log level.
 
 ### How to split tests based on test level instead of test file level?
 
@@ -995,6 +1022,8 @@ Note:
 
 ### What is optimal order of test commands?
 
+__Tip 1:__
+
 I recommend to run first the test commands in the regular mode and later the commands in the queue mode.
 
   * Step 1. `bundle exec rake knapsack_pro:cucumber` (regular mode)
@@ -1002,12 +1031,158 @@ I recommend to run first the test commands in the regular mode and later the com
 
 Thanks to that when for some reason the tests executed for cucumber in regular mode will not be well balanced across CI nodes (for instance when one of CI node has bad performance) then the rspec tests executed later in the queue mode will autobalance your build.
 
+__Tip 2:__
+
+When you have short test suite, for instance in javascript then you could distribute tests this way:
+
+* CI 0
+  * Step 1: `npm test`
+  * Step 2: `bundle exec rake knapsack_pro:queue:rspec`
+
+* CI 1
+  * Step 1: `bundle exec rake knapsack_pro:queue:rspec`
+
+You will run your javascript tests on single CI node and the knapack_pro will auto-balance CI build with Queue Mode. Thanks to that CI build time execution will be flat and optimal (as fast as possible).
+
 ### Why my tests are executed twice in queue mode? Why CI node runs whole test suite again?
 
 This may happen when one of your CI node started work later when all other CI nodes already executed whole test suite.
 The slow CI node will initialize a new queue hence the tests executed twice. To solve this problem you should set `KNAPSACK_PRO_FIXED_QUEUE_SPLIT=true`.
 Please [read this](#knapsack_pro_fixed_queue_split-remember-queue-split-on-retry-ci-node).
 
+### How to set `before(:suite)` and `after(:suite)` RSpec hooks in Queue Mode (Percy.io example)?
+
+Some tools like [Percy.io](https://percy.io/docs/clients/ruby/capybara-rails) requires to set hooks for RSpec `before(:suite)` and `after(:suite)`.
+Knapsack Pro Queue Mode runs subset of test files from the work queue many times. This means the RSpec hooks `before(:suite)` and `after(:suite)` will execute multiple times. If you want to run some code only once before Queue Mode starts work and after it finishes then you should do it this way:
+
+```ruby
+# spec_helper.rb or rails_helper.rb
+
+# executes before Queue Mode starts work
+Percy::Capybara.initialize_build
+
+# executes after Queue Mode finishes work
+at_exit { Percy::Capybara.finalize_build }
+```
+
+### How to call `before(:suite)` and `after(:suite)` RSpec hooks only once in Queue Mode?
+
+Knapsack Pro Queue Mode runs subset of test files from the work queue many times. This means the RSpec hooks `before(:suite)` and `after(:suite)` will be executed multiple times. If you want to run some code only once before Queue Mode starts work and after it finishes then you should do it this way:
+
+```ruby
+# spec_helper.rb or rails_helper.rb
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    unless ENV['KNAPSACK_PRO_RSPEC_BEFORE_SUITE_LOADED']
+      ENV['KNAPSACK_PRO_RSPEC_BEFORE_SUITE_LOADED'] = 'true'
+
+      # this will be called only once before the tests started on the CI node
+    end
+  end
+
+  at_exit do
+    # this will be called only once at the end when the CI node finished tests
+  end
+end
+```
+
+### How to fix capybara-screenshot fail with `SystemStackError: stack level too deep` when using Queue Mode for RSpec?
+
+Please use fixed version of capybara-screenshot.
+
+```
+# Gemfile
+group :test do
+  gem 'capybara-screenshot', github: 'ArturT/capybara-screenshot', branch: 'fix-reporter_module-loaded-twice'
+end
+```
+
+Here is [fix PR](https://github.com/mattheworiordan/capybara-screenshot/pull/205) to official capybara-screenshot repository and the explanation of the problem.
+
+### How to run knapsack_pro with parallel_tests gem?
+
+You can run knapsack_pro with [parallel_tests](https://github.com/grosser/parallel_tests) gem to run multiple concurrent knapsack_pro commands per CI node.
+
+Let's consider this example. We have 2 CI node. On each CI node we want to run 2 concurrent knapsack_pro commands by parallel_tests gem (`PARALLEL_TESTS_CONCURRENCY=2`).
+This means we would have 4 parallel knapack_pro commands in total across all CI nodes. So from knapsack_pro perspective you will have 4 nodes in total.
+
+Create in your project directory an executable file `bin/parallel_tests`:
+
+```
+#!/bin/bash
+# This file should be in bin/parallel_tests
+
+# updates CI node total based on parallel_tests concurrency
+KNAPSACK_PRO_CI_NODE_TOTAL=$(( $PARALLEL_TESTS_CONCURRENCY * $KNAPSACK_PRO_CI_NODE_TOTAL ))
+
+if [ "$TEST_ENV_NUMBER" == "" ]; then
+  PARALLEL_TESTS_CONCURRENCY_INDEX=0
+else
+  PARALLEL_TESTS_CONCURRENCY_INDEX=$(( $TEST_ENV_NUMBER - 1 ))
+fi
+
+KNAPSACK_PRO_CI_NODE_INDEX=$(( $PARALLEL_TESTS_CONCURRENCY_INDEX + ($PARALLEL_TESTS_CONCURRENCY * $KNAPSACK_PRO_CI_NODE_INDEX) ))
+
+# logs info about ENVs to ensure everything works
+echo KNAPSACK_PRO_CI_NODE_TOTAL=$KNAPSACK_PRO_CI_NODE_TOTAL KNAPSACK_PRO_CI_NODE_INDEX=$KNAPSACK_PRO_CI_NODE_INDEX PARALLEL_TESTS_CONCURRENCY=$PARALLEL_TESTS_CONCURRENCY
+
+# you can customize your knapsack_pro command here to use regular or queue mode
+bundle exec rake knapsack_pro:queue:rspec
+```
+
+Now you need to set parallel_tests command per CI node:
+
+* CI node 0 (first CI node):
+
+    ```
+    export PARALLEL_TESTS_CONCURRENCY=2; # this must be export
+    KNAPSACK_PRO_TEST_SUITE_TOKEN_RSPEC=xxx \
+    KNAPSACK_PRO_CI_NODE_TOTAL=$YOUR_CI_NODE_TOTAL \
+    KNAPSACK_PRO_CI_NODE_INDEX=$YOUR_CI_NODE_INDEX \
+    bundle exec parallel_test -n $PARALLEL_TESTS_CONCURRENCY -e './bin/parallel_tests'
+    ```
+
+* CI node 1 (second CI node):
+
+    ```
+    export PARALLEL_TESTS_CONCURRENCY=2; # this must be export
+    KNAPSACK_PRO_TEST_SUITE_TOKEN_RSPEC=xxx \
+    KNAPSACK_PRO_CI_NODE_TOTAL=$YOUR_CI_NODE_TOTAL \
+    KNAPSACK_PRO_CI_NODE_INDEX=$YOUR_CI_NODE_INDEX \
+    bundle exec parallel_test -n $PARALLEL_TESTS_CONCURRENCY -e './bin/parallel_tests'
+    ```
+
+Please note you need to update `$YOUR_CI_NODE_TOTAL` and `$YOUR_CI_NODE_INDEX` to the ENVs provided by your CI provider. For instance in case of CircleCI it would be `$CIRCLE_NODE_TOTAL` and `$CIRCLE_NODE_INDEX`. Below is an example for CircleCI configuration:
+
+```
+# circle.yml for CircleCI 1.0
+# KNAPSACK_PRO_TEST_SUITE_TOKEN_RSPEC=xxx can be set in CircleCI ENV settings
+test:
+  override:
+    - export PARALLEL_TESTS_CONCURRENCY=2; KNAPSACK_PRO_CI_NODE_TOTAL=$CIRCLE_NODE_TOTAL KNAPSACK_PRO_CI_NODE_INDEX=$CIRCLE_NODE_INDEX bundle exec parallel_test -n $PARALLEL_TESTS_CONCURRENCY -e './bin/parallel_tests':
+        parallel: true # Caution: there are 8 spaces indentation!
+```
+
+In summary, the `bin/parallel_tests` script will calculate a new values for `KNAPSAKC_PRO_*` environment variables and then run knapsack_pro command with them.
+To ensure everything works you can check output for each CI node.
+
+* Expected output for CI node 0 (first CI node):
+
+    ```
+    KNAPSACK_PRO_CI_NODE_TOTAL=4 KNAPSACK_PRO_CI_NODE_INDEX=1 PARALLEL_TESTS_CONCURRENCY=2
+    KNAPSACK_PRO_CI_NODE_TOTAL=4 KNAPSACK_PRO_CI_NODE_INDEX=0 PARALLEL_TESTS_CONCURRENCY=2
+    (tests output here)
+    ```
+
+* Expected output for CI node 1 (second CI node):
+
+    ```
+    KNAPSACK_PRO_CI_NODE_TOTAL=4 KNAPSACK_PRO_CI_NODE_INDEX=2 PARALLEL_TESTS_CONCURRENCY=2
+    KNAPSACK_PRO_CI_NODE_TOTAL=4 KNAPSACK_PRO_CI_NODE_INDEX=3 PARALLEL_TESTS_CONCURRENCY=2
+    (tests output here)
+    ```
+
 ## Gem tests
 
 ### Spec

data/lib/knapsack_pro.rb

@@ -89,11 +89,5 @@ module KnapsackPro
       task_loader = KnapsackPro::TaskLoader.new
       task_loader.load_tasks
     end
-
-    private
-
-    def set_progname(logger)
-      logger.progname = '[knapsack_pro]' if logger
-    end
   end
 end

data/lib/knapsack_pro/adapters/base_adapter.rb

@@ -12,13 +12,13 @@ module KnapsackPro
 
       def bind
         if KnapsackPro::Config::Env.recording_enabled?
-          KnapsackPro.logger.info('Test suite time execution recording enabled.')
+          KnapsackPro.logger.debug('Test suite time execution recording enabled.')
           bind_time_tracker
           bind_save_report
         end
 
         if KnapsackPro::Config::Env.queue_recording_enabled?
-          KnapsackPro.logger.info('Test suite time execution queue recording enabled.')
+          KnapsackPro.logger.debug('Test suite time execution queue recording enabled.')
           bind_time_tracker
           bind_save_queue_report
         end

data/lib/knapsack_pro/adapters/cucumber_adapter.rb

@@ -37,7 +37,7 @@ module KnapsackPro
         end
 
         ::Kernel.at_exit do
-          KnapsackPro.logger.info(KnapsackPro::Presenter.global_time)
+          KnapsackPro.logger.debug(KnapsackPro::Presenter.global_time)
         end
       end
 

data/lib/knapsack_pro/adapters/minitest_adapter.rb

@@ -39,7 +39,7 @@ module KnapsackPro
         ::Minitest::Test.send(:include, BindTimeTrackerMinitestPlugin)
 
         add_post_run_callback do
-          KnapsackPro.logger.info(KnapsackPro::Presenter.global_time)
+          KnapsackPro.logger.debug(KnapsackPro::Presenter.global_time)
         end
       end
 

data/lib/knapsack_pro/adapters/rspec_adapter.rb

@@ -37,7 +37,7 @@ module KnapsackPro
           end
 
           config.after(:suite) do
-            KnapsackPro.logger.info(KnapsackPro::Presenter.global_time)
+            KnapsackPro.logger.debug(KnapsackPro::Presenter.global_time)
           end
         end
       end

data/lib/knapsack_pro/adapters/spinach_adapter.rb

@@ -18,7 +18,7 @@ module KnapsackPro
         end
 
         ::Spinach.hooks.after_run do
-          KnapsackPro.logger.info(KnapsackPro::Presenter.global_time)
+          KnapsackPro.logger.debug(KnapsackPro::Presenter.global_time)
         end
       end
 

data/lib/knapsack_pro/client/connection.rb

@@ -90,13 +90,13 @@ module KnapsackPro
 
         request_uuid = http_response.header['X-Request-Id']
 
-        logger.info("API request UUID: #{request_uuid}")
-        logger.info("Test suite split seed: #{seed}") if has_seed?
-        logger.info('API response:')
+        logger.debug("API request UUID: #{request_uuid}")
+        logger.debug("Test suite split seed: #{seed}") if has_seed?
+        logger.debug('API response:')
         if errors?
           logger.error(response)
         else
-          logger.info(response)
+          logger.debug(response)
         end
 
         response

data/lib/knapsack_pro/config/env.rb

@@ -148,10 +148,12 @@ module KnapsackPro
 
         def log_level
           {
-            'debug' => ::Logger::DEBUG,
-            'info'  => ::Logger::INFO,
+            'fatal'  => ::Logger::FATAL,
+            'error'  => ::Logger::ERROR,
             'warn'  => ::Logger::WARN,
-          }[ENV['KNAPSACK_PRO_LOG_LEVEL']] || ::Logger::INFO
+            'info'  => ::Logger::INFO,
+            'debug' => ::Logger::DEBUG,
+          }[ENV['KNAPSACK_PRO_LOG_LEVEL'].to_s.downcase] || ::Logger::DEBUG
         end
 
         private

data/lib/knapsack_pro/report.rb

@@ -56,7 +56,7 @@ module KnapsackPro
       response = connection.call
       if connection.success?
         raise ArgumentError.new(response) if connection.errors?
-        KnapsackPro.logger.info('Saved time execution report on API server.')
+        KnapsackPro.logger.debug('Saved time execution report on API server.')
       end
     end
 

data/lib/knapsack_pro/version.rb

@@ -1,3 +1,3 @@
 module KnapsackPro
-  VERSION = '0.30.0'
+  VERSION = '0.31.0'
 end

data/spec/knapsack_pro/adapters/base_adapter_spec.rb

@@ -38,7 +38,7 @@ describe KnapsackPro::Adapters::BaseAdapter do
       it do
         logger = instance_double(Logger)
         expect(KnapsackPro).to receive(:logger).and_return(logger)
-        expect(logger).to receive(:info).with('Test suite time execution recording enabled.')
+        expect(logger).to receive(:debug).with('Test suite time execution recording enabled.')
       end
       it { expect(subject).to receive(:bind_time_tracker) }
       it { expect(subject).to receive(:bind_save_report) }
@@ -55,7 +55,7 @@ describe KnapsackPro::Adapters::BaseAdapter do
       it do
         logger = instance_double(Logger)
         expect(KnapsackPro).to receive(:logger).and_return(logger)
-        expect(logger).to receive(:info).with('Test suite time execution queue recording enabled.')
+        expect(logger).to receive(:debug).with('Test suite time execution queue recording enabled.')
       end
       it { expect(subject).to receive(:bind_time_tracker) }
       it { expect(subject).to receive(:bind_save_queue_report) }

data/spec/knapsack_pro/adapters/cucumber_adapter_spec.rb

@@ -91,7 +91,7 @@ describe KnapsackPro::Adapters::CucumberAdapter do
           expect(::Kernel).to receive(:at_exit).and_yield
           expect(KnapsackPro::Presenter).to receive(:global_time).and_return(global_time)
           expect(KnapsackPro).to receive(:logger).and_return(logger)
-          expect(logger).to receive(:info).with(global_time)
+          expect(logger).to receive(:debug).with(global_time)
 
           subject.bind_time_tracker
         end
@@ -114,7 +114,7 @@ describe KnapsackPro::Adapters::CucumberAdapter do
           expect(::Kernel).to receive(:at_exit).and_yield
           expect(KnapsackPro::Presenter).to receive(:global_time).and_return(global_time)
           expect(KnapsackPro).to receive(:logger).and_return(logger)
-          expect(logger).to receive(:info).with(global_time)
+          expect(logger).to receive(:debug).with(global_time)
 
           subject.bind_time_tracker
         end

data/spec/knapsack_pro/adapters/minitest_adapter_spec.rb

@@ -95,7 +95,7 @@ describe KnapsackPro::Adapters::MinitestAdapter do
 
         expect(KnapsackPro::Presenter).to receive(:global_time).and_return(global_time)
         expect(KnapsackPro).to receive(:logger).and_return(logger)
-        expect(logger).to receive(:info).with(global_time)
+        expect(logger).to receive(:debug).with(global_time)
 
         subject.bind_time_tracker
       end

data/spec/knapsack_pro/adapters/rspec_adapter_spec.rb

@@ -96,7 +96,7 @@ describe KnapsackPro::Adapters::RSpecAdapter do
 
         expect(KnapsackPro::Presenter).to receive(:global_time).and_return(global_time)
         expect(KnapsackPro).to receive(:logger).and_return(logger)
-        expect(logger).to receive(:info).with(global_time)
+        expect(logger).to receive(:debug).with(global_time)
 
         subject.bind_time_tracker
       end

data/spec/knapsack_pro/adapters/spinach_adapter_spec.rb

@@ -42,7 +42,7 @@ describe KnapsackPro::Adapters::SpinachAdapter do
         expect(Spinach.hooks).to receive(:after_run).and_yield
         expect(KnapsackPro::Presenter).to receive(:global_time).and_return(global_time)
         expect(KnapsackPro).to receive(:logger).and_return(logger)
-        expect(logger).to receive(:info).with(global_time)
+        expect(logger).to receive(:debug).with(global_time)
 
         subject.bind_time_tracker
       end

data/spec/knapsack_pro/client/connection_spec.rb

@@ -52,8 +52,8 @@ describe KnapsackPro::Client::Connection do
 
         before do
           expect(KnapsackPro).to receive(:logger).exactly(3).and_return(logger)
-          expect(logger).to receive(:info).with('API request UUID: fake-uuid')
-          expect(logger).to receive(:info).with('API response:')
+          expect(logger).to receive(:debug).with('API request UUID: fake-uuid')
+          expect(logger).to receive(:debug).with('API response:')
         end
 
         it do
@@ -72,15 +72,15 @@ describe KnapsackPro::Client::Connection do
 
         before do
           expect(KnapsackPro).to receive(:logger).exactly(4).and_return(logger)
-          expect(logger).to receive(:info).with('API request UUID: fake-uuid')
-          expect(logger).to receive(:info).with("Test suite split seed: seed-uuid")
-          expect(logger).to receive(:info).with('API response:')
+          expect(logger).to receive(:debug).with('API request UUID: fake-uuid')
+          expect(logger).to receive(:debug).with("Test suite split seed: seed-uuid")
+          expect(logger).to receive(:debug).with('API response:')
         end
 
         it do
           parsed_response = { 'build_distribution_id' => 'seed-uuid' }
 
-          expect(logger).to receive(:info).with(parsed_response)
+          expect(logger).to receive(:debug).with(parsed_response)
 
           expect(subject).to eq(parsed_response)
           expect(connection.success?).to be true
@@ -93,12 +93,12 @@ describe KnapsackPro::Client::Connection do
 
         before do
           expect(KnapsackPro).to receive(:logger).exactly(3).and_return(logger)
-          expect(logger).to receive(:info).with('API request UUID: fake-uuid')
-          expect(logger).to receive(:info).with('API response:')
+          expect(logger).to receive(:debug).with('API request UUID: fake-uuid')
+          expect(logger).to receive(:debug).with('API response:')
         end
 
         it do
-          expect(logger).to receive(:info).with('')
+          expect(logger).to receive(:debug).with('')
 
           expect(subject).to eq('')
           expect(connection.success?).to be true

data/spec/knapsack_pro/config/env_spec.rb

@@ -551,14 +551,38 @@ describe KnapsackPro::Config::Env do
   describe '.log_level' do
     subject { described_class.log_level }
 
-    context 'when ENV exists' do
-      let(:log_level) { 'debug' }
+    context 'when ENV set to fatal' do
+      let(:log_level) { 'fatal' }
       before { stub_const('ENV', { 'KNAPSACK_PRO_LOG_LEVEL' => log_level }) }
-      it { should eql ::Logger::DEBUG }
+      it { should eql ::Logger::FATAL }
     end
 
-    context "when ENV doesn't exist" do
+    context 'when ENV set to error' do
+      let(:log_level) { 'error' }
+      before { stub_const('ENV', { 'KNAPSACK_PRO_LOG_LEVEL' => log_level }) }
+      it { should eql ::Logger::ERROR }
+    end
+
+    context 'when ENV set to warn' do
+      let(:log_level) { 'warn' }
+      before { stub_const('ENV', { 'KNAPSACK_PRO_LOG_LEVEL' => log_level }) }
+      it { should eql ::Logger::WARN }
+    end
+
+    context 'when ENV set to info' do
+      let(:log_level) { 'info' }
+      before { stub_const('ENV', { 'KNAPSACK_PRO_LOG_LEVEL' => log_level }) }
       it { should eql ::Logger::INFO }
     end
+
+    context 'when ENV set with capital letters' do
+      let(:log_level) { 'WARN' }
+      before { stub_const('ENV', { 'KNAPSACK_PRO_LOG_LEVEL' => log_level }) }
+      it { should eql ::Logger::WARN }
+    end
+
+    context "when ENV doesn't exist" do
+      it { should eql ::Logger::DEBUG }
+    end
   end
 end

data/spec/knapsack_pro/report_spec.rb

@@ -130,7 +130,7 @@ describe KnapsackPro::Report do
           it do
             logger = instance_double(Logger)
             expect(KnapsackPro).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:info).with('Saved time execution report on API server.')
+            expect(logger).to receive(:debug).with('Saved time execution report on API server.')
             subject
           end
         end

data/spec/knapsack_pro_spec.rb

@@ -18,7 +18,7 @@ describe KnapsackPro do
 
       before do
         expect(Logger).to receive(:new).with(STDOUT).and_return(logger)
-        expect(logger).to receive(:level=).with(Logger::INFO)
+        expect(logger).to receive(:level=).with(Logger::DEBUG)
         expect(KnapsackPro::LoggerWrapper).to receive(:new).with(logger).and_return(logger_wrapper)
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knapsack_pro
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - ArturT
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-24 00:00:00.000000000 Z
+date: 2017-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -363,7 +363,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Knapsack Pro splits tests across CI nodes and makes sure that tests will