data_factory 0.1.0

data/README.md

@@ -0,0 +1,129 @@
+# DataFactory
+
+DataFactory is a simple Ruby gem that generates data random test data and inserts it into database tables. It was created to help with unit testing in a project that had database tables having many (50+) columns, and manually crafing insert statements was tedious and error prone.
+
+DataFactory reads the table definition from the database, and generates random values for all not null columns. It inserts this data into the table, while providing the option of specifying non-random defaults.
+
+In the 0.1 release DataFactory can be considered beta software. In other words it is not really production ready, but then as it generates random test data, it is not really designed to run on a production system, so that is probably OK. It is also missing many potential features, and could easily be enhanced to do much more.
+
+# Database Compatibility
+
+Right now, DataFactory only works with Oracle databases. It should be fairly easy to extend it to other databases, but all the DB interactions have not been abstracted into an access layer, so there would be some work to do.
+
+# Requirements
+
+There are no strict dependencies for DataFactory to work, and it is a pure Ruby gem.
+
+However, DataFactory doesn't actually have a database access layer built in, as it is designed to use an external access layer that knows how to connect and query the database. 
+
+If you can use JRuby, consider using Simple JDBC Oracle to interact with your database. If you cannot use JRuby, implementing your own database interface is simple. Create a class that handles creating a database connection, and implement the following three methods to run SQL statements on the database, and issue commits:
+
+    # should return an object that implements the each_array method
+    # below
+    def execute_sql(statement, *binds)
+    end
+
+    def commit
+    end
+
+    def each_array(&blk)
+    end
+
+The first two methods are fairly obvious. The each_array method is expected to iterate over the result set returned by the executed sql statement, passing an array of columns to the block for each row returned. The array should contain the value of each column in Ruby types, ie not Java types if using JRuby.
+
+The OCI8 gem is pretty good place to start if you are using MRI Ruby, but you will need the Oracle client installed. Raw JDBC can get the job done if you are using JRuby and you do not want to use Simple JDBC Oracle.
+
+# Usage
+
+DataFactory is a simple gem, so a few examples explore a lot of the functionality. Note that these examples use Simple Oracle JDBC as the database access layer. 
+
+For these examples to run, create a table on the database as follows:
+
+    create table employees (emp_id     integer,
+                            dept_id    integer,
+                            first_name varchar2(50),
+                            last_name  varchar2(50),
+                            email      varchar2(50),
+                            ssn        varchar2(10));
+
+## Define a DataFactory Class
+
+To use DataFactory, create a class for each table you want to interface with, and make it a sub-class of DataFactory::Base:
+
+    class Employee < DataFactory::Base
+    
+      set_table_name "employees"
+    
+      set_column_default :last_name, "Smith"
+      set_column_default :email,   begin    
+                                     "#{rand(10000)}@#{rand(10000)}.com"
+                                   end
+    end
+
+In the class definition, use the set_table_name method to map the class to a particular table on the database.
+
+Optionally, you can specify default values for columns in the table with the set_column_default method, which takes the table name followed by a value for the column, or a block that generates the value each time it is called, as with the email example.
+
+
+## Creating a Row
+
+The first requirement is to connect to the database, and hand an instance of the database interface to DataFactory:
+
+    interface = SimpleOracleJDBC::Interface.create('sodonnel',
+                                                   'sodonnel',
+                                                   'local11gr2.world',
+                                                   'localhost',
+                                                   '1521')
+    
+    DataFactory::Base.set_database_interface(interface)
+
+Then a row can be created using the create! method, for example:
+
+    f = Employee.create!("emp_id" => 1001)
+
+The create! call will take the column defaults defined in the Employee class, and merge in any column values passed into the create! method. Then it will generate a value for any other non-nullable columns in the table, and insert the row into the database.
+
+An Employee instance is returned, containing all the generated values.
+
+## Putting It Together
+
+Combining each of the steps above, gives the following script:
+
+    require 'rubygems'
+    require 'simple_oracle_jdbc'
+    require 'data_factory'
+    
+    class Employee < DataFactory::Base
+    
+      set_table_name "employees"
+    
+      set_column_default :last_name, "Smith"
+      set_column_default :email,   begin
+                                     "#{rand(10000)}@#{rand(10000)}.com"
+                                   end
+    end
+    
+    interface = SimpleOracleJDBC::Interface.create('sodonnel',
+                                                   'sodonnel',
+                                                   'local11gr2.world',
+                                                   'localhost',
+                                                   '1521')
+    
+    DataFactory::Base.set_database_interface(interface)
+
+    f = Employee.create!("emp_id" => 1001)
+    
+    f.column_values.keys.each do |k|
+      puts f.column_values[k]
+    end
+
+## Other Methods
+
+The sample above illustrates how the create! method returns an Employee object, giving access to the generated values. For an overview of other methods browse the documentation for the base_api, base_dsl and base_factory methods.
+
+
+
+
+
+
+  

