scenariotest 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 The Plant Co.,LTD
+
+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.markdown

@@ -0,0 +1,97 @@
+Why
+=====
+
+I think Test Case are made up with these:
+
+1. Certain state (snapshot) of a whole database
+1. Code to read or change the state of the the database
+1. Assertions for the change of database state or generated http response
+
+The current way of change the state of database are loading yaml files (Rails Fixture) or every time create objects by ActiveRecord or FactoryGirl. when you create a lots of records, it tends to be slow.
+
+So why not use the fastest native `mysqldump` and `mysql` to load the snapshot of database for each test case.
+
+
+How to use
+==========
+1. Create a ruby file like `scenarios.rb` under your test directory:
+
+``` ruby
+S.define :dalian do
+  S[:dalian] = City.create!(:name => "Dalian")
+end
+
+S.define :cafes, :req => :dalian do
+  S[:starbucks] = Store.create!(:name => "Starbucks", :city => S[:dalian])
+  S[:metoo] = Store.create!(:name => "Metoo", :city => S[:dalian])
+end
+
+S.define :drinks do
+  S[:orange_juice] = Cafe::Drink.create!(:name => "Orange Juice", :color => 1)
+  S[:latte] = Cafe::Drink.create!(:name => "Latte", :color => 9)
+end
+
+S.define :starbucks_with_drinks, :req => [:cafes, :drinks] do
+  S[:starbucks].drinks << S[:orange_juice]
+  S[:starbucks].drinks << S[:latte]
+end
+```
+Which you can define groups of objects as scenario, can depend on other scenario you defined. So that you can use in your test case setup block.
+
+
+1. And in your test_helper.rb:
+
+``` ruby
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+S = Scenariotest::Scenario.init
+require 'scenarios'
+```
+
+1. Then in your test file:
+
+You can use the objects created for you freely
+
+``` ruby
+require 'test_helper'
+
+class Cafe::DrinkTest < ActiveSupport::TestCase
+  setup do
+    S.setup(:cafes, :drinks)
+  end
+
+  test "have both cafes and drinks" do
+    assert S[:starbucks]
+    assert S[:latte]
+  end
+
+  test "has many drinks" do
+    S.setup(:starbucks_with_drinks)
+    assert_equal(2, S[:starbucks].drinks.size, S[:starbucks].drinks.count)
+    assert_equal(2, Store.count, Store.count)
+  end
+
+end
+```
+
+
+How it works
+============
+
+First time you call `S.setup(:starbucks_with_drinks)` it will do:
+
+1. empty the whole database
+1. invoke the blocks and create data from the blocks you defined and store the objects you created to `S[]`
+1. dump the database data (not schema) to tmp/scenariotest_fixtures/
+1. dump the loaded objects ids to tmp/scenariotest_fixtures/
+
+Next time you run tests and call `S.setup(:starbucks_with_drinks)` it will do:
+
+1. load the dump database data
+1. load the objects into `S[]`
+
+
+
+

data/Rakefile

