smokescreen 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in smokescreen.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,9 @@
+Copyright (c) 2013 LivingSocial, Inc.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,84 @@
+# Smokescreen
+
+Quickly run critical tests on your app, recently changed tests, or tests related to recent changed files
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'smokescreen'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install smokescreen
+    
+
+## Usage
+
+Setting up smokescreen is fairly easy, include the gem in your `Gemfile`, and then require it in your primary `Rakefile` or in any of your `lib/tasks/other_rakefiles`.
+
+	#in Gemfile
+    group :development, :test do
+      gem 'smokescreen'
+    end
+
+	#in a Rakefile
+    require 'smokescreen'
+    
+	#below require in rake file
+    Smokescreen.configure(:critical_tests => ["test/functional/purchases_controller_test.rb", "test/functional/important_controller_test.rb"])
+    
+After you require smokescreen make sure to configure the critical tests. Just pass in an array of tests that you want to be be considered part of the critical set of tests. 
+    
+### After configuring Smokescreen
+
+You can view all the tasks together running `bundle exec rake -T smoke`, as you can tell there are four main groupings of tests current, deploy, previous, and recent. 
+
+
+	rake test:smokescreen:critical:functionals                # Run tests for critical:functionals
+	rake test:smokescreen:current:all                         # run most important tests as well as tests for current...
+	rake test:smokescreen:current:changed                     # run tests related to currently changed files (git diff)
+	rake test:smokescreen:current:changed_tests               # run currently changed test files (git diff)
+	rake test:smokescreen:current:functionals                 # Run tests for functionals
+	rake test:smokescreen:current:functionals:changed_tests   # Run tests for functionals:changed_tests
+	rake test:smokescreen:current:units                       # Run tests for units
+	rake test:smokescreen:current:units:changed_tests         # Run tests for units:changed_tests
+	rake test:smokescreen:deploy:all                          # run most important tests as well as tests for files c...
+	rake test:smokescreen:deploy:changed                      # run tests related to files changed since last deploy
+	rake test:smokescreen:deploy:functionals                  # Run tests for functionals
+	rake test:smokescreen:deploy:units                        # Run tests for units
+	rake test:smokescreen:previous:all                        # run most important tests as well as tests for previou...
+	rake test:smokescreen:previous:changed                    # run tests related to previously changed files (last c...
+	rake test:smokescreen:previous:changed_tests              # run previously changed test files (last commit, git s...
+	rake test:smokescreen:previous:functionals                # Run tests for functionals
+	rake test:smokescreen:previous:functionals:changed_tests  # Run tests for functionals:changed_tests
+	rake test:smokescreen:previous:units                      # Run tests for units
+	rake test:smokescreen:previous:units:changed_tests        # Run tests for units:changed_tests
+	rake test:smokescreen:recent:all                          # run most important tests as well as recently effected...
+	rake test:smokescreen:recent:changed                      # run tests for currently changed files (git diff)
+	rake test:smokescreen:recent:changed_tests                # run recently changed test files (current and previous...
+	rake test:smokescreen:recent:functionals                  # Run tests for functionals
+	rake test:smokescreen:recent:functionals:changed_tests    # Run tests for functionals:changed_tests
+	rake test:smokescreen:recent:units                        # Run tests for units
+	rake test:smokescreen:recent:units:changed_tests          # Run tests for units:changed_tests
+
+
+### Running Smokescreen
+
+The most common task I run is `rake test:smokescreen:recent:all`, as it is the most comprehensive. That task runs the critical tests, test files related to currently change files (as found by git diff), and test files related to recently changed files (as found by git show). It is easy to target more specifically if you choose.
+
+I also find running `rake test:smokescreen:previous:changed_tests` or `rake test:smokescreen:previous:all` handy when doing code review on another developers cherry-picked commit. Making sure the tests don't have one of the "it works on my machine" bugs.
+
+Smokescreen has only been used on a small set of projects, and doesn't currently support anything other than `test:unit`. I know now that it is extracted out that I plan to add it to some other projects and hopefully it will be easy to make some improvements to the tool. I already know there could be some great improvements to the process of matching up likely related test files to recent changes. Adding support to run any recently failing tests from CI would also be another great feature.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/smokescreen.rb

