ddt 0.1.0

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2012 Dan Swain
+
+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,208 @@
+# DDT
+
+Data driven testing for Ruby with RSpec.  DDT kills bugs.
+
+DDT is a plugin for RSpec that makes data-driven testing easy.  It
+allows you to define a [YAML](http://www.yaml.org/) file for a
+specific method that includes test input and expected outputs.  See
+below for an example.
+
+## License
+
+DDT is released under the 
+[MIT license](http://en.wikipedia.org/wiki/MIT_License). 
+See the LICENSE file.
+
+## Requirements
+
+DDT requires RSpec because, well, it's an RSpec plugin.  In the
+future, I may make DDT more general and let the RSpec part be
+optional.  
+
+DDT should work on any Ruby.  It's only been tested on Ruby
+1.9.3 so far, though.
+
+## Installation
+
+If your system is set up to allow it, you can just do
+
+    gem install ddt
+
+Or, if you prefer a more hands-on approach or want to hack at the source:
+
+    git clone git://github.com/simplifi/ddt.git
+    cd ddt
+    rake install
+
+If you are working on a system where you need to `sudo gem install`
+you can do
+
+    rake gem 
+    sudo gem install ddt
+
+As always, you can `rake -T` to find out what other rake tasks we have
+provided.
+
+## Basic Usage
+
+Right now, `DDT::TruthTesting` that is the main workhorse of DDT.
+`DDT::TruthTesting` adds some methods to RSpec to enable a truth
+testing. `DDT::TruthTest` automates the process of creating an
+object, calling a method on it with some specified input, and checking
+the state of the object afterwords against what is expected, i.e., the
+"truth".  `DDT::TruthTest` defines a class called `Truth` for the
+class under test; the `Truth` class encapsulates the input and
+expected output.
+
+This example and the others below are taken from
+spec/truth\_test/truth\_test\_spec.rb
+
+First, include ddt in your test suite.  Probably this just means
+adding `require 'ddt'` to your spec\_helper.rb
+
+Suppose we have a classed called `Cat` that has a state called
+`disposition` and a method called `pet`:
+
+    class Cat
+      attr_accessor :disposition
+    
+      def initialize
+        @disposition = "mrow."
+      end
+    
+      # cats are temperamental.  my cat does not
+      # like to be petted on the belly, but she
+      # won't let you know until afterwords.
+      def pet how
+        predisposition = @disposition
+        if how =~ /belly/
+          @disposition = "*hiss*"
+        end
+        predisposition
+      end
+    end
+
+We can write a truth testing spec file for `Cat#pet` like this:
+
+    describe Cat do
+      truth_test :pet
+    end
+
+When we run rspec, DDT will look for a file called
+`truths/cat/pet_truths.yaml` containing YAML test cases.  Here's an
+example:
+
+    ---
+    input: "on the head"
+    output: "mrow."
+    disposition: "mrow."
+    ---
+    input: "on the belly"
+    output: "mrow."
+    disposition: "*hiss*"
+
+For each of these test cases, `DDT::TruthTest` will create a new `Cat`
+instance and call the `pet` method with "input" as the argument.  It
+then does an RSpec example that looks something like
+
+    cat.pet("on the head").should == "mrow."
+
+as well as
+
+    cat.disposition.should == "mrow."
+
+## Mapping test data
+
+`DDT::TruthTest` lets us map test data using
+`Object::define_truth`, which takes as arguments an instance of the
+object under test and a hash corresponding to the YAML test case.  As
+an example, consider the `Dog` class here:
+
+    class Dog
+      attr_accessor :name, :weight, :age
+    
+      def parse! str
+        d = str.split(",")
+        @name = d[0]
+        @weight = d[1].to_f
+        @age = d[2].to_i
+        self
+      end
+    end
+
+    # example:
+    rover = Dog.new.parse! "rover", 31.5, 5
+    rover.name   # => "rover"
+    rover.weight # => 31.5
+    rover.age    # => 5
+
+In our test data, the weight needs to be converted to a float and the
+age needs to be converted to an int, so we'll manually add some
+conversions to our truth class:
+
+    Dog::define_truth do |dog, data|
+      # make age an integer
+      dog.age = data["age"].to_i
+    
+      # make weight a float
+      dog.weight = data["weight"].to_f
+    end
+
+We can then define truths for `Dog#parse!` in
+`truths/dog/parse\!_truths.yaml` (note the `\!`):
+
+    ---
+    input: "Fido, 30.0, 3"
+    name: "Fido"
+    weight: 30.0
+    age: 3
+
+And test in RSpec:
+
+    describe Dog do
+      truth_test :parse!
+    end
+
+Note, in the `Cat` example above, `Cat::define_truth` is called
+automatically by `truth_test`.
+
+## Specifying the test instance
+
+The `Truth` class also provides a method called `Truth#tester` that
+supplies the instance to test.  By default, `Object#new` is called
+with no arguments to supply the instance.  This method can be overridden to
+specify other arguments:
+
+    class Wolf
+      attr_accessor :call
+      def initialize call
+        @call = call
+      end
+    end
+    
+    # we have to first create the truth class
+    Wolf::define_truth
+    
+    # then we can monkey patch the tester method
+    class Wolf::Truth
+      def tester
+        self.class.tester || Wolf.new("AOOOO")
+      end
+    end
+
+It's also possible to use RSpec's stubbing to do this:
+
+    Wolf::Truth.should_receive(:tester).and_return(Wolf.new "draw blood")
+
+## Contributing
+
+The usual github process applies here:
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+You can also contribute to the author's ego by letting him know that
+you find String Eater useful ;)

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rake/clean'
+
+project_name = "ddt"
+
+desc "Run rspec spec/ (compile if needed)"
+task :test do
+  sh "rspec spec/"
+end
+
+desc "Create gem"
+task :gem => "#{project_name}.gemspec" do
+  sh "gem build #{project_name}.gemspec"
+end
+
+desc "Install using 'gem install'"
+task :install => :gem do
+  sh "gem install #{project_name}"
+end

data/lib/ddt.rb

@@ -0,0 +1,17 @@
+# defines DDT::TruthTest
+require 'truth_test/truth_test'
+
+module DDT
+  autoload :VERSION, 'version/version'
+
+  # copied from ActiveSupport
+  def underscore string
+    string.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+  
+  module_function :underscore
+end

data/lib/truth_test/truth_test.rb

@@ -0,0 +1,151 @@
+require 'rspec/core'
+require 'yaml'
+
+class Object
+  def self.define_truth &block
+    DDT::TruthTest::define_truth_for self, &block
+  end
+end
+
+# @private
+module DDT
+  module TruthTest
+
+    def define_truth_for the_klass, &block
+      klass = Class.new
+
+      klass.class_eval do
+        # defined so we can override it with should_receive
+        def self.tester
+          nil
+        end
+
+        attr_accessor :input, :output
+      end
+
+      if block_given?
+        pblock = block
+      else
+        pblock = nil
+      end
+
+      # this is a bit of trickery to get at the private method
+      #  :define_method and also allow access to the_klass
+      klass.send(:define_method, :initialize) do |data={}|
+        data.each_pair do |attr, value|
+          instance_variable_set "@#{attr}", value
+          self.class.send(:attr_accessor, attr.to_sym)
+        end
+
+        instance_variable_set "@input", data["input"]
+        (instance_variable_set "@output", data["output"]) if data["output"]
+
+        if pblock
+          pblock.call(self, data)
+        end
+      end
+
+      klass.send(:define_method, :tester) do
+        self.class.send(:tester) || the_klass.new 
+      end
+
+      the_klass.const_set "Truth", klass
+
+    end
+
+    module_function :define_truth_for
+
+    class RSpec::Core::ExampleGroup
+
+      # Declare a truth test for a method of the class being described.
+      # If the class did not have define_truth called, it will be
+      # called automatically with no arguments.
+      #
+      # Example
+      #     # truths/foo/do_stuff_truths.yaml
+      #     ---
+      #     input: blah
+      #     bar: baz blah
+      #     ---
+      #     input: bam
+      #     bar: baz bam
+      #
+      #     # foo.rb
+      #     class Foo
+      #       attr_accessor :bar
+      #
+      #       def do_stuff input
+      #         @bar = "baz #{input}"
+      #       end
+      #     end
+      #
+      #     # foo_spec.rb
+      #     Foo.define_truth
+      #     
+      #     describe Foo do
+      #       truth_test :do_stuff
+      #     end
+      #
+      # opts can either be an options hash or a filename in which to find the
+      # truth data.  If opts is a hash and it includes :data as a key, the 
+      # value of opts :data is a string to be parsed as YAML.  If opts 
+      # includes the :truth_file, then that file is used for truth (same
+      # as using a string instead of a hash).
+      #
+      # If no input is specified (i.e., if opts is omitted), then truth_test will
+      # look for a yaml file called ./truths/class_name/method_truths.yaml 
+      # (class_name in snake case a la Rails).
+      def self.truth_test method, opts={}
+        unless described_class.const_defined?("Truth")
+          described_class.define_truth
+        end
+
+        if (opts.is_a? Hash) && opts[:data]
+          data = opts[:data]
+        else
+          filename = opts if opts.is_a? String
+          filename ||= (opts[:truth_file] || "./truths/#{DDT::underscore(described_class.name)}/#{method}_truths.yaml")
+          data = File.open(filename, "rb")
+        end
+
+        run_truth_test method, data
+      ensure
+        data.close if data.is_a? File
+      end
+
+      # @private
+      def self.run_truth_test method, data
+        truth_count = -1
+        YAML::load_documents(data).each do |datum|
+          truth_count += 1
+          truth = described_class::Truth.new datum
+
+          # don't use the value because we might want nil input
+          unless datum.has_key?("input")
+            puts "Skipping truth datum #{truth_count} with no input..."
+            next
+          end
+
+          if truth.output
+            it "should respond to '#{method}(#{truth.input})' with '#{truth.output}'" do
+              truth.tester.send(method, truth.input).should == truth.output
+            end
+          end
+
+          # already tested these
+          datum.delete("input")
+          datum.delete("output")
+
+          datum.each_key do |attr|
+            it "when the input is '#{truth.input}', calling '#{attr}' should return '#{truth.send(attr)}'" do
+              obj = truth.tester
+              obj.send(method, truth.input)
+              obj.send(attr).should == truth.send(attr)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/version/version.rb

@@ -0,0 +1,9 @@
+module DDT
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    PRE   = nil
+    STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift('lib/')
+
+require 'ddt'

data/spec/truth_test/truth_test_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+Dog_attrs = [:name, :weight, :age]
+
+# A class to test with
+class Dog
+  attr_accessor *Dog_attrs
+
+  def parse! str
+    d = str.split(",")
+    @name = d[0]
+    @weight = d[1].to_f
+    @age = d[2].to_i
+    self
+  end
+end
+
+Dog::define_truth do |dog, data|
+  # make age an integer
+  dog.age = data["age"].to_i
+
+  # make weight a float
+  dog.weight = data["weight"].to_f
+end
+
+# we'll automatically generate a truth class for this
+class Cat
+  attr_accessor :disposition
+
+  def initialize
+    @disposition = "mrow."
+  end
+
+  # cats are temperamental.  my cat does not
+  # like to be petted on the belly, but she
+  # won't let you know until afterwords.
+  def pet how
+    predisposition = @disposition
+    if how =~ /belly/
+      @disposition = "*hiss*"
+    end
+    predisposition
+  end
+end
+
+# a class that we'll define a specific tester for
+class Wolf
+  attr_accessor :call
+  def initialize call
+    @call = call
+  end
+end
+
+Wolf::define_truth
+
+class Wolf::Truth
+  def tester
+    self.class.tester || Wolf.new("AOOOO")
+  end
+end
+
+describe DDT::TruthTest do
+ it "should create a Truth class under Dog" do
+    Dog::Truth.should respond_to(:new)
+  end
+
+  it "should create an input attr_accessor" do
+    Dog::Truth.new.should respond_to(:input)
+  end
+
+  it "should create an output attr_accessor" do
+    Dog::Truth.new.should respond_to(:output)
+  end
+
+  it "should create a tester method" do
+    Dog::Truth.new.should respond_to(:tester)
+  end
+
+  it "should respond to tester with an instance of Dog" do
+    Dog::Truth.new.tester.class.should == Dog
+  end
+
+  it "should allow us to set the tester method" do
+    Wolf::Truth.new.tester.call.should == "AOOOO"
+  end
+
+  it "should allow us to override the tester method by intercepting Truth::tester" do
+    Wolf::Truth.should_receive(:tester).and_return(Wolf.new "draw blood")
+    Wolf::Truth.new.tester.call.should == "draw blood"
+  end
+end
+
+# this way we know that a truth was automatically defined
+describe Cat do
+  truth_test :pet
+end
+
+# tests for truth_test
+describe Dog do
+  Group = self
+
+  it "should not raise an error if we try to add a truth test" do
+    Group.should_receive(:run_truth_test)
+    Group.truth_test :parse!
+  end
+
+  it "should raise an error if the truth file does not exist" do
+    lambda do
+      Group.truth_test :parse!, "nonexistent.yaml"
+    end.should raise_error
+  end
+
+  it "should allow us to specify YAML directly" do
+    yaml = "input: foo"
+    Group.should_receive(:run_truth_test).with(:parse!, yaml)
+    Group.truth_test :parse!, :data => yaml
+  end
+
+  # test that we actually can run the test
+  truth_test :parse!
+end

data/truths/cat/pet_truths.yaml

@@ -0,0 +1,8 @@
+---
+input: "on the head"
+output: "mrow."
+disposition: "mrow."
+---
+input: "on the belly"
+output: "mrow."
+disposition: "*hiss*"

data/truths/dog/parse!_truths.yaml

@@ -0,0 +1,5 @@
+---
+input: "Fido, 30.0, 3"
+name: "Fido"
+weight: 30.0
+age: 3

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: ddt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Dan Swain
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-27 00:00:00.000000000 Z
+dependencies: []
+description: DDT automates data driven testing.  Test data is read from a YAML file.
+email:
+- dan@simpli.fi
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ddt.rb
+- lib/truth_test/truth_test.rb
+- lib/version/version.rb
+- spec/spec_helper.rb
+- spec/truth_test/truth_test_spec.rb
+- truths/cat/pet_truths.yaml
+- truths/dog/parse!_truths.yaml
+- LICENSE
+- Rakefile
+- README.md
+homepage: http://github.com/simplifi/ddt
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Data driven testing for Ruby with RSpec.  DDT kills bugs.
+test_files:
+- spec/spec_helper.rb
+- spec/truth_test/truth_test_spec.rb
+- truths/cat/pet_truths.yaml
+- truths/dog/parse!_truths.yaml