data/Rakefile.rb

@@ -0,0 +1,30 @@
+desc "Generate RDoc"
+task :doc => ['doc:generate']
+
+namespace :doc do
+  project_root = File.expand_path(File.dirname(__FILE__))
+  doc_destination = File.join(project_root, 'doc')
+
+  begin
+    require 'yard'
+    require 'yard/rake/yardoc_task'
+
+    YARD::Rake::YardocTask.new(:generate) do |yt|
+      yt.files   = Dir.glob(File.join(project_root, 'lib/**/*.rb')) + #, '**', '*.rb')) +
+                   [ File.join(project_root, 'README.md') ]
+      puts yt.files
+      yt.options = ['--output-dir', doc_destination, '--readme', 'README.md']
+    end
+  rescue LoadError
+    desc "Generate YARD Documentation"
+    task :generate do
+      abort "Please install the YARD gem to generate rdoc."
+    end
+  end
+
+  desc "Remove generated documenation"
+  task :clean do
+    rm_r doc_dir if File.exists?(doc_destination)
+  end
+
+end

data/lib/data_factory.rb

@@ -0,0 +1,12 @@
+require 'date'
+
+require 'data_factory/random'
+require 'data_factory/exceptions'
+require 'data_factory/column'
+require 'data_factory/base_dsl'
+require 'data_factory/base_factory'
+require 'data_factory/base_api'
+
+require 'data_factory/base'
+
+

data/lib/data_factory/base.rb

@@ -0,0 +1,16 @@
+module DataFactory
+
+  # The Base class provides a class designed to be sub-classed. It does not create any
+  # methods on its own, but is extended with class methods from the BaseDSL and BaseFactory
+  # modules and has the BaseAPI module included to provide instance methods.
+
+  class Base
+
+    extend BaseDSL
+    extend BaseFactory
+
+    include BaseAPI
+
+  end
+
+end

data/lib/data_factory/base_api.rb

