hexx-rspec 0.0.1

data/lib/hexx/rspec/system.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module Hexx
+
+  module RSpec
+
+    # The utility sends multiline string to system
+    #
+    # Allows stubbing system calls in specifications.
+    #
+    # @example
+    #   System.call %(
+    #     inch --pedantic
+    #     rubocop
+    #   )
+    #
+    # @api private
+    class System < String
+
+      # Initializes multiline text to be sent to system
+      #
+      # Removes repetitive spaces from itself
+      #
+      # @param [#to_s] _
+      #   Multiline text to be sent to system
+      #
+      # @return [undefined]
+      def initialize(_)
+        super
+        strip!
+        gsub!(/ {2,}/, " ")
+      end
+
+      # Returns non-empty lines without trailing spaces
+      #
+      # @return [Array<String>]
+      def lines
+        Array(super) # Array() is needed to support rubies 1.9.3
+          .map(&:strip)
+          .reject(&:empty?)
+      end
+
+      # Sends itself to system line by line
+      #
+      # @return [self]
+      def call
+        lines.each(&method(:system))
+
+        self
+      end
+
+      # Sends multiline string to system
+      #
+      # @example (see Hexx::RSpec::System)
+      #
+      # @param  (see #initialize)
+      #
+      # @return [Hexx::RSpec::System]
+      #   utility object (allows chaining)
+      def self.call(text)
+        new(text).call
+      end
+
+    end # class System
+
+  end # module RSpec
+
+end # module Hexx

data/lib/hexx/rspec/version.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Hexx
+
+  module RSpec
+
+    # The semantic version of the module.
+    # @see http://semver.org/ Semantic versioning 2.0
+    VERSION = "0.0.1".freeze
+
+  end # module RSpec
+
+end # module Hexx

data/lib/hexx/rspec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+module Hexx
+
+  # Namespace for the module.
+  #
+  # @api public
+  module RSpec
+
+    require_relative "rspec/system"
+    require_relative "rspec/metrics"
+    require_relative "rspec/install"
+
+    class << self
+
+      # Loads coverage metric in a given scope
+      #
+      # Checks if a corresponding environment is set
+      #
+      # @example
+      #   # spec/spec_helper.rb
+      #   Hexx::RSpec.load_metrics_for(self)
+      #
+      # @param [Object] scope
+      #
+      # @return [self]
+      def load_metrics_for(scope)
+        return unless ENV["USE_SIMPLECOV"]
+        scope.instance_eval { Hexx::RSpec::Metrics::SimpleCov.run }
+      end
+
+      # Loads all the necessary rake tasks
+      #
+      # @example
+      #   Hexx::RSpec.install_tasks
+      #
+      # @return [self]
+      def install_tasks
+        load_gem_tasks
+        load_rspec_tasks
+        load_custom_tasks
+      end
+
+      private
+
+      def load_gem_tasks
+        require "bundler/gem_tasks"
+        ::Bundler::GemHelper.install_tasks
+      end
+
+      def load_rspec_tasks
+        require "rspec/core/rake_task"
+        ::RSpec::Core::RakeTask.new(:spec)
+      end
+
+      def load_custom_tasks
+        tasks = ::File.expand_path "../../tasks/**/*.rake", __FILE__
+        ::Dir[tasks].each { |task| load task }
+      end
+
+    end # singleton class RSpec
+
+  end # module RSpec
+
+end # module Hexx

data/lib/hexx-rspec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require "i18n"
+require "rake"
+require "rspec"
+require "thor"
+require "yaml"
+
+# Shared namespace for the Hexx-based gems
+module Hexx
+
+  require_relative "hexx/rspec/version"
+  require_relative "hexx/rspec"
+  require_relative "../config/initializer.rb"
+
+end # module Hexx

data/lib/tasks/test/coverage.rake

@@ -0,0 +1,29 @@
+namespace :test do
+
+  namespace :coverage do
+
+    metric = Hexx::RSpec::Metrics::SimpleCov
+    caller = Hexx::RSpec::System
+    output = -> { ENV.fetch("SIMPLECOV_OUTPUT") { "coveralls/index.html" } }
+
+    # Loads settings for simplecov from the 'config/metrics/simplecov.yml'
+    task :configure do
+      metric.load
+    end
+
+    desc "Runs tests under the coveralls"
+    task run: :configure do
+      caller.call "rake test"
+      puts "see results in #{ output.call }"
+    end
+
+    desc "Displays results of the coveralls last run"
+    task display: :configure do
+      caller.call "launchy #{ output.call }"
+    end
+  end
+
+  desc "Runs tests under the coveralls and displays the results"
+  task coverage: %w(coverage:run coverage:display)
+
+end # namespace :test