@@ -0,0 +1,142 @@
+require 'rubygems'
+require 'rake'
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  system("cd test/dummy && rake")
+end
+
+desc "Generate RCov test coverage and open in your browser"
+task :coverage do
+  require 'rcov'
+  sh "rm -fr coverage"
+  sh "rcov test/test_*.rb"
+  sh "open coverage/index.html"
+end
+
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+#############################################################################
+#
+# Custom tasks (add your own tasks here)
+#
+#############################################################################
+
+
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/#{name}-#{version}.gem"
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec => :validate do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    reject { |file| file =~ /^(test)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end
+
+desc "Validate #{gemspec_file}"
+task :validate do
+  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  unless libfiles.empty?
+    puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
+    exit!
+  end
+  unless Dir['VERSION*'].empty?
+    puts "A `VERSION` file at root level violates Gem best practices."
+    exit!
+  end
+end

data/lib/scenariotest/driver.rb

@@ -0,0 +1,207 @@
+require "active_record"
+module Scenariotest
+  class Driver
+
+    def self.start(app)
+      new(app).start
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def find_cmd(*commands)
+      dirs_on_path = ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
+      commands += commands.map{|cmd| "#{cmd}.exe"} if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+
+      full_path_command = nil
+      found = commands.detect do |cmd|
+        dir = dirs_on_path.detect do |path|
+          full_path_command = File.join(path, cmd)
+          File.executable? full_path_command
+        end
+      end
+      found ? full_path_command : abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
+    end
+
+    def config
+      @config ||= begin
+        database_config = @app.config.database_configuration
+        unless c = database_config[Rails.env]
+          abort "No database is configured for the environment '#{Rails.env}'"
+        end
+        c
+      end
+    end
+
+    def run(type, file, options={})
+      cmd = case config["adapter"]
+      when /^mysql/
+        args = {
+          'host'      => '--host',
+          'port'      => '--port',
+          'socket'    => '--socket',
+          'username'  => '--user',
+          'encoding'  => '--default-character-set',
+          'password'  => '--password'
+        }.map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }.compact
+
+        args << (options.map do |name, value|
+          if value.blank?
+            " #{name}"
+          else
+            " #{name}=#{value}"
+          end
+        end).join("")
+
+        args << config['database']
+
+        commands, direct = if type == 'dump'
+          [['mysqldump', 'mysqldump5'], ">>"]
+        else
+          [['mysql', 'mysql5'], "<"]
+        end
+        [find_cmd(*commands), args.join(" "), direct, file].join(" ")
+
+      when "postgresql", "postgres"
+        ENV['PGUSER']     = config["username"] if config["username"]
+        ENV['PGHOST']     = config["host"] if config["host"]
+        ENV['PGPORT']     = config["port"].to_s if config["port"]
+        ENV['PGPASSWORD'] = config["password"].to_s if config["password"]
+
+        commands, direct = if type == 'dump'
+          [['psqldump'], ">>"]
+        else
+          [['psql'], "<"]
+        end
+
+        [find_cmd(*commands), config["database"], direct, file].join(" ")
+      end
+
+      Rails.logger.debug("  Scenariotest: #{cmd}")
+      raise "failed running #{cmd}" unless system(cmd)
+      true
+    end
+
+    def dump_file(name, source_sha1, type = "sql")
+      f = "#{@app.root}/tmp/scenariotest_fixtures/#{name}_#{source_sha1}.#{type}"
+      FileUtils.mkdir_p(File.dirname(f)) unless File.exist?(File.dirname(f))
+      f
+    end
+
+    class << self
+      def instance
+        @instance ||= new(Rails.application)
+      end
+    end
+
+    def setup(senario_klass, method_names)
+      definations = senario_klass.definations
+
+      method_name = if method_names.length > 1
+        sha1s = method_names.map{|name| definations[name].nil? ? senario_klass.not_defined!(name) : definations[name].sha1}
+        collection_sha1 = if sha1s.uniq.size == 1
+          sha1s[0]
+        else
+          Digest::SHA1.hexdigest(sha1s.join("\n"))
+        end
+        m = "__#{method_names.join("_")}".to_sym
+        senario_klass.define(m, :req => method_names, :source_sha1 => collection_sha1) {} unless definations[m]
+        m
+      else
+        method_names[0]
+      end
+
+      ActiveSupport::Notifications.instrument('setup.scenariotest', :name => "%s" % [method_name]) do
+        Rails.logger.info("\n\n* Scenariotest Setup Started: #{method_name}")
+        senario_klass.invoke(method_name)
+      end
+    end
+
+
+    def empty_data(source_sha1)
+      f = dump_file("empty_data", source_sha1, "sql")
+      unless File.exist?(f)
+        truncate_sql = ActiveRecord::Base.connection.tables.map{|t| "TRUNCATE `#{t}`;"}.join("\n")
+        File.open(f, "w"){|fh| fh.write("-- clear data\n" << truncate_sql)}
+        # run("dump", f, "--no-data" => nil, "--ignore-table"=>"#{config['database']}.schema_migration")
+      end
+      run("load", f)
+    end
+
+    def can_load?(name, source_sha1)
+      f = dump_file(name, source_sha1, "sql")
+      return false unless File.exist?(f)
+      yml_file = dump_file(name, source_sha1, "objects.yml")
+      return false unless File.exist?(yml_file)
+      true
+    end
+
+    def load(name, source_sha1)
+      f = dump_file(name, source_sha1, "sql")
+      return false unless File.exist?(f)
+      yml_file = dump_file(name, source_sha1, "objects.yml")
+      return false unless File.exist?(yml_file)
+
+      ActiveSupport::Notifications.instrument('load.scenariotest', :name => "%s (%s)" % [name, source_sha1]) do
+
+      run("load", f)
+
+      objs = YAML.load_file(yml_file)
+
+      klass_ids_map = {}
+      objs.each do |name, obj|
+        (if !obj[0].is_a?(Array)
+          [obj]
+        else
+          obj
+        end).each{|klass, id| (klass_ids_map[klass] ||= []) << id}
+      end
+
+      objs_identity_map = {}
+      klass_ids_map.each do |klass, ids|
+        klass.constantize.find(ids).each do |obj|
+          objs_identity_map["#{klass}_#{obj.id}"] = obj
+        end
+      end
+
+
+      objs.each do |name, obj|
+        loaded_obj = if obj[0].is_a?(Array)
+          obj.map{|klass, id| objs_identity_map["#{klass}_#{id}"]}
+        else
+          objs_identity_map["#{obj[0]}_#{obj[1]}"]
+        end
+        Scenariotest::Scenario[name] = loaded_obj
+      end
+
+      end
+      true
+    end
+
+    def dump(name, source_sha1, changed_data, truncate = true)
+      ActiveSupport::Notifications.instrument('dump.scenariotest', :name => "%s (%s)" % [name, source_sha1]) do
+
+      File.open(dump_file(name, source_sha1, "objects.yml"), 'wb') do |f|
+        YAML.dump(changed_data, f)
+      end
+
+      if truncate
+        File.open(dump_file(name, source_sha1, "sql"), 'wb') do |f|
+          truncate_sql = ActiveRecord::Base.connection.tables.map{|t| "TRUNCATE `#{t}`;"}.join("\n")
+          f.write("-- clear data start\n" << truncate_sql << "\n-- clear data end\n\n")
+        end
+      end
+
+      run("dump", dump_file(name, source_sha1, "sql"),
+        "--no-create-info" => nil,
+        "--skip-add-locks" => nil,
+        "--skip-triggers" => nil)
+
+      end
+    end
+
+  end
+end
+
+