@@ -0,0 +1,245 @@
+module DataFactory
+
+  # This module is included into the DataFactory::Base class providing methods
+  # to generate data and insert it into the database.
+  #
+  # For most use cases, these methods will not need to be called. The
+  # DataFactory::BaseFactory module provides factory methods that create objects and insert
+  # the data into database
+
+  module BaseAPI
+
+    include Random
+
+    attr_reader :column_values, :insert_statement, :binds
+
+    def initialize
+      unless self.class.meta_data_loaded
+        self.class.load_meta_data
+      end
+      @column_values = Hash.new
+    end
+
+    # Retrieves the table name this class interfaces with on the database
+    def table_name
+      self.class.table_name
+    end
+
+    def column_details # :nodoc:
+      self.class.column_details
+    end
+
+    def column_defaults # :nodoc:
+      self.class.column_defaults
+    end
+
+    def column_detail(key) # :nodoc:
+      self.class.column_detail(key)
+    end
+
+    # Retrieves the default value set for a column, which can be a proc
+    # or any Ruby object in general, but in practice is likely to be a
+    # Date, Time, String, Float, Integer
+    def column_default(key)
+      self.class.column_default(key)
+    end
+
+    # Returns the value assigned to a column, or nil if it is not defined
+    def column_value(key)
+      # ensure the requested column is in the table
+      column_detail(key)
+      @column_values[key.to_s.upcase]
+    end
+
+    # Returns the database interface object
+    def db_interface
+      self.class.database_interface
+    end
+
+    # Commit changes to the database
+    def commit
+      db_interface.commit
+    end
+
+    # Generates values for all the columns in the table.
+    #
+    # If no value is passed into this procedure for a column, a default will be used
+    # if it is configured. Otherwise a random value will be generated.
+    #
+    # Values for a column can be passed into this method using a hash, eg:
+    #
+    #    obj.generate_column_data(:emp_id => 1, :last_name => 'Smith)
+    def generate_column_data(params=Hash.new)
+      self.class.column_details.keys.each do |k|
+        if column_default(k)
+          if column_default(k).is_a?(Proc)
+            @column_values[k] = column_default(k).call
+          else
+            @column_values[k] = column_default(k)
+          end
+        else
+          @column_values[k] = generate_value(column_detail(k))
+        end
+      end
+      normalised_params = internalize_column_params(params)
+      validate_columns(normalised_params)
+      @column_values.merge! normalised_params
+    end
+
+
+    # Generates an insert statement for the current state of the object. It is intended
+    # to be called after generate_column_data has been called, otherwise all the values
+    # will be null.
+    #
+    # The generated statement returned as a string and also stored in the @insert_statement
+    # instance variable.
+    #
+    # The insert statement will contain bind variables for all columns. The generated bind
+    # variabled are stored in @binds.
+    def generate_insert
+      @binds = Array.new
+      @insert_statement = "insert into #{table_name} ("
+      @insert_statement << column_details.keys.sort.map { |k| column_detail(k).column_name }.join(',')
+      @insert_statement << ') values ('
+      @insert_statement << column_details.keys.sort.map { |k|
+        ":#{k}"
+      }.join(',')
+      column_details.keys.sort.each { |k|
+        if @column_values[k] == nil
+          @binds.push [column_type_to_ruby_type(column_details[k]), nil]
+        else
+          @binds.push @column_values[k]
+        end
+      }
+      @insert_statement << ')'
+      @insert_statement
+    end
+
+    # Runs the insert statement prepared by generate_insert, using the insert
+    # statement stored in @insert_statement and the bind variables in @binds
+    #
+    # If generate_insert has not be executed, this procedure will raise
+    # a DataFactory::NoInsertStatement exeception
+    def run_insert
+      raise DataFactory::NoInsertStatement unless @insert_statement
+
+      stmt = db_interface.execute_sql(@insert_statement, *@binds)
+      stmt.close
+    end
+
+    # Generates a where clause for the DataFactory object. This method looks at the columns
+    # on the table, and the values set against them, and generates a string representing a
+    # where clause that can be used in an SQL query.
+    #
+    # The generated string does not contain the 'where' keyword.
+    def where_clause_for(cols)
+      cols.map{|c| c.to_s.upcase}.map{|c|
+        if @column_values[c] == nil
+          "#{c} is null"
+        else
+          "#{c} = #{quote_value(c) }"
+        end
+      }.join " and "
+    end
+
+    private
+
+    # TODO - This needs to be extracted into a DB specific access layer, as it is
+    # Oracle specific.
+    def quote_value(col)
+      case column_detail(col).data_type
+      when 'CHAR', 'VARCHAR2', 'CLOB'
+        "'#{@column_values[col]}'"
+      when 'DATE', 'DATETIME'
+        "to_date('#{@column_values[col].strftime('%Y%m%d %H:%M:%S')}', 'YYYYMMDD HH24:MI:SS')"
+      else
+        @column_values[col].to_s
+      end
+    end
+
+    def generate_value(col)
+      if col.nullable?
+        return nil
+      end
+
+      case col.data_type
+      when 'CHAR', 'VARCHAR2', 'CLOB'
+        random_string_upto_length(col.data_length)
+      when 'DATE', 'DATETIME', 'TIMESTAMP'
+        Time.now
+      when 'NUMBER', 'INTEGER'
+        scale = 2
+        if col.data_scale && col.data_scale == 0
+          1
+        else
+          22.23
+        end
+
+      #   # random numbers is very much beta and very untested.
+      #   #
+      #   # 38 digits total, 28 before decimal point, and 10 after.
+      #   precision = 38
+      #   scale     = 10
+      #   if col.data_precision
+      #     precision = col.data_precision
+      #   end
+      #   if col.data_scale
+      #     scale = col.data_scale
+      #   end
+
+      #   if scale == 0
+      #     # its an integer
+      #     random_integer(10**col.data_precision - 1)
+      #   else
+      #     # its a number
+      #     max_left  = 10**(precision - scale) - 1
+      #     max_right = 10**scale - 1
+      #     "#{random_integer(max_left)}.#{random_integer(max_right)}".to_f
+      #   end
+      when 'NUMBER'
+        23.34
+      when 'INTEGER'
+      else
+        nil
+      end
+    end
+
+    def column_type_to_ruby_type(col)
+      case col.data_type
+      when 'CHAR', 'VARCHAR2', 'CLOB'
+        String
+      when 'DATE', 'DATETIME', 'TIMESTAMP'
+        Time
+      when 'INTEGER'
+        Integer
+      when 'NUMBER'
+        if col.data_scale == 0
+          Integer
+        else
+          Float
+        end
+      else
+        raise "unsupported datatype #{col.data_type}"
+      end
+    end
+
+    def internalize_column_params(params)
+      upcased_params = Hash.new
+      params.keys.each do |k|
+        # change it from a symbol(if it is a symbol) to a string and uppercase.
+        upcased_params[k.to_s.upcase] = params[k]
+      end
+      upcased_params
+    end
+
+    def validate_columns(params)
+      params.keys.each do |k|
+        unless column_details.has_key? k.upcase
+          raise DataFactory::ColumnNotInTable
+        end
+      end
+    end
+
+
+  end
+end