@@ -0,0 +1,15 @@
+require "smokescreen/version"
+
+module Smokescreen
+  @@critical_tests = []
+
+  def self.configure(options = {})
+    @@critical_tests = options.fetch(:critical_tests){[]}
+    require "smokescreen/tasks"
+  end
+  
+  def self.critical_tests
+    @@critical_tests
+  end
+
+end

data/lib/smokescreen/tasks.rb

@@ -0,0 +1,286 @@
+require 'rake/testtask'
+
+namespace :test do
+  namespace :smokescreen do
+    
+    #####
+    # Rake is so weird, but to define a task all code inside the task is evaluated at definition time
+    # This has lead to splitting out the methods, so that when defined they should really do nothing,
+    # but when invoked they should run and output info.
+    #
+    # I am sure this means there is a better way to do this, but I don't know it
+    ####
+    def functionals_critical(test_changed_files, t)
+      t.libs << "test"
+      t.verbose = true
+      if !test_changed_files.empty?
+        t.test_files = test_changed_files
+      else
+        t.test_files = []
+      end
+    end
+
+    def critical_test_files
+      Smokescreen.critical_tests
+    end
+
+    desc 'runs most critical functional tests'
+    Rake::TestTask.new("critical:functionals") do |t|
+      functionals_critical(critical_test_files, t)
+    end
+
+    # this won't work until your capistrano supports fetching the currently deployed git SHA on production
+    def changed_files_since_deploy
+      if File.exists?("log/latest-REVISION-syntaxcheck")
+        revision = File.read("log/latest-REVISION-syntaxcheck").chomp
+
+        `git whatchanged #{revision}..HEAD`.split("\n").select{|l| l =~ /^\:/}.collect {|l| l.split("\t")[1]}.sort.uniq
+      else
+        puts "log/latest-REVISION-syntaxcheck not found. run 'cap fetch_currently_deployed_version' to get it"
+        []
+      end
+    end
+
+    # file changes detected by git diff
+    def currently_changed_files
+      `git status --porcelain`.split("\n").map{ |file| file.split.last }
+    end
+
+    # file changes detected by git show
+    def previously_changed_files
+      `git show --pretty="format:" --name-only`.split("\n")
+    end
+
+    # based on a list of files changes try to detect functional tests we should likely run
+    # include test files that were directly modified
+    def functionals_changed(test_changed_files, t)
+      changed_controllers = []
+      changed_functional_tests = []
+      changed_view_directories = Set.new
+      test_changed_files.each do |file|
+        controller_match = file.match(/app\/controllers\/(.*).rb/)
+        if controller_match
+          changed_controllers << controller_match[1]
+        end
+
+        view_match = file.match(/app\/views\/(.*)\/.+\.erb/)
+        if view_match
+          changed_view_directories << view_match[1]
+        end
+
+        functional_test_match = file.match(/test\/functional\/(.*).rb/)
+        if functional_test_match
+          changed_functional_tests << functional_test_match[1]
+        end
+      end
+
+      test_files = FileList['test/functional/**/*_test.rb'].select{|file| changed_controllers.any?{|controller| file.match(/test\/functional\/#{controller}_test.rb/) }} +
+        FileList['test/functional/**/*_test.rb'].select{|file| changed_view_directories.any?{|view_directory| file.match(/test\/functional\/#{view_directory}_controller_test.rb/) }} +
+        FileList['test/functional/**/*_test.rb'].select{|file|
+        (changed_functional_tests.any?{|functional_test| file.match(/test\/functional\/#{functional_test}.rb/) } ||
+         test_changed_files.any?{|changed_file| file==changed_file })
+      }
+
+      test_files = test_files.uniq
+      test_files = test_files.reject{ |f| Smokescreen.critical_tests.include?(f) }
+
+      t.libs << "test"
+      t.verbose = true
+      if !test_files.empty?
+        t.test_files = test_files
+      else
+        t.test_files = []
+      end
+    end
+
+   # run tests against any functional test file, that has been modified
+    def functionals_changed_tests(test_changed_files, t)
+      test_changed_files = test_changed_files.split("\n") if test_changed_files.is_a?(String)
+      test_files = FileList['test/functional/**/*_test.rb'].select{|file| test_changed_files.any?{|changed_file| file==changed_file }}
+      test_files = test_files.uniq
+      test_files = test_files.reject{ |f| Smokescreen.critical_tests.include?(f) }
+
+      t.libs << "test"
+      t.verbose = true
+      if !test_files.empty?
+        t.test_files = test_files
+      else
+        t.test_files = []
+      end
+    end
+
+    # based on a list of files changes try to detect unit tests we should likely run.
+    # include test files that were directly modified
+    def units_changed(test_changed_files, t)
+      changed_models = []
+      test_changed_files.each do |file|
+        matched = file.match(/app\/models\/(.*).rb/)
+        if matched
+          changed_models << matched[1]
+        end
+      end
+      test_files = FileList['test/unit/*_test.rb'].select{|file| 
+        (changed_models.any?{|model| file.match(/test\/unit\/#{model}_test.rb/) } ||
+         test_changed_files.any?{|changed_file| file==changed_file })
+      }
+      test_files = test_files.uniq
+
+      t.libs << "test"
+      t.verbose = true
+      if !test_files.empty?
+        t.test_files = test_files
+      else
+        t.test_files = []
+      end
+    end
+
+    # run tests against any unit test file, that has been modified
+    def units_changed_tests(test_changed_files, t)
+      test_changed_files = test_changed_files.split("\n") if test_changed_files.is_a?(String)
+      test_files = FileList['test/unit/*_test.rb'].select{|file| test_changed_files.any?{|changed_file| file==changed_file }}
+      test_files = test_files.uniq
+
+      t.libs << "test"
+      t.verbose = true
+      if !test_files.empty?
+        t.test_files = test_files
+      else
+        t.test_files = []
+      end
+    end
+
+    namespace :deploy do
+      desc 'run most important tests as well as tests for files changed since the last deploy'
+      task :all do
+        Rake::Task["test:smokescreen:critical:functionals"].invoke
+        Rake::Task["test:smokescreen:deploy:changed"].invoke
+      end
+      
+      desc 'run tests related to files changed since last deploy'
+      task :changed do
+        Rake::Task["test:smokescreen:deploy:functionals"].invoke
+        Rake::Task["test:smokescreen:deploy:units"].invoke
+      end
+      
+      Rake::TestTask.new("functionals") do |t|
+        functionals_changed(changed_files_since_deploy, t)
+      end
+      
+      Rake::TestTask.new("units") do |t|
+        units_changed(changed_files_since_deploy, t)
+      end
+    end
+
+    namespace :previous do
+      desc 'run most important tests as well as tests for previously changed files (last commit, git show)'
+      task :all do
+        Rake::Task["test:smokescreen:critical:functionals"].invoke
+        Rake::Task["test:smokescreen:previous:changed"].invoke
+      end
+
+      desc 'run tests related to previously changed files (last commit, git show)'
+      task :changed do
+        Rake::Task["test:smokescreen:previous:functionals"].invoke
+        Rake::Task["test:smokescreen:previous:units"].invoke
+      end
+
+      desc 'run previously changed test files (last commit, git show)'
+      task :changed_tests do
+        Rake::Task["test:smokescreen:previous:functionals:changed_tests"].invoke
+        Rake::Task["test:smokescreen:previous:units:changed_tests"].invoke
+      end
+
+      Rake::TestTask.new("functionals") do |t|
+        functionals_changed(previously_changed_files, t)
+      end
+
+      Rake::TestTask.new("functionals:changed_tests") do |t|
+        functionals_changed_tests(previously_changed_files, t)
+      end
+      
+      Rake::TestTask.new("units") do |t|
+        units_changed(previously_changed_files, t)
+      end
+      
+      Rake::TestTask.new("units:changed_tests") do |t|
+        units_changed_tests(previously_changed_files, t)
+      end
+    end
+
+    namespace :current do
+      desc 'run most important tests as well as tests for currently changed files (git diff)'
+      task :all do
+        Rake::Task["test:smokescreen:critical:functionals"].invoke
+        Rake::Task["test:smokescreen:current:changed"].invoke
+      end
+
+      desc 'run tests related to currently changed files (git diff)'
+      task :changed do
+        Rake::Task["test:smokescreen:current:functionals"].invoke
+        Rake::Task["test:smokescreen:current:units"].invoke
+      end
+
+      desc 'run currently changed test files (git diff)'
+      task :changed_tests do
+        Rake::Task["test:smokescreen:current:functionals:changed_tests"].invoke
+        Rake::Task["test:smokescreen:current:units:changed_tests"].invoke
+        puts @results
+      end
+
+      Rake::TestTask.new("functionals") do |t|
+        functionals_changed(currently_changed_files, t)
+      end
+      
+      Rake::TestTask.new("functionals:changed_tests") do |t|
+        functionals_changed_tests(currently_changed_files, t)
+      end
+      
+      Rake::TestTask.new("units") do |t|
+        units_changed(currently_changed_files, t)
+      end
+
+      Rake::TestTask.new("units:changed_tests") do |t|
+        units_changed_tests(currently_changed_files, t)
+      end
+
+    end
+
+    namespace :recent do
+      desc 'run most important tests as well as recently effected tests (git diff + git show)'
+      task :all do
+        Rake::Task["test:smokescreen:critical:functionals"].invoke
+        Rake::Task["test:smokescreen:recent:changed"].invoke
+      end
+
+      desc 'run tests for currently changed files (git diff)'
+      task :changed do
+        Rake::Task["test:smokescreen:recent:functionals"].invoke
+        Rake::Task["test:smokescreen:recent:units"].invoke
+      end
+
+      desc 'run recently changed test files (current and previous commit test files)'
+      task :changed_tests do
+        Rake::Task["test:smokescreen:recent:functionals:changed_tests"].invoke
+        Rake::Task["test:smokescreen:recent:units:changed_tests"].invoke
+      end
+
+      Rake::TestTask.new("functionals") do |t|
+        functionals_changed((previously_changed_files + currently_changed_files).uniq, t)
+      end
+      
+      Rake::TestTask.new("functionals:changed_tests") do |t|
+        functionals_changed_tests((previously_changed_files + currently_changed_files).uniq, t)
+      end
+      
+      Rake::TestTask.new("units") do |t|
+        units_changed((previously_changed_files + currently_changed_files).uniq, t)
+      end
+      
+      Rake::TestTask.new("units:changed_tests") do |t|
+        units_changed_tests((previously_changed_files + currently_changed_files).uniq, t)
+      end
+
+    end
+
+  end
+end

data/lib/smokescreen/version.rb

@@ -0,0 +1,3 @@
+module Smokescreen
+  VERSION = "0.0.1"
+end

data/smokescreen.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'smokescreen/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "smokescreen"
+  spec.version       = Smokescreen::VERSION
+  spec.authors       = ["Dan Mayer"]
+  spec.email         = ["dan.mayer@livingsocial.com"]
+  spec.description   = %q{Smokescreen is a smoke test suite that tries to run the most critical and most likely effected tests related to recent changes.}
+  spec.summary       = %q{Smokescreen the minimal final smoke tests for a project}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_dependency "rake"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: smokescreen
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Dan Mayer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-09-13 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Smokescreen is a smoke test suite that tries to run the most critical and most likely effected tests related to recent changes.
+email: 
+- dan.mayer@livingsocial.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/smokescreen.rb
+- lib/smokescreen/tasks.rb
+- lib/smokescreen/version.rb
+- smokescreen.gemspec
+has_rdoc: true
+homepage: ""
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Smokescreen the minimal final smoke tests for a project
+test_files: []
+