data/lib/scenariotest/log_subscriber.rb

@@ -0,0 +1,24 @@
+module Scenariotest
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def load(event)
+      name = event.payload[:name]
+      info "  " << color("Scenariotest Loaded (%.1fms) %s" % [event.duration, name], GREEN, false).to_s
+    end
+
+    def dump(event)
+      name = event.payload[:name]
+      info "  " << color("Scenariotest Dumped (%.1fms) %s" % [event.duration, name], YELLOW, false).to_s
+    end
+
+    def setup(event)
+      name = event.payload[:name]
+      info "  " << color("Scenariotest Setup Finished (%.1fms) %s" % [event.duration, name], MAGENTA, true).to_s << "\n\n"
+    end
+
+    def logger
+      ActiveRecord::Base.logger
+    end
+  end
+end
+
+Scenariotest::LogSubscriber.attach_to :scenariotest

data/lib/scenariotest.rb

@@ -0,0 +1,170 @@
+require 'scenariotest/driver'
+require 'scenariotest/log_subscriber'
+require 'digest'
+
+module Scenariotest
+  VERSION = "0.1.0"
+  class Scenario
+    class Defination
+      attr_accessor :name, :sha1, :options, :main_blk, :after_blk, :scenario_klass
+
+      def initialize(scenario_klass, name, options, blk)
+        self.scenario_klass = scenario_klass
+        self.sha1 = options[:source_sha1]
+        self.sha1 ||= begin
+          source_path = blk.source_location[0].dup
+          Digest::SHA1.hexdigest(source_path << File.read(source_path))
+        end
+        self.name = name
+        self.options = options
+        self.main_blk = blk
+
+      end
+
+      def root?
+        self.options[:req].blank?
+      end
+
+      def root_cache_name
+        "___root_#{self.name}"
+      end
+
+      def call
+        loaded = scenario_klass.driver.load(self.name, sha1)
+
+        deps = uniq_dependencies
+
+        unless loaded
+
+          # dump all the reuseable roots
+          roots = deps.select{|d| d.root? }
+          roots.each do |dep|
+            next if scenario_klass.driver.can_load?(dep.root_cache_name, dep.sha1)
+            scenario_klass.driver.empty_data(sha1)
+            dep_changed_data = scenario_klass.changed do
+              dep.main_blk.call
+            end
+            scenario_klass.driver.dump(dep.root_cache_name, dep.sha1, dep_changed_data, false)
+          end
+
+          scenario_klass.driver.empty_data(sha1)
+          changed_data = scenario_klass.changed do
+            deps.each do |dep|
+              if dep.root? && scenario_klass.driver.load(dep.root_cache_name, dep.sha1) # only no dependencies scenarios can be cached
+                # loaded from dump
+              else
+                dep.main_blk.call
+              end
+            end
+
+            self.main_blk.call
+
+          end
+
+          scenario_klass.driver.dump(name, sha1, changed_data)
+
+        end
+
+        deps.each {|dep| dep.after_blk.call if dep.after_blk }
+        self.after_blk.call if self.after_blk
+        nil
+      end
+
+      def uniq_dependencies(list = [])
+        [self.options[:req]].flatten.compact.reverse.each do |name|
+          dep = scenario_klass.definations[name]
+          scenario_klass.not_defined!(name) if dep.nil?
+          dep.uniq_dependencies(list)
+          list << dep unless list.include?(dep)
+        end
+        list
+      end
+
+    end
+
+    class << self
+      def init
+        log("Fixtures are disabled when using Scenariotest.")
+        ActiveRecord::TestFixtures.class_eval <<-EOF
+          def setup_fixtures
+          end
+          def teardown_fixtures
+          end
+        EOF
+        @data = {}
+        @changed_data_stack = [{}]
+        self
+      end
+
+      def data
+        @data
+      end
+
+      def driver
+        @driver ||= Scenariotest::Driver.instance
+      end
+
+      def log(message)
+        Rails.logger.info(message) if const_defined?(:Rails)
+      end
+
+      def []=(name, value)
+        return if value.nil?
+        changed_data_value = if value.is_a?(Array)
+          value.map{|v| [v.class.name, v.id]}
+        else
+          [value.class.name, value.id]
+        end
+
+        @changed_data_stack[-1][name] = changed_data_value
+        @data[name] = value
+      end
+
+      def changed(&blk)
+        @changed_data_stack << {}
+        blk.call
+        changed = @changed_data_stack.pop
+        # if @changed_data_stack[-1]
+        #   @changed_data_stack[-1].update(changed)
+        # end
+        changed
+      end
+
+      def [](name)
+        @data[name]
+      end
+
+      def reload
+        load __FILE__
+      end
+
+
+      def define name, options = {}, &blk
+        definations[name] = Defination.new(self, name, options, blk)
+      end
+
+      def after name, &blk
+        not_defined!(name) unless definations[name]
+        definations[name].after_blk = blk
+      end
+
+      def setup(*names)
+        self.driver.setup(self, names)
+      end
+
+      def invoke(name)
+        (load_or_dump = definations[name]) ? load_or_dump.call : not_defined!(name)
+      end
+
+      def definations
+        (@definations ||= {})
+      end
+
+      def not_defined!(name)
+        raise("`#{name.inspect}' not defined.")
+      end
+
+    end
+  end
+
+end