data/lib/data_factory/base_dsl.rb

@@ -0,0 +1,175 @@
+module DataFactory
+
+  # This module is used to extend the DataFactory::Base class, and so creates a
+  # series of class instance methods that can be used in class definitions.
+  #
+  # For example:
+  #
+  #    class Foo < DataFactory::Base
+  #
+  #      set_table_name "Foobar"
+  #      set_column_default :last_name, 'Smith'
+  #
+  #    end
+  #
+  # For this reason, calling any of these methods on a class, will affect ALL instances
+  # of that class.
+  #
+  # Any subclasses expect the class variables @@db_interface to be set, containing a database
+  # access class, eg:
+  #
+  #     DataFactory::Base.set_database_interface(interface_obj)
+  #
+  # As this is stored in a class variable the same database interface is shared down the entire
+  # inheritance chain. Therefore if many database connections are required, several base classes
+  # will need to be created by including the relevant modules, eg:
+  #
+  #     class OtherBaseClass
+  #       extend BaseDSL
+  #       extend BaseFactory
+  #       include BaseAPI
+  #     end
+
+  module BaseDSL
+
+    attr_reader :table_name, :column_details, :column_defaults, :meta_data_loaded
+
+    # Pass a database interface object to be used by all DataFactory sub-classes
+    # The interface must implement the following two methods:
+    #
+    #     def execute_sql(statement, *binds)
+    #     end
+    #
+    #     def each_array(&blk)
+    #     end
+    #
+    #     def commit
+    #     end
+    #
+    # This method is normally called on the DataFactory::Base class. It will
+    # set a class variable (@@db_interface) in the Base class which is shared
+    # by all sub-classes of the class.
+    #
+    # Ideally use the SimpleOracleJDBC gem to provide the interface
+    def set_database_interface(interface)
+      class_variable_set("@@db_interface", interface)
+    end
+
+
+    # Returns the database interface that was set by set_database_interface
+    def database_interface
+      class_variable_get("@@db_interface")
+    end
+
+
+    # Defines the table a subclass of DataFactory interacts with on the database. This
+    # method stores the tables in a class instance variable (@table_name) that is shared by
+    # all instances of the class, but is not inherited with subclasses.
+    def set_table_name(tab)
+      @table_name = tab.to_s.upcase
+    end
+
+    # Sets the default value to be used for a column if nothing else is
+    # specified. The block is optional and should be used if dynamic defaults
+    # are required. If the default is a constant, a simple value can be specified.
+    # The default is stored within a hash which is stored in a class instance variable
+    # (@column_defaults) that is shared by all instances of the class, but is not inherited
+    # with subclasses.
+    def set_column_default(column_name, value=nil, &block)
+      unless defined? @column_defaults
+        @column_defaults = Hash.new
+      end
+      @column_defaults[column_name.to_s.upcase] = block_given? ? block :
+        value.is_a?(Symbol) ? value.to_s : value
+    end
+
+
+    # Returns the value for a column default. If it is a simple value, the value
+    # is returned. If the default is a proc, the proc is executed and the resulting
+    # values is returned.
+    def column_default(column_name)
+      return nil unless defined? @column_defaults
+
+      val = @column_defaults[column_name.to_s.upcase]
+      if val.is_a?(Proc)
+        val.call
+      else
+        val
+      end
+    end
+
+
+    # Returns a DataFactory::Column object that defines the properties
+    # of the column
+    def column_detail(column_name)
+      load_meta_data unless meta_data_loaded
+
+      unless @column_details.has_key?(column_name.to_s.upcase)
+        raise DataFactory::ColumnNotInTable
+      end
+
+      @column_details[column_name.to_s.upcase]
+    end
+
+
+    # Used to load the table meta-data from the database
+    # TODO - abstract into a database layer as this code is Oracle specific
+    def load_meta_data # :nodoc:
+      raise DataFactory::TableNotSet unless @table_name
+      raise DataFactory::DatabaseInterfaceNotSet unless class_variable_defined?("@@db_interface")
+
+      if meta_data_loaded
+        return
+      end
+
+      @column_details  = Hash.new
+
+      unless defined? @column_defaults
+        @column_defaults = Hash.new
+      end
+
+      table_details_sql = "select column_name,
+                                  data_type,
+                                  data_length,
+                                  data_precision,
+                                  data_scale,
+                                  column_id,
+                                  nullable
+                           from user_tab_columns
+                           where table_name = ?
+                           order by column_id asc"
+
+      database_interface.execute_sql(table_details_sql, @table_name).each_array do |r|
+        c = Column.new
+        c.column_name     = r[0].upcase
+        c.data_type       = r[1].upcase
+        c.data_length     = r[2].to_i
+        c.data_precision  = r[3].to_i
+        c.data_scale      = r[4].to_i
+        c.position        = r[5].to_i
+        c.nullable        = r[6] == 'N' ? false : true
+        @column_details[r[0].upcase] = c
+      end
+      @meta_data_loaded = true
+      # This is needed here as some column defaults will have been set
+      # before the meta_data was loaded and hence will not have been checked
+      validate_column_defaults
+    end
+
+    private
+
+    def validate_column_defaults
+      @column_defaults.keys.each do |k|
+        validate_column_default(k, @column_defaults[k])
+      end
+    end
+
+
+    def validate_column_default(column_name, column_value)
+      unless @column_details.has_key? column_name
+        raise DataFactory::ColumnNotInTable, column_name
+      end
+    end
+
+  end
+end