data/lib/tasks/test.rake

@@ -0,0 +1,6 @@
+caller = Hexx::RSpec::System
+
+desc "Runs a test rspec in a bundle environment, without monitoring coverage."
+task :test do
+  caller.call "bundle exec rspec spec"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+# Loads the RSpec support files.
+require "rspec"
+Dir[File.expand_path "spec/support/config/*.rb"].each { |file| require file }
+
+# encoding: utf-8
+require "coveralls"
+Coveralls.wear!
+
+# Loads the code of the module with the RSpec test rspec.
+require "hexx-rspec"

data/spec/support/config/sandbox.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+RSpec.configure do |config|
+
+  # Prepares a sandbox before corresponding spec.
+  config.before :each, :sandbox do
+    require_relative "../sandbox/helpers"
+    require_relative "../sandbox/matchers"
+    prepare_sandbox
+  end
+
+  # Clears a sandbox after corresponding spec.
+  config.after :each, :sandbox do
+    clear_sandbox
+  end
+end

data/spec/support/config/tasks.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+RSpec.configure do |config|
+
+  # Array of commands that was sent to system
+  #
+  # @return [Array<String>]
+  def commands
+    @commands ||= []
+  end
+
+  # Checks whether a task with given name has been invoked
+  #
+  # @param [String] name
+  #
+  # @return [Boolean]
+  def task_invoked?(name)
+    Rake::Task[name].instance_eval { @already_invoked }
+  end
+
+  config.before :example, :tasks do
+
+    # Resets Rake application and reinstalls all tasks to be available
+    Rake.application = nil
+    Hexx::RSpec.install_tasks
+
+    # Captures commands that System utility sends to system
+    # and stores them in {#commands} array.
+    allow_any_instance_of(Hexx::RSpec::System)
+      .to receive(:system) { |command| commands << command }
+  end
+end

data/spec/support/sandbox/helpers.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+require "yaml"
+
+# Yields block and captures stdout stream.
+#
+# @example
+#   capture_stdout { do_something }
+#
+# @return [String] The captured stream.
+def capture_stdout
+  begin
+    $stdout = StringIO.new
+    yield
+    result = $stdout.string
+  ensure
+    $stdout = STDOUT
+  end
+  result.to_s
+end
+
+# Returns the path to the temporary `spec/sandbox`.
+# @return [String] The absolute path.
+def sandbox
+  @sandbox ||= File.expand_path "../../../sandbox", __FILE__
+end
+
+# Clears the temporary `spec/sandbox`.
+def clear_sandbox
+  FileUtils.rm_rf sandbox
+end
+
+# Re-creates the temporary `spec/sandbox`.
+def prepare_sandbox
+  clear_sandbox
+  FileUtils.mkdir_p sandbox
+end
+
+# Runs code from the temporary `spec/sandbox`.
+def try_in_sandbox
+  FileUtils.cd(sandbox) { capture_stdout { yield } }
+end
+
+# Reads file in sandbox and returns file content.
+# Returns a blank string when the file is absent.
+# @return [String] The content.
+def read_in_sandbox(filename)
+  file = Dir[File.join(sandbox, filename)].first
+  file ? File.read(file) : ""
+end
+
+# Creates settings file in a sandbox
+#
+# @param [Hash] settings ({})
+#   The list of settings to be stored in 'sandbox/.metrics.yml'
+#
+# @return [undefined]
+def prepare_settings(settings, file = ".metrics.yml")
+  try_in_sandbox do
+    ::FileUtils.mkdir_p ::File.dirname(file)
+    ::File.write file, settings.to_yaml
+  end
+end

data/spec/support/sandbox/matchers.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+# Checks if a file with given name is present in sandbox.
+#
+# @example
+#   expect("some_file.rb").to be_present_in_sandbox
+RSpec::Matchers.define :be_present_in_sandbox do
+  match do |filename|
+    files = Dir[File.join(sandbox, filename)]
+    expect(files).to be_any
+  end
+end
+
+# Checks if a file with given name is absent in sandbox.
+#
+# @example
+#   expect("some_file.rb").to be_absent_in_sandbox
+RSpec::Matchers.define_negated_matcher(
+  :be_absent_in_sandbox,
+  :be_present_in_sandbox
+)

