db-factory 0.1.1

data/History.txt

@@ -0,0 +1,8 @@
+== 0.1.0 2013-04-15
+
+* Initial release
+* Known limitations
+  * No YAML file validation
+  * Missing comments
+  * Documentation
+  * Examples

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/db-factory.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = 'db-factory'
+  s.version    = '0.1.1'
+  s.date        = '2013-04-16'
+  s.summary    = "Prepare and compare test data for PL/SQL unit testing"
+  s.description = "db-factory uses definition files with YAML/ERB syntax to define test data (preconditions) for unit PL/SQL testing and can compare actual data with defined expected data."
+  s.authors    = ["Stefan Cibiri"]
+  s.email      = 'stefancibiri@yahoo.com'
+  s.files      = ["History.txt", "VERSION", "db-factory.gemspec", "examples/simple_example_1/Readme.txt", "examples/simple_example_1/create_objects.sql", "examples/simple_example_1/simple_example_1.yml", "examples/simple_example_1/simple_example_1_spec.rb", "examples/simple_example_1/spec_helper.rb", "lib/config.yml", "lib/db-factory.rb", "lib/db_factory/db_factory.rb", "lib/db_factory/helpers.rb", "lib/db_factory/version.rb"]
+  s.homepage    = "https://github.com/stci/db-factory"
+  s.add_dependency('ruby-plsql')
+end

data/examples/simple_example_1/Readme.txt

@@ -0,0 +1,23 @@
+Simple Example 1 Readme
+-----------------------
+
+1) run "create_objects.sql" under e.g. SCOTT schema (which normaly should be schema where your application and data is)
+
+2) create user TEST_USER with there privileges
+  grant connect to TEST_USER;
+  grant delete_catalog_role to TEST_USER;
+  grant execute_catalog_role to TEST_USER;
+  grant select_catalog_role to TEST_USER;
+  grant alter any table to TEST_USER;
+  grant create role to TEST_USER;
+  grant delete any table to TEST_USER;
+  grant execute any procedure to TEST_USER;
+  grant flashback any table to TEST_USER;
+  grant insert any table to TEST_USER;
+  grant select any dictionary to TEST_USER;
+  grant select any sequence to TEST_USER;
+  grant select any table to TEST_USER;
+  grant update any table to TEST_USER;
+
+3) execute in command line:
+  rspec simple_example_1_spec.rb

data/examples/simple_example_1/create_objects.sql

@@ -0,0 +1,35 @@
+create table DEPARTEMENTS
+(
+  departement_id  NUMBER,
+  departement_name VARCHAR2(30),
+  coeficient  number(5,2)
+);
+
+create table EMPLOYEES
+(
+  employee_id    NUMBER,
+  departement_id NUMBER,
+  first_name    VARCHAR2(30),
+  last_name      VARCHAR2(30),
+  hire_date      DATE,
+  phone_number  VARCHAR2(30),
+  salary        NUMBER(12,2)
+);
+
+create or replace function salary_update(dep_id_from number,
+                                        dep_id_to  number) return number is
+begin
+  update employees e
+    set e.salary = e.salary *
+                    (select coeficient
+                      from departements d
+                      where d.departement_id = e.departement_id)
+  where e.departement_id between dep_id_from and dep_id_to;
+
+  return 0;
+
+exception
+  when others then
+    dbms_output.put_line(sqlerrm);
+    return 1;
+end;

data/examples/simple_example_1/simple_example_1.yml