data/lib/data_factory/base_factory.rb

@@ -0,0 +1,41 @@
+module DataFactory
+  module BaseFactory
+
+    # This module implements the class methods of the DataFactory::Base class.
+    # These factory methods should be used to generate database records.
+
+    # Builds a new instance of a DataFactory class, inserts it into the database
+    # and commits the transaction. The params parameter is expected to be a hash, mapping columns
+    # in the underlying table to values. These values will be merged with any
+    # defaults set for the columns, and will override the defaults if passed. For example:
+    #
+    # obj = Employee.create!(:last_name => 'Smith')
+    def create!(params)
+      df = create(params)
+      df.commit
+      df
+    end
+
+    # Same as the create! method, only the transaction is not committed on the database.
+    # For example:
+    #
+    # obj = Employee.create(:last_name => 'Smith')
+    def create(params)
+      df = build(params)
+      df.generate_insert
+      df.run_insert
+      df
+    end
+
+    # Builds and returns a new instance of a DataFactory class, but does not insert it
+    # into the database. For example:
+    #
+    # obj = Employee.build(:last_name => 'Smith')
+    def build(params)
+      df = self.new
+      df.generate_column_data(params)
+      df
+    end
+
+  end
+end

data/lib/data_factory/column.rb

@@ -0,0 +1,18 @@
+module DataFactory
+  class Column
+
+    attr_accessor :column_name, :data_type, :data_length, :data_scale, :data_precision, :position, :nullable
+
+    def initialize
+    end
+
+    def nullable?
+      nullable
+    end
+
+    def to_s
+      "#{@column_name} #{@data_type} #{data_length} #{data_scale} #{data_precision} #{position.to_s}"
+    end
+
+  end
+end

data/lib/data_factory/exceptions.rb

@@ -0,0 +1,6 @@
+module DataFactory
+  class TableNotSet < Exception; end
+  class DatabaseInterfaceNotSet < Exception; end
+  class ColumnNotInTable < Exception; end
+  class NoInsertStatement < Exception; end;
+end

data/lib/data_factory/random.rb