data/scenariotest.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  s.platform = Gem::Platform::RUBY
+
+  s.name     = "scenariotest"
+  s.version  = "0.1.0"
+  s.date     = "2012-02-07"
+
+  s.authors = ["Felix Sun"]
+  s.email   = %q{felix@theplant.jp}
+
+  s.homepage    = %q{http://github.com/theplant/senariotest}
+  s.summary     = %q{Senario Test}
+  s.description = %q{Senario Test}
+
+  s.files         = Dir["{app,lib,public,config}/**/*"] + %w{LICENSE README.markdown}
+  s.require_path = "lib"
+
+  s.required_ruby_version = ">= 1.8.7"
+
+  s.extra_rdoc_files = ["README.markdown"]
+
+  s.test_files = s.files.select { |path| path =~ /^test\/test_.*\.rb/ }
+  # = MANIFEST =
+  s.files = %w[
+    LICENSE
+    README.markdown
+    Rakefile
+    lib/scenariotest.rb
+    lib/scenariotest/driver.rb
+    lib/scenariotest/log_subscriber.rb
+    scenariotest.gemspec
+  ]
+  # = MANIFEST =
+
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: scenariotest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Felix Sun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-07 00:00:00.000000000 Z
+dependencies: []
+description: Senario Test
+email: felix@theplant.jp
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.markdown
+files:
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/scenariotest.rb
+- lib/scenariotest/driver.rb
+- lib/scenariotest/log_subscriber.rb
+- scenariotest.gemspec
+homepage: http://github.com/theplant/senariotest
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.7
+signing_key: 
+specification_version: 2
+summary: Senario Test
+test_files: []
+has_rdoc: