mockumentary 0.2.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+gem "activesupport", ">= 2.3.5"
+gem "hashie"
+gem "faker"
+
+group :development, :test do
+  gem 'activerecord', "~> 3.1.1", :require => 'active_record'
+  gem 'sqlite3'
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+end

data/Gemfile.lock

@@ -0,0 +1,51 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.1)
+      activesupport (= 3.1.1)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.1)
+      activemodel (= 3.1.1)
+      activesupport (= 3.1.1)
+      arel (~> 2.2.1)
+      tzinfo (~> 0.3.29)
+    activesupport (3.1.1)
+      multi_json (~> 1.0)
+    arel (2.2.1)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    faker (1.0.1)
+      i18n (~> 0.4)
+    git (1.2.5)
+    hashie (1.2.0)
+    i18n (0.6.0)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    multi_json (1.0.3)
+    rake (0.9.2.2)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    sqlite3 (1.3.4)
+    tzinfo (0.3.30)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.1.1)
+  activesupport (>= 2.3.5)
+  bundler (~> 1.0.0)
+  faker
+  hashie
+  jeweler (~> 1.6.4)
+  rspec (~> 2.3.0)
+  sqlite3

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Kane Baccigalupi
+
+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.rdoc

@@ -0,0 +1,29 @@
+= mockumentary
+
+With the happy proliferation of TDD, test suites are getting massive, and developer efficiency is dwindling as we wait for our tests to pass. There is a big tradeoff between making unit test more integration-ish (and therefore more life-like) vs. making them very mocky, unity and fast. Mockumentary is a library for the
+later. It inspects the ActiveRecord universe and makes a series of AR mockeries that approximate model without hitting the database, or making any assertions. The assertions, they are still part of the developers job in testing.
+
+Mocumentary has two types of AR mock objects: 
+
+One is used within the Rails universe, a Mockery. It uses introspection to derive association and field information from its ActiveRecord class. It requires Rails or at least ActiveRecord in the test universe where it is used. These Mockeries can be dumped to YAML and used in an alternate universe of testing....
+
+The second, a Mocksimile, is a non-introspective version built from a Mockery. In fact, Mockery dumps its class descriptions to a YAML file that is loaded by Mocksimile. This static version can be used outside the Rails test universe in a suite faster than the speed of Rails environment load time.
+    
+Mocking isn't for everyone, so test-drive responsibly.
+
+
+== Contributing to mockumentary
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Write test(s) (in Rspec and in the appropriate place) that describe the bug or feature
+* Commit and push until you are happy with your contribution
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Kane Baccigalupi. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "mockumentary"
+  gem.homepage = "http://github.com/baccigalupi/mockumentary"
+  gem.license = "MIT"
+  gem.summary = %Q{An ActiveRecord mocking framework, for making your copius BDD rails tests not quite so slow}
+  gem.description = <<-TEXT 
+    With the happy proliferation of TDD, test suites are getting massive, and developer efficiency is dwindling
+    as we wait for our tests to pass. There is a big tradeoff between making unit test more integrationish (and therefore more reliable) vs.
+    making them very mocky, unity and fast. Mockumentary is a library for the later. It inspects the ActiveRecord universe and
+    makes a series of AR mockeries that approximate model without hitting the database, or making any assertions. The assertions,
+    they are still part of the developers job.
+    
+    Mocumentary has two types of AR mockeries: One is used within the Rails universe. It uses introspection to derive association
+    and field information. The second is a static copy built from the first. This static version can be used outside the Rails
+    test universe in a suite faster than the speed of Rails environment load time.
+    
+    Mocking isn't for everyone, so test-drive responsibly.
+  TEXT
+  gem.email = "baccigalupi@gmail.com"
+  gem.authors = ["Kane Baccigalupi"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:mockery) do |spec|
+  spec.pattern = FileList['spec/mockery/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:mocksimile) do |spec|
+  spec.pattern = FileList['spec/mocksimile/**/*_spec.rb']
+end
+
+desc "Run all specs"
+task :spec => [:mockery, :mocksimile]
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/mockumentary/active_record.rb

@@ -0,0 +1,23 @@
+module Mockumentary
+  module ActiveRecord
+    def mock_class
+      @mock_class ||= discover_mock_class!
+    end
+
+    def discover_mock_class!
+      Mockery.classes.detect {|c| c.ar_class == self } || Mockery.generate(self)
+    end
+
+    def mock(opts={})
+      mock_class.mock(opts)
+    end
+
+    def mock!(opts={})
+      mock_class.mock!(opts)
+    end
+
+    def mew(opts={})
+      mock_class.new(opts)
+    end
+  end
+end

data/lib/mockumentary/collection.rb

@@ -0,0 +1,45 @@
+module Mockumentary
+  class Collection < Array
+    attr_accessor :type
+  
+    def initialize(klass)
+      self.type = klass
+    end
+
+    def mock(i=1)
+      (1..i).each { self << type.mock }
+      self
+    end
+
+    def mock!(i=1)
+      (1..i).each { self << type.mock! }
+      self
+    end
+
+    def build(opts={})
+      self << type.new(opts)
+      self
+    end
+
+    def create(opts={})
+      self << type.new(opts).save
+      self
+    end
+
+    alias :create! :create
+
+    def delete(*args)
+      args.each {|e| super(e)}
+      self
+    end
+
+    alias :delete_all :clear
+    alias :destroy_all :clear
+    alias :reset :clear
+
+    def exist?(element)
+      map(&:id).include?(element.id)
+    end
+  end
+end
+

data/lib/mockumentary/data.rb

@@ -0,0 +1,63 @@
+module Mockumentary
+  module Data
+    def self.generate(key)
+      self.send(key) if key.is_a?(Symbol) && respond_to?(key) 
+    end
+
+    def self.string
+      Faker::Lorem.words.join(' ')
+    end
+
+    def self.text
+      Faker::Lorem.sentences.join(' ')
+    end
+
+    def self.integer
+      rand(100)
+    end
+
+    def self.decimal
+      rand * 100
+    end
+
+    def self.float
+      decimal
+    end
+
+    def self.time
+      Time.now + rand(60) * (3600*24)
+    end
+
+    def self.timestamp
+      time
+    end
+
+    def self.datetime
+      time
+    end
+
+    def self.date
+      Date.today + rand(60) * (3600*24)
+    end
+
+    def self.binary
+      Faker::Lorem.characters
+    end
+
+    def self.boolean
+      false
+    end
+
+    def self.first_name
+      Faker::Name.first_name
+    end
+
+    def self.last_name
+      Faker::Name.last_name
+    end
+
+    def self.full_name
+      "#{first_name} #{last_name}"
+    end
+  end
+end

data/lib/mockumentary/mockery.rb

@@ -0,0 +1,87 @@
+class Mockery < Mockumentary::Model
+  def self.ar_class
+    @ar_class ||= infer_ar_class
+  end
+
+  def self.ar_class=(klass)
+    @ar_class = klass
+    introspect if klass
+    klass
+  end
+
+  def self.container_name
+    "Mockery"
+  end
+
+  def self.infer_ar_class
+    self.to_s.gsub(/^#{container_name}/, '').constantize
+  end
+
+  def self.build(klass)
+    super
+    class_eval "#{container_name}::#{klass}.ar_class = ::#{klass}"
+  end
+
+  def self.reset_defaults
+    @relationships = nil
+    @save_defaults = nil
+    @mock_defaults = nil
+    @uid = nil
+  end
+
+  def self.introspect
+    reset_defaults
+
+    # introspect columns
+    ar_class.columns.each do |c|
+      name = c.name.to_sym
+      if save_fields.include?(name) 
+        save_defaults[name] = c.type if name != :id
+      else
+        mock_defaults[name] = c.type
+      end 
+    end
+
+    # introspect relationships
+    ar_class.reflections.each do |name, reflection|
+      attr_accessor name
+      class_name = reflection.options[:class_name] || name.to_s.classify
+      relationships[name] = lambda { Mockumentary::Collection.new(build(class_name)) } if reflection.collection?
+    end
+  end
+
+  def self.dump dir = "#{Rails.root}/config"
+    File.open("#{dir}/#{DUMP_NAME}", 'w') do |f|
+      f.write(YAML.dump(data_dump))
+    end
+  end
+
+  def self.data_dump
+    classes.inject({}) do |result, klass|
+      init = klass.init_defaults.dup
+      init.merge!(klass.overrides[:init]) if klass.overrides && klass.overrides[:init]
+      
+      save = klass.save_defaults.dup
+      save.merge!(klass.overrides[:save]) if klass.overrides && klass.overrides[:save]
+
+      mock = klass.mock_defaults.dup
+      mock.merge!(klass.overrides[:mock]) if klass.overrides && klass.overrides[:mock]
+
+      relationships = klass.relationships.inject({}) do |result, array|
+        key = array.first
+        value = array.last # a lambda 
+        relationship_type = value.call.type.to_s.gsub(/^Mockery::/, '')        
+        result[key] = relationship_type
+        result
+      end
+
+      result[klass.ar_class.to_s] = {
+        :init => init,
+        :save => save,
+        :mock => mock,
+        :relationships => relationships
+      }
+      result
+    end
+  end
+end

data/lib/mockumentary/mocksimile.rb

@@ -0,0 +1,57 @@
+class Mocksimile < Mockumentary::Model
+  def self.generate(ar_class_name, opts=nil)
+    mock_class = super(ar_class_name)
+    mock_class.defaulterize(opts) if opts
+    mock_class
+  end
+
+  def self.defaulterize(opts)
+    @init_defaults = opts[:init]
+    @mock_defaults = opts[:mock]
+    @save_defaults = opts[:save]
+    build_relationships(opts[:relationships])
+  end
+
+  def self.build_relationships(opts)
+    attr_accessor *(opts.keys)
+    @relationships = opts.inject({}) do |result, arr|
+      key = arr.first
+      klass = generate( arr.last )
+      result[key] = lambda { Mockumentary::Collection.new(klass) }
+
+      result
+    end
+  end
+
+  def self.container_name
+    "Mocksimile"
+  end
+
+  def self.load(dir=nil)
+    unless dir
+      dir = if defined?(Rails) 
+              Rails.root
+            elsif defined?(RAILS_ROOT)
+              RAILS_ROOT
+            else
+              ''
+            end
+    end
+
+    path =  "#{dir}/config/#{DUMP_NAME}"
+    unless File.exist?(path)
+      raise ArgumentError, "Could not find mockumentary.yml. Please include a path or define RAILS_ROOT"
+    end
+    config = YAML.load(File.read(path))
+    config.each{ |klass_name, options| Mocksimile.generate(klass_name, options) }
+  end
+
+  def self.release
+    if self.to_s == container_name
+      classes.map{|c| c.release }
+    else
+      release_name = self.to_s.gsub(/^#{container_name}::/, '')
+      eval "::#{release_name} = #{self} unless defined?(::#{release_name})"
+    end
+  end
+end

data/lib/mockumentary/model.rb

@@ -0,0 +1,126 @@
+module Mockumentary
+  class Model < Hashie::Mash
+    DUMP_NAME = 'mockumentary.yml'
+    
+    def self.generate(klass)
+      mock_class = constantize klass
+      build klass unless mock_class
+      mock_class ||= constantize klass
+    end
+
+    def self.init_defaults
+      @init_defaults ||= {
+        :new_record => true
+      }
+    end
+
+    def self.mock_defaults
+      @mock_defaults ||= {}
+    end
+
+    def self.save_defaults
+      @save_defaults ||= {
+        :new_record => false,
+        :id => :uid
+      }
+    end
+
+    def self.classes
+      @classes ||= []
+    end
+
+    def self.build(klass)
+      class_eval <<-RUBY
+        class #{container_name}::#{klass} < #{container_name}; end
+        classes << #{container_name}::#{klass}
+      RUBY
+    end
+
+    def self.relationships
+      @relationships ||= {}
+    end
+
+    def self.constantize(klass)
+      classes.detect{|c| c.to_s == "#{container_name}::#{klass}"}
+    end
+
+    def self.uid
+      @uid ||= 0
+      @uid += 1
+      @uid
+    end
+
+    def self.overrides
+      {}
+    end
+
+    def self.fake_data(key)
+      data = Mockumentary::Data.generate(key)
+
+      unless data
+        data  = if key == :uid
+          uid
+        elsif key.respond_to?(:call)
+          key.respond_to?(:call) 
+        else
+          key
+        end
+      end
+
+      data
+    end
+
+    def self.evaluate(opts)
+      opts.inject({}) do |result, arr|
+        result[arr.first] = fake_data(arr.last)
+        result
+      end
+    end
+
+    def self.mock_opts
+      opts = init_defaults.dup
+      opts.merge!(mock_defaults)
+      opts.merge!(overrides[:mock]) if overrides && overrides[:mock]
+      evaluate(opts)
+    end
+
+    def self.init_opts
+      opts = init_defaults.dup
+      opts.merge!(overrides[:init]) if overrides && overrides[:init]
+      evaluate(opts)
+    end
+
+    def self.save_opts
+      opts = save_defaults.dup
+      opts.merge!(overrides[:save]) if overrides && overrides[:save]
+      evaluate(opts)
+    end
+
+    def initialize(opts={})
+      super(self.class.init_opts.merge(opts))
+      self.class.relationships.each do |key, value|
+        send("#{key}=", value.call)
+      end
+    end
+
+    def self.mock(opts={})
+      new(mock_opts.merge(opts))
+    end
+
+    def self.mock!(opts={})
+      instance = mock(opts)
+      instance.save(opts)
+    end
+
+    def save(opts={})
+      self.class.save_opts.merge(opts).each do |key, value|
+        self[key] = value
+      end
+      self
+    end
+
+    def self.save_fields
+      @save_fields ||= [:id, :created_at, :updated_at]
+    end
+  end
+end

data/lib/mockumentary.rb

@@ -0,0 +1,42 @@
+Bundler.require
+
+module Mockumentary
+  def self.introspect dir = "#{Rails.root}/app/models", namespace = ''
+     Dir.chdir(dir) do 
+      Dir['*.rb'].each do |file|
+        require "#{dir}/#{file}"
+        ar_class = (namespace + file.gsub(/\.rb$/, '').classify).constantize
+        Mockery.generate(ar_class)
+      end
+
+      Dir['*'].each do |file|
+        path = "#{dir}/#{file}"
+        if File.directory?(path)
+          namespace << "::" unless namespace.empty?
+          namespace << "#{file.classify}::"
+          introspect(path, namespace)
+        end
+      end
+    end 
+  end
+
+  def self.dump dir = "#{Rails.root}/config"
+    Mockery.dump
+  end
+
+  def self.load(dir=nil)
+    Mocksimile.load(dir)
+  end
+
+  def self.load_and_release(dir=nil)
+    load(dir)
+    Mocksimile.release
+  end
+end
+
+require 'mockumentary/data'
+require 'mockumentary/collection'
+require 'mockumentary/model'
+require 'mockumentary/mockery'
+require 'mockumentary/active_record'
+require 'mockumentary/mocksimile'