@@ -0,0 +1,28 @@
+module DataFactory
+  module Random
+
+    CHARS = ['A'..'Z', 'a'..'z', '0'..'9'].map{|r|r.to_a}.flatten
+
+    # Generates a random string of letters and numbers of length
+    def random_string_of_length(length)
+      str = ''
+      1.upto(length) do
+        str << CHARS[rand(CHARS.size)]
+      end
+      str
+    end
+
+    # Generates a random string of random length, which has a maximum
+    # length of max_length
+    def random_string_upto_length(max_length)
+      length = random_integer(max_length)
+      random_string_of_length(length)
+    end
+
+    # Generates a random integer that is at most max_size
+    def random_integer(max_size)
+      1 + rand(max_size)
+    end
+
+  end
+end

data/test/base_api_test.rb

@@ -0,0 +1,151 @@
+require 'helper'
+
+class BaseAPITest < Test::Unit::TestCase
+
+  include TestHelper
+
+  def setup
+    @klass = Class.new
+    @klass.extend DataFactory::BaseDSL
+    @dbinterface = DBInterfaceMock.new
+    @klass.set_database_interface(@dbinterface)
+    @klass.set_table_name('foobar')
+    @klass.send :include, DataFactory::BaseAPI
+  end
+
+  def teardown
+  end
+
+  def test_exception_if_table_name_not_set
+    klass = Class.new
+    klass.extend DataFactory::BaseDSL
+    dbinterface = DBInterfaceMock.new
+    klass.set_database_interface(dbinterface)
+    klass.send :include, DataFactory::BaseAPI
+    assert_raises DataFactory::TableNotSet do
+      instance = klass.new
+    end
+  end
+
+  def test_table_name_can_be_retrieved
+    instance = @klass.new
+    assert_equal('FOOBAR', instance.table_name)
+  end
+
+  def test_column_default_is_retrieved
+    @klass.set_column_default('COL1', 'abcd')
+    instance = @klass.new
+    assert_equal('abcd', instance.column_default('COL1'))
+  end
+
+  def test_column_default_is_nil_if_not_set
+    instance = @klass.new
+    assert_equal(nil, instance.column_default('COL1'))
+  end
+
+  def test_column_default_hash_is_retrieved
+    @klass.set_column_default('COL1', 'abcd')
+    instance = @klass.new
+    assert(instance.column_defaults.is_a?(Hash))
+    assert_equal('abcd', instance.column_defaults['COL1'])
+  end
+
+  def test_empty_default_hash_retrieved_if_no_defaults
+    instance = @klass.new
+    assert(instance.column_defaults.is_a?(Hash))
+    assert_equal(0, instance.column_defaults.keys.length)
+  end
+
+  def test_column_detail_is_retrieved
+    instance = @klass.new
+    assert(instance.column_detail('COL1').is_a? DataFactory::Column)
+    assert_equal('COL1', instance.column_detail('COL1').column_name)
+  end
+
+  def test_exception_raised_if_column_not_in_table
+    instance = @klass.new
+    assert_raises DataFactory::ColumnNotInTable do
+      instance.column_detail('not exist')
+    end
+  end
+
+  def test_column_detail_hash_retrieved
+    instance = @klass.new
+    assert(instance.column_details.is_a? Hash)
+    assert_equal('COL1', instance.column_details['COL1'].column_name)
+  end
+
+  def test_db_interface_returned
+    instance = @klass.new
+    assert_equal(@dbinterface, instance.db_interface)
+  end
+
+  def test_commit_called_on_db_interface
+    # Mocha will raise an exception if the commit method is not invoked
+    instance = @klass.new
+    @dbinterface.expects(:commit).at_least_once
+    instance.commit
+  end
+
+  def test_column_value_returns_nil_when_not_generated
+    instance = @klass.new
+    assert_equal(nil, instance.column_value('COL1'))
+  end
+
+  def test_execption_raised_for_column_value_when_not_in_table
+    instance = @klass.new
+    assert_raises DataFactory::ColumnNotInTable do
+      instance.column_value('NOTTHERE')
+    end
+  end
+
+  def test_generate_data_generates_nil_if_column_nullable
+    instance = @klass.new
+    instance.generate_column_data
+    assert_nil(instance.column_value('COL1'))
+  end
+
+  def test_generate_data_generates_column_data_if_column_not_nullable
+    instance = @klass.new
+    instance.generate_column_data
+    assert_not_nil(instance.column_value('COL3'))
+  end
+
+  def test_generate_data_default_used_for_column_when_present
+    @klass.set_column_default :col1, 'PRESET'
+    instance = @klass.new
+    instance.generate_column_data
+    assert_equal('PRESET', instance.column_value('COL1'))
+  end
+
+  def test_generate_data_passed_in_value_overrides_default
+    @klass.set_column_default :col1, 'PRESET'
+    instance = @klass.new
+    instance.generate_column_data(:col1 => 'OVERRIDE')
+    assert_equal('OVERRIDE', instance.column_value('COL1'))
+  end
+
+  def test_generate_data_raises_exception_when_passed_in_column_not_exist
+    instance = @klass.new
+    assert_raises DataFactory::ColumnNotInTable do
+      instance.generate_column_data(:notexist => 'OVERRIDE')
+    end
+  end
+
+
+  # TODO - tests for generate insert
+  # TODO - tests for
+
+
+
+
+  def test_run_insert_invokes_execute_on_db_interface
+    instance = @klass.new
+    instance.generate_column_data
+    instance.generate_insert
+    @dbinterface.expects(:execute_sql).returns(@dbinterface)
+    instance.run_insert
+  end
+
+end
+