@@ -0,0 +1,63 @@
+--- %FORMAT: 1.0
+
+CONSTANTS:
+- HIRE_DATE : &HD
+    <%= Date.today %>
+
+DEFAULTS:
+  tables:
+
+  - "scott.employees": {
+      :hire_date : *HD,
+      :last_name : 'SMITH'
+    }
+
+COMMON:
+  setup:
+    tables:
+
+    - "scott.departements":
+        delete:
+          condition: "1=1"
+        columns:
+          [:departement_id, :departement_name, :coeficient]
+        data:
+        - [1              , 'IT'            , 1.15      ]
+        - [2              , 'Administration' , 1.10      ]
+        - [3              , 'Sales'          , 0.95      ]
+        - [4              , 'Other'          , ~          ]
+
+SALARY:
+  setup:
+    tables:
+
+    - "scott.employees":
+        delete:
+          condition: "last_name = 'SMITH'"
+        columns:
+          [:employee_id, :departement_id, :first_name, :salary]
+        data:
+        - [1          , 1              , 'STEVE'    , 100.00 ]
+        - [2          , 1              , 'BOB'      , 120.00 ]
+        - [3          , 2              , 'COLIN'    , 180.30 ]
+        - [4          , 3              , 'PHIL'    , 280.00 ]
+        - [5          , 4              , 'JHON'    ,  88.00 ]
+
+  postconditions:
+    tables:
+
+    - "scott.employees":
+        filter: "last_name = 'SMITH' and departement_id <> 4"
+        connect keys: [:employee_id]
+        columns:
+          [:employee_id, :salary]
+        stage-1:
+        - [1          , 115.00 ]
+        - [2          , 138.00 ]
+        - [3          , 198.33 ]
+        - [4          , 280.00 ]
+        expected data:
+        - [1          , 115.00 ]
+        - [2          , 138.00 ]
+        - [3          , 198.33 ]
+        - [4          , 266.00 ]

data/examples/simple_example_1/simple_example_1_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Simple example 1" do
+
+  DBFactory.load('simple_example_1.yml')
+
+  before(:all) do
+    DBFactory.setup('SALARY')
+  end
+
+  it "should update salary of employees according coeficient defined on department" do
+
+    plsql.scott.salary_update(1, 2).should == 0
+    DBFactory.evaluate('stage-1').should == true
+
+    plsql.scott.salary_update(3, 3).should == 0
+    DBFactory.evaluate().should == true
+
+  end
+
+end

data/examples/simple_example_1/spec_helper.rb

@@ -0,0 +1,52 @@
+require "rspec"
+require "ruby-plsql"
+require "db-factory"
+
+$LOAD_PATH << File.dirname(__FILE__) + '/factories'
+
+# Establish connection to database where tests will be performed.
+# Change according to your needs.
+DATABASE_USER    = "TEST_USER"
+DATABASE_PASSWORD = "TEST_USER"
+DATABASE_NAME    = "DEV_DB" # TNS
+
+plsql.connect! DATABASE_USER, DATABASE_PASSWORD, DATABASE_NAME
+
+# Set autocommit to false so that automatic commits after each statement are _not_ performed
+plsql.connection.autocommit = false
+# reduce network traffic in case of large resultsets
+plsql.connection.prefetch_rows = 100
+# uncomment to log DBMS_OUTPUT to standard output
+# plsql.dbms_output_stream = STDOUT
+
+# Do logoff when exiting to ensure that session temporary tables
+# (used when calling procedures with table types defined in packages)
+at_exit do
+  plsql.logoff
+end
+
+RSpec.configure do |config|
+  config.before(:each) do |test|
+    plsql.savepoint "before_each"
+
+    plsql.sys.dbms_application_info.set_module(:module_name => test_filename, :action_name => test.example.metadata[:example_group][:full_description]);
+  end
+  config.after(:each) do
+    # Always perform rollback to savepoint after each test
+    plsql.rollback_to "before_each"
+  end
+  config.after(:all) do
+    # Always perform rollback after each describe block
+    plsql.rollback
+  end
+end
+
+# require all helper methods which are located in any helpers subdirectories
+Dir[File.dirname(__FILE__) + '/**/helpers/*.rb'].each {|f| require f}
+
+# require all factory modules which are located in any factories subdirectories
+Dir[File.dirname(__FILE__) + '/**/factories/*.rb'].each {|f| require f}
+
+# Add source directory to load path where PL/SQL example procedures are defined.
+# It is not required if PL/SQL procedures are already loaded in test database in some other way.
+$:.push File.dirname(__FILE__) + '/../../source'

data/lib/config.yml

@@ -0,0 +1,15 @@
+# configuration file
+
+GENERAL:
+  supported format:
+    - 1.0
+  validation schema: validator.yml
+
+LOG:
+  path      : .
+  filename  : <%= "DBFactory.#{Date.today().to_s()}.log" %>
+  date format: "%Y-%m-%d %H:%M:%S"
+  level      : <%= Logger::DEBUG %>
+
+DIFF:
+  filename_tpl: "diff-#CASE#.yml"

data/lib/db-factory.rb