data/spec/tests/bin/install_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+describe "hexx-rspec install", :sandbox do
+
+  before { try_in_sandbox { `hexx-rspec install` } }
+
+  it "creates necessary files" do
+    %w(
+      .rspec
+      Rakefile
+      config/metrics/simplecov.yml
+    ).each { |file| expect(file).to be_present_in_sandbox }
+  end
+
+end # describe hexx-rspec install

data/spec/tests/lib/install_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+describe Hexx::RSpec::Install, :sandbox do
+
+  describe ".start" do
+
+    before { try_in_sandbox { described_class.start } }
+
+    it "creates necessary files" do
+      %w(
+        .rspec
+        Rakefile
+        config/metrics/simplecov.yml
+      ).each { |file| expect(file).to be_present_in_sandbox }
+    end
+
+    it "adds Hexx::RSpec tasks loader to Rakefile" do
+      expect(read_in_sandbox "Rakefile").to include "Hexx::RSpec.install_tasks"
+    end
+  end
+end

data/spec/tests/lib/metrics/simplecov_spec.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+require "simplecov"
+
+describe Hexx::RSpec::Metrics::SimpleCov, :sandbox do
+
+  shared_context "without simplecov.yml" do
+
+    let(:options) do
+      {
+        "output"  => "tmp/coverage",
+        "filters" => ["spec/", "config/"],
+        "groups"  => {
+          "Libraries" => "lib/",
+          "Application" => "app/"
+        }
+      }
+    end
+
+  end # shared_context
+
+  shared_context "with simplecov.yml" do
+
+    let(:options) do
+      {
+        "output"  => "custom",
+        "filters" => ["custom/"],
+        "groups"  => { "Custom" => "custom/" }
+      }
+    end
+
+    before { prepare_settings options, "config/metrics/simplecov.yml" }
+
+  end # shared_context
+
+  shared_examples "environmets setter" do
+
+    before do
+      ENV["USE_SIMPLECOV"]    = nil
+      ENV["SIMPLECOV_OUTPUT"] = nil
+    end
+
+    it "[sets USE_SIMPLECOV]" do
+      expect { subject }
+        .to change { ENV["USE_SIMPLECOV"] }
+        .to "true"
+    end
+
+    it "[sets SIMPLECOV_OUTPUT]" do
+      expect { subject }
+        .to change { ENV["SIMPLECOV_OUTPUT"] }
+        .to "#{ options['output'] }/index.html"
+    end
+
+  end # shared_examples
+
+  shared_examples "metric loader" do
+
+    after { subject }
+
+    it "starts the metric" do
+      expect(::SimpleCov).to receive(:start)
+    end
+
+  end # shared_examples
+
+  describe ".load" do
+
+    subject { try_in_sandbox { described_class.load } }
+
+    context "without simplecov.yml" do
+
+      include_context "without simplecov.yml"
+
+      it_behaves_like "environmets setter"
+    end
+
+    context "with simplecov.yml" do
+
+      include_context "with simplecov.yml"
+
+      it_behaves_like "environmets setter"
+    end
+
+  end # describe .load
+
+  describe ".run" do
+
+    subject { try_in_sandbox { described_class.run } }
+
+    context "without simplecov.yml" do
+
+      include_context "without simplecov.yml"
+
+      it_behaves_like "environmets setter"
+      it_behaves_like "metric loader"
+    end
+
+    context "with simplecov.yml" do
+
+      include_context "without simplecov.yml"
+
+      it_behaves_like "environmets setter"
+      it_behaves_like "metric loader"
+    end
+
+  end # describe .run
+
+end # describe Hexx::RSpec::Metrics::SimpleCov

data/spec/tests/lib/system_spec.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+describe Hexx::RSpec::System do
+
+  it "is a string" do
+    subject = described_class.new ""
+    expect(subject).to be_kind_of String
+  end
+
+  describe ".new" do
+
+    it "removes repetitive spaces from source" do
+      subject = described_class.new "foo   bar   \n   baz"
+
+      expect(subject).to eq "foo bar \n baz"
+    end
+
+    it "strips the source" do
+      subject = described_class.new "  foo bar \n baz  "
+
+      expect(subject).to eq "foo bar \n baz"
+    end
+
+  end # describe .new
+
+  describe "#lines" do
+
+    it "strips lines" do
+      subject = described_class.new " foo bar \n baz "
+
+      expect(subject.lines).to eq ["foo bar", "baz"]
+    end
+
+    it "ignores empty lines" do
+      subject = described_class.new " \nfoo bar\n \nbaz\n "
+
+      expect(subject.lines).to eq ["foo bar", "baz"]
+    end
+
+    it "returns an array of utilities" do
+      subject = described_class.new "foo bar\nbaz"
+
+      subject.lines.each { |line| expect(line).to be_kind_of described_class }
+    end
+
+  end # describe #lines
+
+  describe "#call" do
+
+    before { allow_any_instance_of(described_class).to receive :system }
+
+    it "returns itself (allows chaining)" do
+      subject = described_class.new "foo"
+
+      expect(subject.call).to eq subject
+    end
+
+    context "single line" do
+
+      subject { described_class.new "foo bar" }
+      after   { subject.call }
+
+      it "sends itself to system" do
+        expect(subject).to receive(:system).with(subject)
+      end
+
+    end # context
+
+    context "multiline string" do
+
+      subject { described_class.new "foo bar\nbaz" }
+      after   { subject.call }
+
+      it "sends each line to system" do
+        subject.lines.each do |line|
+          expect(subject).to receive(:system).with(line).ordered
+        end
+      end
+
+    end # context
+
+  end # describe #call
+
+  describe ".call" do
+
+    let!(:value)   { "foo bar\nbaz" }
+    let!(:utility) { described_class.new value }
+
+    before { allow(described_class).to receive(:new) { utility } }
+
+    it "constucts the utility object and calls it" do
+      expect(described_class).to receive(:new).with(value)
+      expect(utility).to receive :call
+      described_class.call value
+    end
+
+  end # describe .call
+
+end

data/spec/tests/rspec_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+describe Hexx::RSpec do
+
+  let(:coverage_settings) { described_class::Metrics::SimpleCov }
+  let(:rake_tasks)        { Rake::Task.tasks.map(&:name)        }
+
+  describe ".install_tasks" do
+
+    before { described_class.install_tasks }
+
+    it "installs Gem tasks" do
+      expect(rake_tasks).to include("build", "install", "release")
+    end
+
+    it "installs RSpec tasks" do
+      expect(rake_tasks).to include("spec")
+    end
+
+    it "installs described_class tasks" do
+      expect(rake_tasks).to include(*%w(
+        test:coverage
+        test:coverage:display
+        test:coverage:run
+        test
+      ))
+    end
+
+  end # display .insall_tasks
+
+  describe ".load_metrics_for" do
+
+    subject { described_class.load_metrics_for(double) }
+
+    context "when ENV[USE_SIMPLECOV] is set" do
+
+      before  { ENV["USE_SIMPLECOV"] = "true" }
+
+      it "initializes and runs a coverage settings" do
+        expect(coverage_settings).to receive(:run)
+        subject
+      end
+    end
+
+    context "when ENV[USE_SIMPLECOV] isn't set" do
+
+      before { ENV["USE_SIMPLECOV"] = nil }
+
+      it "doesn't run settings" do
+        expect(coverage_settings).not_to receive(:run)
+        subject
+      end
+    end
+
+  end # display .load_metrics_for
+
+end # display Hexx::RSpec

data/spec/tests/tasks/test/coverage/display_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+describe "Rake::Task['test:coverage:display']", :tasks do
+
+  # The {#commands} variable is defined in the spec/support/config/tasks.rb
+  # It collects the list of commands, that has been sent to system by
+  # any instance of Hexx::RSpec::System utility.
+
+  let(:metric) { Hexx::RSpec::Metrics::SimpleCov }
+  let(:task)   { Rake::Task["test:coverage:display"] }
+
+  describe ".invoke", :sandbox do
+
+    subject { try_in_sandbox { task.invoke } }
+
+    context "when '.metrics.yml' is absent" do
+
+      it "loads the metric" do
+        expect(metric).to receive(:load)
+        subject
+      end
+
+      it "displays the default output" do
+        expect { subject }.to change { commands }.to [
+          "launchy tmp/coverage/index.html"
+        ]
+      end
+    end
+
+    context "when '.metrics.yml' is present" do
+
+      let(:output) { "tmp/coverage" }
+      before do
+        prepare_settings "simplecov" => { "output" => output }
+      end
+
+      it "loads the metric" do
+        expect(metric).to receive(:load)
+        subject
+      end
+
+      it "uses the custom output folder" do
+        expect { subject }.to change { commands }.to [
+          "launchy #{ output }/index.html"
+        ]
+      end
+    end
+  end
+end