data/test/base_dsl_test.rb

@@ -0,0 +1,109 @@
+require 'helper'
+
+class BaseDSLTest < Test::Unit::TestCase
+
+  include TestHelper
+
+  def setup
+    @klass = Class.new
+    @klass.extend DataFactory::BaseDSL
+  end
+
+  def teardown
+  end
+
+  def test_table_name_can_be_set_as_a_class_instance_variable
+    @klass.set_table_name('foobar')
+    assert_equal('FOOBAR', @klass.table_name)
+    assert_equal('FOOBAR', @klass.instance_variable_get('@table_name'))
+  end
+
+  def test_table_name_as_symbol_converted_to_string
+    @klass.set_table_name(:foobar)
+    assert_equal('FOOBAR', @klass.table_name)
+  end
+
+  def test_db_interface_is_set_as_a_class_variable
+    dbklass = Class.new
+    @klass.set_database_interface(dbklass)
+    # need to use send here as @@db_interface is a private variable
+    assert_equal(dbklass, @klass.send(:class_variable_get, '@@db_interface'))
+  end
+
+  def test_set_column_default_value
+    @klass.set_column_default("COL1", 'value1')
+    assert_equal('value1', @klass.column_default('COL1'))
+  end
+
+  def test_set_column_default_as_symbol_converted_to_string
+    @klass.set_column_default(:col1, 'value1')
+    assert_equal('value1', @klass.column_default('COL1'))
+  end
+
+  def test_set_column_default_as_proc
+    @klass.set_column_default(:col1) { 'value1' }
+    assert_equal('value1', @klass.column_default('COL1'))
+  end
+
+  def test_set_column_default_value_as_symbol_converted_to_string
+    @klass.set_column_default("COL1", :value1)
+    assert_equal('value1', @klass.column_default('COL1'))
+  end
+
+  def test_get_column_default_returns_nil_when_not_set
+    assert_equal(nil, @klass.column_default('COL1'))
+  end
+
+  def test_get_column_default_as_symbol_converted_to_string
+    @klass.set_column_default("COL1", 'value1')
+    assert_equal('value1', @klass.column_default(:col1))
+  end
+
+  def test_load_meta_data_loads_columns
+    @klass.set_database_interface(DBInterfaceMock.new)
+    @klass.set_table_name(:foobar)
+    @klass.load_meta_data
+    assert(@klass.column_detail('COL1').is_a?(DataFactory::Column))
+    assert_equal('COL1', @klass.column_detail('COL1').column_name)
+  end
+
+  def test_load_meta_data_exception_raised_when_table_not_set
+    assert_raises DataFactory::TableNotSet do
+      @klass.set_database_interface(DBInterfaceMock.new)
+      @klass.load_meta_data
+    end
+  end
+
+  def test_load_meta_data_exception_raised_when_db_interface_not_set
+    @klass.set_table_name(:foobar)
+    assert_raises DataFactory::DatabaseInterfaceNotSet do
+      @klass.load_meta_data
+    end
+  end
+
+  def test_load_meta_data_raises_exception_when_invalid_column_default_set
+    @klass.set_database_interface(DBInterfaceMock.new)
+    @klass.set_table_name(:foobar)
+    @klass.set_column_default :not_exists, :value1
+    assert_raises DataFactory::ColumnNotInTable do
+      @klass.load_meta_data
+    end
+  end
+
+  def test_column_detail_loads_meta_data_if_not_loaded
+    @klass.set_database_interface(DBInterfaceMock.new)
+    @klass.set_table_name(:foobar)
+    assert(@klass.column_detail('COL1').is_a?(DataFactory::Column))
+  end
+
+  def test_column_detail_raises_exception_if_column_does_not_exist
+    @klass.set_database_interface(DBInterfaceMock.new)
+    @klass.set_table_name(:foobar)
+    assert_raises DataFactory::ColumnNotInTable do
+      assert(@klass.column_detail('COLNOTTHERE').is_a?(DataFactory::Column))
+    end
+  end
+
+
+end
+