@@ -0,0 +1,5 @@
+ROOT = File.expand_path(File.dirname(__FILE__))
+
+%w(db_factory version helpers).each do |file|
+  require "db_factory/#{file}"
+end

data/lib/db_factory/db_factory.rb

@@ -0,0 +1,532 @@
+require "logger"
+require "bigdecimal/util"
+require "yaml"
+require "erb"
+
+class DBFactoryClass
+
+  @cfg
+  @log
+  @definition
+  @case
+  @scn
+
+  def initialize()
+    l_erb  = ERB.new(File.read("#{ROOT}/config.yml"))
+    @cfg = YAML.load(l_erb.result(binding).to_s)
+
+    @log = Logger.new("#{@cfg['LOG']['path']}/#{@cfg['LOG']['filename']}")
+    @log.info  "================ Initializing DBFactory ================"
+    @log.debug "[ DBFactory::initialize(...) ]"
+
+    @log.datetime_format = @cfg['LOG']['date format']
+    @log.level = @cfg['LOG']['level']
+
+    return self
+  end
+
+  def load(definition_file)
+    @log.debug "[ DBFactory::load(...) ]"
+    @log.debug " > definition_file = <#{definition_file}>"
+
+    begin
+      @log.debug "Reading constants ..."
+      constants  = YAML.load_file(definition_file)['CONSTANTS'].reduce(Hash.new, :merge)
+    rescue Exception => e
+      @log.error "[ DBFactory::load(...) ] ERROR: <#{e.to_s}>"
+      @log.error "Error occurred during load of definition file <#{definition_file}>"
+      raise "Check defintion file <#{definition_file}>: #{e.to_s}"
+    end
+
+    @log.debug "Injecting constants ..."
+    l_erb      = ERB.new(File.read(definition_file).strip.gsub(/^\s*#.*/,'').gsub(/\n^\s*$/,''))
+
+    @log.debug "Parsing defintion file ..."
+    @definition = YAML.load(l_erb.result(binding).to_s)
+    @case = 'COMMON'
+
+#    puts @cfg['GENERAL']['supported_file_format_versions'].to_s
+#    puts @definition['FORMAT VERSION']
+#    puts @definition.inspect
+    raise "Unsupported version of YAML file. Supported file versions: #{@cfg['GENERAL']['supported format'].to_s}" unless @cfg['GENERAL']['supported
+format'].include?(@definition['%FORMAT'])
+  end
+
+  def setup(casename = 'COMMON')
+    @log.debug "[ DBFactory::setup(...) ]"
+    @log.debug " > casename = <#{casename}>"
+
+    if casename != 'COMMON'
+      setup()
+    else
+      @scn = plsql.select("select current_scn from v$database")[0][:current_scn]
+      @log.info("CURRENT SCN from DB = <#{@scn}>")
+    end
+
+    @case = casename
+
+    if @definition[@case].include?('cleanup')
+      @definition[@case]['cleanup']['tables'].each { |t|
+        cleanup_table(t)
+      }
+    end
+
+#    puts @definition[@case] unless casename == 'COMMON'
+    @definition[@case]['setup']['tables'].each { |t|
+      prepare_table(t)
+    }
+
+  end
+
+  def check_postconditions(stage = nil)
+    @log.debug "[ DBFactory::check_postconditions(...) ]"
+    l_result = true
+    raise "Use stage name (must contain string 'stage-[stage name]'" unless stage.nil? || stage.include?('stage')
+#    l_stage = "stage-#{stage}" unless stage == nil
+    l_diff_file = @cfg['DIFF']['filename_tpl'].gsub('#CASE#',@case)
+    File.delete(l_diff_file) unless not File.exist?(l_diff_file)
+    @definition[@case]['postconditions']['tables'].each { |t|
+      if stage.nil? || t.values[0].include?(stage)
+        l_result_tmp = check_postconditions_for_table(t, stage)
+        l_result = l_result_tmp unless l_result == false
+      end
+    }
+
+    if l_result
+      @log.info("> DBFactory::evaluate(...) ... PASS")
+    else
+      @log.warn("> DBFactory::evaluate(...) ... FAIL")
+    end
+
+    return l_result
+  end
+
+  def flashback()
+    @log.debug "[ DBFactory::flashback(...) ]"
+    l_result = true
+    @definition[@case]['flashback']['tables'].each { |t|
+        table_owner = t.split('.')[0].upcase
+        table_name = t.split('.')[1].upcase
+        @log.debug " > table_owner = <#{table_owner}>"
+        @log.debug " > table_name  = <#{table_name}>"
+        @log.debug " > scn        = <#{@scn}>"
+        l_result = plsql.flashback_table(table_owner, table_name, @scn) unless l_result == false
+        @log.debug "...DONE"
+    }
+    @scn = nil
+
+    return l_result
+  end
+
+  private
+
+  def execute_sql(sql_command)
+    @log.debug "[ DBFactory::sql_command(...) ]"
+    @log.debug " > sql_command = <#{sql_command}>"
+
+    begin
+      eval("plsql.execute('#{sql_command}')")
+    rescue Exception => e
+      @log.error "[ DBFactory::execute_sql(...) ] ERROR: <#{e.to_s}>"
+      @log.error "Error occurred during execution of SQL command <#{sql_command}>"
+      raise
+    end
+  end
+
+  def cleanup_table(table)
+    @log.debug "[ DBFactory::cleanup_table(...) ]"
+
+    begin
+#      l_delete = @definition[@case]['cleanup']['tables'][tablename]['delete']['condition']
+      l_delete = table.values[0]['delete']['condition']
+      @log.debug "Using delete condition: <#{l_delete}>"
+      l_object_id  = plsql.find_table(table.keys[0])
+      l_object_id.delete("WHERE #{l_delete}")
+    rescue Exception => e
+      @log.error "[ DBFactory::cleanup(...) ] ERROR: <#{e.to_s}>"
+#      @log.warn "Error occured during cleanup procedure on table <#{tablename}> failed in <#{@case}> block"
+#      raise "Error occured during cleanup procedutre on table <#{tablename}> failed in <#{@case}> block"
+      raise "Error occured during cleanup procedutre"
+    end
+  end
+
+  def delete(table)
+    @log.debug "[ DBFactory::delete(...) ]"
+
+    begin
+      if table.values[0].include?('delete')
+        l_delete = table.values[0]['delete']['condition']
+      else
+        l_delete = '1=0'
+      end
+      l_object_id  = plsql.find_table(table.keys[0])
+      l_object_id.delete("WHERE #{l_delete}") unless l_delete.nil?
+    rescue Exception => e
+      @log.error " >> ERROR: <#{e.to_s}>"
+      raise "Failed on delete statement."
+    end
+  end
+
+  def insert(table)
+    @log.debug "[ DBFactory::insert(...) ]"
+
+    begin
+      tablename = table.keys[0]
+      l_data = data(table)
+      l_object_id  = plsql.find_table(tablename)
+      l_object_id.insert(l_data)
+      @log.info("#{l_data.size} records were inserted into <#{tablename}> table")
+    rescue Exception => e
+      raise "[ DBFactory::insert ]: Failed insert data. #{e.to_s}"
+    end
+  end
+
+  def sql_statement(table)
+    @log.debug "[ DBFactory::sql_statement(...) ]"
+
+    begin
+      l_statement = table.values[0]['sql statement']
+      execute_sql(l_statement) unless l_statement.nil?
+    rescue Exception => e
+      @log.error " >> ERROR: <#{e.to_s}>"
+      raise "Failed on SQL statement"
+    end
+  end
+
+  def other_column_data(table)
+    @log.debug "[ DBFactory::other_column_data(...) ]"
+
+    tablename = table.keys[0]
+    begin
+      l_object_id  = plsql.find_table(tablename)
+      l_other_column_data = l_object_id.first || {}
+    rescue Exception => e
+      raise "[ DBFactory::other_column_data ]: #{e.to_s}"
+    end
+
+    return l_other_column_data
+  end
+
+  def defaults(table)
+    @log.debug "[ DBFactory::defaults(...) ]"
+
+    l_other_column_data = other_column_data(table)
+
+    tablename = table.keys[0]
+    l_defaults1 = {}
+    begin
+      @definition['DEFAULTS']['tables'].each { |t|
+        if t.keys[0] == table.keys[0]
+          l_defaults1 = t.values[0] || {}
+          break
+        end
+      }
+#      if l_defaults1 != nil
+#        @log.debug "Loading of defaults for table <#{tablename}> was succesfull in <DEFAULTS> block"
+#      else
+#        l_defaults1 = {}
+#      end
+    rescue Exception => e
+      @log.error "Error: <#{e.to_s}>"
+      @log.warn "Loading of defaults for table <#{tablename}> failed in <DEFAULTS> block"
+    end
+
+    l_defaults2 = {}
+    begin
+      l_defaults2 = table.values[0]['defaults'] || {}
+#      if l_defaults2 != nil
+#        @log.debug "Loading of defaults for table <#{tablename}> was succesfull in <#{@case}> block"
+#      else
+#        l_defaults2 = {}
+#      end
+    rescue Exception => e
+      @log.error "[ DBFactory::defaults(...) ] ERROR: <#{e.to_s}>"
+      @log.warn "Loading of defaults for table <#{tablename}> failed in <#{@case}> block"
+    end
+
+    return(l_other_column_data.merge(l_defaults1).merge(l_defaults2))
+  end
+
+  def data(table)
+    @log.debug "[ DBFactory::data(...) ]"
+
+    table_def = table[table.keys[0]]
+    begin
+      l_data = []
+      l_defaults = defaults(table)
+      l_data_tmp = table_def['data']
+
+      case
+        when l_data_tmp.nil?
+          l_data = []
+        when l_data_tmp[0].instance_of?(Hash)
+          l_data_tmp.collect! { |values|
+            values = l_defaults.merge(values)
+          }
+          l_data = l_data_tmp
+        when l_data_tmp[0].instance_of?(Array)
+          l_columns = table_def['columns']
+          l_data_tmp.each_index { |i|
+            l_data[i] = {}
+            l_data_tmp[i].each_index { |k|
+              l_data[i] = l_data[i].merge({l_columns[k] => l_data_tmp[i][k]})
+            }
+          }
+          l_data.collect! { |values|
+            values = l_defaults.merge(values)
+          }
+      end
+    rescue Exception => e
+      raise "[ DBFactory::data ]: Failed loading of data. #{e.to_s}"
+    end
+
+    # convert FLOAT - otherwise OCI error will be rasied
+    l_data.each_index {|i|
+      l_data[i].each { |k,v|
+        l_data[i][k] = v.instance_of?(Float) ? v.to_d : v
+      }
+    }
+    return l_data
+  end
+
+  def prepare_table(table)
+    @log.debug "[ DBFactory::prepare_table(...) ]"
+    @log.debug ">> table: #{table.keys[0]}"
+
+    begin
+      tablename = table.keys[0]
+      l_object_id  = plsql.find_table(tablename)
+    rescue Exception => e
+      raise "Failed to find table <#{tablename}> in DB"
+    end
+
+    # delete data according to delete condition in file
+    delete(table)
+
+    # execute SQL statement
+    sql_statement(table)
+
+    # insert defined data
+    insert(table)
+
+  end
+
+  def expected_columns(table)
+    l_data_tmp = table.values[0]['expected data']
+    case
+      when l_data_tmp[0].instance_of?(Hash)
+        l_expected_columns = l_data_tmp[0].keys
+      when l_data_tmp[0].instance_of?(Array)
+        l_expected_columns = table.values[0]['columns']
+    end
+    l_expected_columns
+  end
+
+  def expected_data(table, stage = nil)
+    @log.debug "[ DBFactory::expected_data(...) ]"
+    @log.debug " > stage    = <#{stage}>"
+
+    stage ||= 'expected data'
+
+    l_data = []
+    begin
+      l_data_tmp = table.values[0][stage]
+      case
+        when l_data_tmp[0].instance_of?(Hash)
+          l_data = l_data_tmp
+        when l_data_tmp[0].instance_of?(Array)
+          l_columns = table.values[0]['columns']
+#          l_columns = expected_columns(tablename)
+          l_data_tmp.each_index { |i|
+            l_data[i] = {}
+            l_data_tmp[i].each_index { |k|
+              l_data[i] = l_data[i].merge({l_columns[k] => l_data_tmp[i][k]})
+            }
+          }
+      end
+    rescue Exception => e
+      @log.error "[ DBFactory::expected_data(...) ] ERROR: <#{e.to_s}>"
+      raise "Failed to get expected data."
+    end
+
+#    @log.info("There are currently #{l_data.size} records expected in <#{tablename}> table")
+    return l_data
+  end
+
+  def actual_data(table)
+    @log.debug "[ DBFactory::actual_data(...) ]"
+
+    l_object_id  = plsql.find_table(table.keys[0])
+    begin
+      l_filter = table.values[0]['filter'] || '1=1'
+      @log.debug("filter: <#{l_filter}>")
+      l_data = l_object_id.all("WHERE #{l_filter}")
+      l_columns = expected_columns(table)
+      @log.debug "columns: <#{l_columns}>"
+      l_data.each_index { |i|
+        l_data[i].delete_if { |k,v| not l_columns.include?(k) }
+      }
+      l_data.each_index { |i|
+        l_data[i].each { |k,v|
+          if v.instance_of?(String)
+            l_data[i][k] = v.rstrip
+          end
+          if v.instance_of?(BigDecimal)
+            l_data[i][k] = v.to_f
+          end
+        }
+      }
+    rescue Exception => e
+      @log.error "[ DBFactory::actual_data(...) ] ERROR: <#{e.to_s}>"
+#      @log.warn "Loading actual data for table <#{tablename}> failed in <#{@case}> block"
+      raise "Failed to load actual data from DB." #or table <#{tablename}> failed in <#{@case}> block"
+    end
+
+#    @log.info("There are currently #{l_data.size} records in <#{tablename}> table")
+    return l_data
+  end
+
+  def pk_data_split(data, pk)
+    l_split_data = []
+    data.each { |values|
+      l_pk = {}
+      pk.each { |k|
+        l_pk[k] = values[k]
+        values.delete(k)
+      }
+      l_split_data.push({"PK" => l_pk, "DATA" => values})
+    }
+#    puts l_split_data.inspect
+    return l_split_data
+  end
+
+  def get_all_pk(data1, data2)
+    l_all_pks = []
+    data1.each { |v|
+      l_tmp = {"PK" => v["PK"]}
+      l_all_pks.push(l_tmp) unless l_all_pks.include?(l_tmp)
+    }
+    data2.each { |v|
+      l_tmp = {"PK" => v["PK"]}
+      l_all_pks.push(l_tmp) unless l_all_pks.include?(l_tmp)
+    }
+    return l_all_pks #.sort_by { |k| k["PK"] }
+  end
+
+  def check_postconditions_for_table(table, stage = nil)
+    @log.debug "[ DBFactory::check_postconditions_for_table(...) ]"
+    @log.debug " > stage    = <#{stage}>"
+
+    tablename = table.keys[0]
+    l_data = nil
+    begin
+      l_expected_data = expected_data(table, stage)
+      l_actual_data  = actual_data(table)
+
+      if l_expected_data == l_actual_data
+        @log.info("> DBFactory::compare_table(#{tablename}, #{stage}) ... PASS")
+        return true
+      end
+
+      @log.warn "Seems that some differences found when comparing actual and expected data in table <#{tablename}>"
+
+#      l_pk = @definition[@case]['postconditions']['tables'][tablename]['connect keys']
+      l_pk = table.values[0]['connect keys']
+      @log.debug "connect keys: <#{l_pk}>"
+      if l_pk == nil
+        raise "Missing <connect keys> definition"
+      end
+
+      te = pk_data_split(l_expected_data, l_pk) #.sort_by { |v| v.values_at(0) }
+      ta = pk_data_split(l_actual_data, l_pk) #.sort_by { |v| v.values_at(0) }
+#      puts te.inspect
+#      puts ta.inspect
+      d = []
+      get_all_pk(te, ta).each { |k|
+        vei = te.index { |v| v["PK"] == k["PK"] }
+        if vei != nil
+          ve = te[vei]
+          te.delete_at(vei)
+        else
+          ve = {"PK" => {}, "DATA" => {}}
+        end
+
+#        ve = te.detect { |v| v["PK"] == k["PK"] }
+#        if ve == nil
+#          ve = {"PK" => {}, "DATA" => {}}
+#        end
+        vai = ta.index { |v| v["PK"] == k["PK"] }
+        if vai != nil
+          va = ta[vai]
+          ta.delete_at(vai)
+        else
+          va = {"PK" => {}, "DATA" => {}}
+        end
+#        va = ta.detect { |v| v["PK"] == k["PK"] }
+#        if va == nil
+#          va = {"PK" => {}, "DATA" => {}}
+#        end
+        diff = va["DATA"].diff(ve["DATA"])
+#        puts diff.inspect
+#        d.push({"PK" => k["PK"], "DATA" => diff}) unless diff == {}
+        d.push(k["PK"].merge(diff)) unless diff == {}
+      }
+
+      if d.empty?
+#        puts "l_expected_datasize = <#{l_expected_data.size}>"
+#        puts l_expected_data.inspect
+#        puts "l_actual_data.size = <#{l_actual_data.size}>"
+        @log.info("> DBFactory::compare_table(#{tablename}, #{stage}) ... PASS")
+        return true
+#      return false
+      else
+        if stage.nil?
+          d = {"#{@case}" => {"#{tablename}" => d}}.to_yaml
+        else
+          d = {"#{@case}" => {"#{stage}" => {"#{tablename}" => d}}}.to_yaml
+        end
+        l_diff_file = @cfg['DIFF']['filename_tpl'].gsub('#CASE#',@case)
+        @log.info "Writing differences for table <#{tablename}> for <#{@case}> block into <#{l_diff_file}>"
+        l_fw = File.open(l_diff_file, "a")
+        l_fw.write(d)
+        l_fw.close
+      end
+
+    rescue Exception => e
+      @log.error "[ DBFactory::compare_table(...) ] ERROR: <#{e.to_s}>"
+      @log.warn "Comparison of actual and expected data for table <#{tablename}> failed in <#{@case}> block"
+      raise "Error occurred during comparison if data for table <#{tablename}> in <#{@case}> block"
+    end
+
+    @log.warn("> DBFactory::compare_table(#{tablename}, #{stage}) ... FAIL")
+
+    return false
+  end
+
+end
+
+module DBFactory
+
+  LOG      = "#{ROOT}/log"
+  DEFAULTS = "#{ROOT}/defaults"
+
+  @instance
+
+  def self.load(*args)
+    @instance = DBFactoryClass.new
+    @instance.load(*args)
+  end
+
+  def self.setup(*args)
+    @instance.setup(*args)
+  end
+
+  def self.evaluate(*args)
+    @instance.check_postconditions(*args)
+  end
+
+  def self.flashback(*args)
+    @instance.flashback(*args)
+  end
+
+end

data/lib/db_factory/helpers.rb

@@ -0,0 +1,32 @@
+module PLSQL
+  class Schema
+    # Returns object ID of table object. Examples:
+    #  plsql.find_table('scott.my_table')
+    #  plsql.find_table('scott', 'my_table')
+    def find_table(*args)
+      if args.size == 1
+        table_owner = args[0].split('.')[0].upcase
+        table_name = args[0].split('.')[1].upcase
+      else
+        table_name = args[0]
+        table_owner = args[1]
+      end
+      find_database_object(table_name, table_owner)
+    end
+  end
+end
+
+class Hash
+  # Returns difference between 2 hashes (actual values and expecyted values)
+  # as Hash with "expected" and "actual" keys
+  def diff(other)
+    l_keys = self.keys.concat(other.keys).uniq
+    l_keys.inject({}) do |memo, key|
+      l_expected = other[key] rescue {}
+      unless self[key] == l_expected
+        memo[key] = {"actual" => self[key], "expected" => l_expected}
+      end
+      memo
+    end
+  end
+end

data/lib/db_factory/version.rb

@@ -0,0 +1,3 @@
+module DBFactory #:nodoc:
+  VERSION = File.read(File.dirname(__FILE__)+'/../../VERSION').chomp
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: db-factory
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Stefan Cibiri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-plsql
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: db-factory uses definition files with YAML/ERB syntax to define test
+  data (preconditions) for unit PL/SQL testing and can compare actual data with defined
+  expected data.
+email: stefancibiri@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- History.txt
+- VERSION
+- db-factory.gemspec
+- examples/simple_example_1/Readme.txt
+- examples/simple_example_1/create_objects.sql
+- examples/simple_example_1/simple_example_1.yml
+- examples/simple_example_1/simple_example_1_spec.rb
+- examples/simple_example_1/spec_helper.rb
+- lib/config.yml
+- lib/db-factory.rb
+- lib/db_factory/db_factory.rb
+- lib/db_factory/helpers.rb
+- lib/db_factory/version.rb
+homepage: https://github.com/stci/db-factory
+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.23
+signing_key: 
+specification_version: 3
+summary: Prepare and compare test data for PL/SQL unit testing
+test_files: []