data/test/helper.rb

@@ -0,0 +1,49 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+#require 'rubygems'
+#require 'simple_oracle_jdbc'
+require 'data_factory'
+require 'test/unit'
+require 'mocha/setup'
+
+module TestHelper
+
+  DB_USER     = 'sodonnel'
+  DB_PASSWORD = 'sodonnel'
+  DB_SERVICE  = 'local11gr2.world'
+  DB_HOST     = 'localhost'
+  DB_PORT     = '1521'
+
+#  @@interface ||= SimpleOracleJDBC::Interface.create(DB_USER,
+#                                                     DB_PASSWORD,
+#                                                     DB_SERVICE,
+#                                                     DB_HOST,
+#                                                     DB_PORT)
+
+  class DBInterfaceMock
+    def execute_sql(sql, binds)
+      self
+    end
+
+    # Mock out returing a list of columns for a table.
+    def each_array(&blk)
+      data = [
+              # cname, type       len  precision, scale, position, nullable
+              ['col1', 'varchar2', 20, nil, nil, 1, 'Y'],
+              ['col2', 'number',   20, 9,   2,   2, 'Y'],
+              ['col3', 'DATE',     20, nil, nil, 3, 'N'],
+              ['col4', 'varchar2', 20, nil, nil, 4, 'N'],
+              ['col5', 'integer',  20, 38,  0, 5, 'N'],
+              ['col6', 'number',   20, 20,  5, 6, 'N']
+             ]
+      data.each do |d|
+        yield d
+      end
+    end
+
+    def close
+    end
+  end
+
+end

data/test/sanity.rb

@@ -0,0 +1,22 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'simple_oracle_jdbc'
+require 'data_factory'
+
+#interface = DataFactory::DBInterface::Oracle.create('sodonnel', 'sodonnel', 'local11gr2')
+interface = SimpleOracleJDBC::Interface.create('sodonnel', 'sodonnel', 'local11gr2.world', 'localhost', '1521')
+
+DataFactory::Base.set_database_interface(interface)
+
+class Foo < DataFactory::Base
+  set_table_name "employees"
+  set_column_default "EMP_NAME", 'john'
+end
+
+
+f = Foo.create!("emp_id" => 1001)
+f.column_values.keys.each do |k|
+  puts f.column_values[k]
+end

data/test/test_runner.rb

@@ -0,0 +1,11 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "."))
+
+current_dir = File.expand_path(File.dirname(__FILE__))
+
+
+# Find all files that end in _test.rb and require them ...
+files = Dir.entries(current_dir).grep(/^[^#].+_test\.rb$/).sort
+files.each do |f|
+  require File.join(current_dir, f)
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: data_factory
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Stephen O'Donnell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-02-12 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: Generates data to insert into database tables, allowing columns to be defaulted or overriden. Intended to be used when testing wide tables where many not null columns may need to be populated but are not part of the test
+email: stephen@betteratoracle.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- test/base_api_test.rb
+- test/base_dsl_test.rb
+- test/helper.rb
+- test/sanity.rb
+- test/test_runner.rb
+- lib/data_factory/base.rb
+- lib/data_factory/base_api.rb
+- lib/data_factory/base_dsl.rb
+- lib/data_factory/base_factory.rb
+- lib/data_factory/column.rb
+- lib/data_factory/exceptions.rb
+- lib/data_factory/random.rb
+- lib/data_factory.rb
+- DataFactory-0.1.gem
+- Rakefile.rb
+- README.md
+has_rdoc: true
+homepage: http://betteratoracle.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A gem to generate template insert statements for use when unit testing database code
+test_files: []
+