ruby-plsql-spec 0.1.0

data/examples/spec/award_bonus_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+# load 'award_bonus' procedure into the database
+require 'award_bonus'
+
+describe "Award bonus" do
+  include EmployeeFactory
+
+  [ [1000,  1234.55,  0.10,   1123.46],
+    [nil,   1234.56,  0.10,   123.46],
+    [1000,  1234.54,  0.10,   1123.45]
+  ].each do |salary, sales_amt, commission_pct, result|
+    it "should calculate base salary #{salary.inspect} + sales amount #{sales_amt} * commission percentage #{commission_pct} = salary #{result.inspect}" do
+      employee = create_employee(
+        :commission_pct => commission_pct,
+        :salary => salary
+      )
+      plsql.award_bonus(employee[:employee_id], sales_amt)
+      get_employee(employee[:employee_id])[:salary].should == result
+    end
+  end
+
+  it "should raise ORA-06510 exception if commission percentage is missing" do
+    salary, sales_amt, commission_pct = 1000,  1234.55,  NULL
+    employee = create_employee(
+      :commission_pct => commission_pct,
+      :salary => salary
+    )
+    lambda {
+      plsql.award_bonus(employee[:employee_id], sales_amt)
+    }.should raise_error(/ORA-06510/)
+  end
+
+end
+

data/examples/spec/betwnstr_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+# load 'betwnstr' procedure into the database
+require "betwnstr"
+
+describe "Between string" do
+  it "should be correct in normal case" do
+    plsql.betwnstr('abcdefg', 2, 5).should == 'bcde'
+  end
+
+  it "should be correct with zero start value" do
+    plsql.betwnstr('abcdefg', 0, 5).should == 'abcde'
+  end
+
+  it "should be correct with way big end value" do
+    plsql.betwnstr('abcdefg', 5, 500).should == 'efg'
+  end
+
+  it "should be correct with NULL string" do
+    plsql.betwnstr(NULL, 5, 500).should == NULL
+  end
+
+end
+

data/examples/spec/database.yml

@@ -0,0 +1,16 @@
+# Change default connection username, password and database.
+# Specify also host and port if not using tnsnames.ora connection.
+default:
+  username: hr
+  password: hr
+  database: orcl
+  # host: localhost
+  # port: 1521
+
+# Add other connection if needed.
+# You can access them with plsql(:other) where :other is connection name specified below.
+
+# other:
+#   username: scott
+#   password: tiger
+#   database: xe

data/examples/spec/factories/employee_factory.rb

@@ -0,0 +1,23 @@
+module EmployeeFactory
+  # Creates new employee with valid field values.
+  # Pass in parameters only field values that you want to override.
+  def create_employee(params)
+    employee = {
+      :employee_id => plsql.employees2_seq.nextval,
+      :last_name => 'Last',
+      :email => 'last@example.com',
+      :hire_date => Date.today,
+      :job_id => plsql.jobs.first[:job_id],
+      :commission_pct => nil,
+      :salary => nil
+    }.merge(params)
+    plsql.employees2.insert employee
+    get_employee employee[:employee_id]
+  end
+
+  # Select employee by primary key
+  def get_employee(employee_id)
+    plsql.employees2.first :employee_id => employee_id
+  end
+
+end

data/examples/spec/helpers/inspect_helpers.rb

@@ -0,0 +1,17 @@
+# As ruby-plsql returns NUMBER values as BigDecimal values in Ruby then
+# change format how they are by default displayed
+BigDecimal.class_eval do
+  def inspect
+    to_s('F')
+  end
+end
+
+# As ruby-plsql returns NULL as Ruby nil then change nil.inspect to return 'NULL'
+NilClass.class_eval do
+  def inspect
+    'NULL'
+  end
+end
+
+# NULL looks more like SQL NULL than nil
+NULL = nil

data/examples/spec/helpers/oracle_ebs_helpers.rb

@@ -0,0 +1,32 @@
+# initialize Oracle E-Business Suite session with specified user and responsibility
+def init_ebs_user(params={})
+  # replace with default user name and responsibility and then it will not be necessary
+  # to specify default value as parameter
+  params = {
+      :user_name => "default user name",
+      :responsibility_name => "default responsibility"
+     }.merge(params)
+
+  row = plsql.select(:first, "SELECT usr.user_name, res.responsibility_name, usr.user_id,
+                       urg.responsibility_id, urg.responsibility_application_id resp_appl_id
+                  FROM apps.fnd_user_resp_groups urg,
+                       applsys.fnd_user usr,
+                       fnd_responsibility_vl res
+                 WHERE usr.user_name = :user_name
+                   AND res.responsibility_name = :responsibility_name
+                   AND urg.user_id = usr.user_id
+                   AND res.responsibility_id = urg.responsibility_id",
+                   params[:user_name], params[:responsibility_name])
+
+  raise ArgumentError, "Wrong user name or responsibility name" unless row
+
+  plsql.fnd_global.apps_initialize(
+        :user_id => row[:user_id], 
+        :resp_id => row[:responsibility_id], 
+        :resp_appl_id => row[:resp_appl_id]
+        )
+
+  # uncomment if logging to dbms_output is necessary
+  # plsql.dbms_output.put_line("Initialized " + params[:user_name] + " / " + params[:responsibility_name])
+
+end

data/examples/spec/helpers/time_helpers.rb

@@ -0,0 +1,5 @@
+# return current date with time 00:00:00
+def Time.today
+  t = Time.now
+  Time.local(t.year, t.month, t.day)
+end unless Time.respond_to?(:today)

data/examples/spec/oracle_ebs_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe "Oracle E-Business Suite" do
+  before(:all) do
+    # @old_connection = plsql.connection
+    # plsql.connect! "APPS", "APPS", "VIS"
+    @user_name = "OPERATIONS"
+    @responsibility_name = "System Administrator"
+  end
+
+  after(:all) do
+    # plsql.connection = @old_connection
+  end
+
+  if plsql.schema_name == 'APPS'
+
+    describe "Session initialization" do
+      it "should initialize session with valid user and responsibility" do
+        lambda {
+          init_ebs_user(:user_name => @user_name, :responsibility_name => @responsibility_name)
+        }.should_not raise_error
+      end
+
+      it "should raise error with invalid user" do
+        lambda {
+          init_ebs_user(:user_name => "INVALID", :responsibility_name => @responsibility_name)
+        }.should raise_error(/Wrong user name or responsibility name/)
+      end
+
+      it "should raise error with invalid responsibility" do
+        lambda {
+          init_ebs_user(:user_name => @user_name, :responsibility_name => "INVALID")
+        }.should raise_error(/Wrong user name or responsibility name/)
+      end
+
+      it "should raise error with default username and responsibility parameters" do
+        lambda {
+          init_ebs_user
+        }.should raise_error(/Wrong user name or responsibility name/)
+      end
+
+    end
+
+    describe "Session information" do
+      before(:all) do
+        init_ebs_user(:user_name => @user_name, :responsibility_name => @responsibility_name)
+      end
+
+      it "should return user name" do
+        plsql.fnd_global.user_name.should == @user_name
+      end
+
+      it "should return responsibility name" do
+        plsql.fnd_global.resp_name.should == @responsibility_name
+      end
+
+    end
+
+  end
+
+end

data/examples/spec/remove_rooms_by_name_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+require 'remove_rooms_by_name'
+
+describe "Remove rooms by name" do
+  before(:all) do
+    plsql.rooms.insert_values(
+      [:room_key, :name],
+      [1, 'Dining Room'],
+      [2, 'Living Room'],
+      [3, 'Office'],
+      [4, 'Bathroom'],
+      [5, 'Bedroom']
+    )
+    plsql.room_contents.insert_values(
+      [:contents_key, :room_key, :name],
+      [1, 1, 'Table'],
+      [2, 1, 'Hutch'],
+      [3, 1, 'Chair'],
+      [4, 2, 'Sofa'],
+      [5, 2, 'Lamp'],
+      [6, 3, 'Desk'],
+      [7, 3, 'Chair'],
+      [8, 3, 'Computer'],
+      [9, 3, 'Whiteboard']
+    )
+  end
+
+  it "should remove a room without furniture" do
+    rooms_without_b = plsql.rooms.all("WHERE name NOT LIKE 'B%'")
+    plsql.remove_rooms_by_name('B%')
+    plsql.rooms.all.should == rooms_without_b
+  end
+
+  it "should not remove a room with furniture" do
+    lambda {
+      lambda {
+        plsql.remove_rooms_by_name('Living Room')
+      }.should raise_error(/ORA-02292/)
+    }.should_not change { plsql.rooms.all }
+  end
+
+  it "should raise exception when NULL value passed" do
+    lambda {
+      lambda {
+        plsql.remove_rooms_by_name(NULL)
+      }.should raise_error(/program error/)
+    }.should_not change { plsql.rooms.all }
+  end
+
+end

data/examples/spec/spec_helper.rb

@@ -0,0 +1,78 @@
+require "rubygems"
+require "ruby-plsql-spec"
+require "yaml"
+
+# create all connections specified in database.yml file
+database_config_file = File.expand_path('../database.yml', __FILE__)
+database_config = YAML.load(File.read(database_config_file))
+database_config = {} unless database_config.is_a?(Hash)
+database_connections = database_config.keys.map{|k| k.to_sym}
+
+database_config.each do |name, params|
+  # change all keys to symbols
+  name = name.to_sym
+  symbol_params = Hash[*params.map{|k,v| [k.to_sym, v]}.flatten]
+
+  plsql(name).connect! symbol_params
+
+  # Set autocommit to false so that automatic commits after each statement are _not_ performed
+  plsql(name).connection.autocommit = false
+  # reduce network traffic in case of large resultsets
+  plsql(name).connection.prefetch_rows = 100
+  # log DBMS_OUTPUT to standard output
+  if ENV['PLSQL_DBMS_OUTPUT']
+    plsql(name).dbms_output_stream = STDOUT
+  end
+
+  # start code coverage collection
+  if ENV['PLSQL_COVERAGE']
+    PLSQL::Coverage.start(name)
+  end
+end
+
+# Do logoff when exiting to ensure that session temporary tables
+# (used when calling procedures with table types defined in packages)
+at_exit do
+  database_connections.each do |name|
+    if ENV['PLSQL_COVERAGE']
+      PLSQL::Coverage.stop(name)
+      coverage_directory = name == :default ? ENV['PLSQL_COVERAGE'] : "#{ENV['PLSQL_COVERAGE']}/#{name}"
+      options = {:directory => coverage_directory}
+      options[:ignore_schemas] = ENV['PLSQL_COVERAGE_IGNORE_SCHEMAS'].split(',') if ENV['PLSQL_COVERAGE_IGNORE_SCHEMAS']
+      options[:like] = ENV['PLSQL_COVERAGE_LIKE'].split(',') if ENV['PLSQL_COVERAGE_LIKE']
+      PLSQL::Coverage.report name, options
+      PLSQL::Coverage.cleanup name
+    end
+    plsql(name).logoff
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.before(:each) do
+    database_connections.each do |name|
+      plsql(name).savepoint "before_each"
+    end
+  end
+  config.after(:each) do
+    # Always perform rollback to savepoint after each test
+    database_connections.each do |name|
+      plsql(name).rollback_to "before_each"
+    end
+  end
+  config.after(:all) do
+    # Always perform rollback after each describe block
+    database_connections.each do |name|
+      plsql(name).rollback
+    end
+  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}
+
+# If necessary add source directory to load path where PL/SQL 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/examples/spec/what_is_profiled_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+require 'what_is_profiled'
+
+describe "what is profiled" do
+  it "should run driver" do
+    lambda {
+      plsql.what_is_profiled.driver
+    }.should_not raise_error
+  end
+  
+end

data/lib/plsql/coverage.rb

@@ -0,0 +1,262 @@
+module PLSQL
+  class Coverage
+    @@coverages = {}
+
+    attr_accessor :directory
+
+    # used in tests to reset coverages cache
+    def self.reset_cache
+      @@coverages = {}
+    end
+
+    def self.start(connection_alias = nil)
+      find_or_new(connection_alias).start
+    end
+
+    def initialize(connection_alias)
+      @connection_alias = connection_alias
+    end
+
+    def start
+      # ignore repeated invocation
+      return false if @started
+      create_profiler_tables
+      result = plsql(@connection_alias).dbms_profiler.start_profiler(
+        :run_comment => "ruby-plsql-spec #{Time.now.xmlschema}",
+        :run_number => nil
+      )
+      @run_number = result[1][:run_number]
+      @coverages = nil
+      @started = true
+    end
+
+    def self.stop(connection_alias = nil)
+      find_or_new(connection_alias).stop
+    end
+
+    def stop
+      # ignore repeated invocation
+      return false unless @started
+      plsql(@connection_alias).dbms_profiler.stop_profiler
+      @started = false
+      true
+    end
+
+    def self.cleanup(connection_alias = nil)
+      find(connection_alias).cleanup
+    end
+
+    def cleanup
+      return false if @started
+      drop_or_delete_profiler_tables
+      true
+    end
+
+    def self.find(connection_alias = nil)
+      connection_alias ||= :default
+      @@coverages[connection_alias]
+    end
+
+    def self.report(connection_alias = nil, options = {})
+      # if first parameter is Hash then consider it as options and use default connection
+      if connection_alias.is_a?(Hash)
+        options = connection_alias
+        connection_alias = nil
+      end
+      find(connection_alias).report(options)
+    end
+
+    def report(options={})
+      # prevent repeated invocation after coverage is reported
+      # return if @coverages
+
+      @directory = options.delete(:directory)
+      coverage_data(options)
+      create_static_files
+      read_templates
+
+      # Loop through each database object, evaluating it along with the template
+      @coverage_data.keys.sort.each do |schema|
+        @coverage_data[schema].keys.sort.each do |object|
+          details_report(schema, object)
+        end
+      end
+
+      index_report
+      true
+    end
+
+    def coverage_data(options={})
+      quoted_ignore_schemas = if options[:ignore_schemas]
+        options[:ignore_schemas].map{|schema| quote_condition_string(schema)}
+      else
+        %w('SYS')
+      end
+      quoted_ignore_schemas << "'<anonymous>'"
+      like_condition = if options[:like]
+        'AND ((' << Array(options[:like]).map do |like|
+          like_schema, like_object = like.split('.')
+          condition = "u.unit_owner LIKE #{quote_condition_string(like_schema)}"
+          condition << " AND u.unit_name LIKE #{quote_condition_string(like_object)}" if like_object
+        end.join(') OR (') << '))'
+      else
+        nil
+      end
+      data = {}
+      rows = plsql(@connection_alias).select_all <<-EOS
+        SELECT u.unit_owner, u.unit_name, d.line# line_number, d.total_occur
+        FROM plsql_profiler_units u, plsql_profiler_data d
+        WHERE u.runid = #{@run_number}
+          AND u.unit_owner NOT IN (#{quoted_ignore_schemas.join(',')})
+          AND u.runid = d.runid
+          AND u.unit_number = d.unit_number
+          #{like_condition}
+        ORDER BY u.unit_owner, u.unit_name, d.line#
+      EOS
+      rows.each do |row|
+        unit_owner, unit_name, line_number, total_occur = row
+        data[unit_owner] ||= {}
+        data[unit_owner][unit_name] ||= {}
+        data[unit_owner][unit_name][line_number] = total_occur
+      end
+      @coverage_data = data
+    end
+
+    private
+
+    def self.find_or_new(connection_alias) #:nodoc:
+      connection_alias ||= :default
+      if @@coverages[connection_alias]
+        @@coverages[connection_alias]
+      else
+        @@coverages[connection_alias] = self.new(connection_alias)
+      end
+    end
+
+    def create_profiler_tables
+      unless PLSQL::Table.find(plsql(@connection_alias), 'plsql_profiler_data')
+        proftab_file = File.expand_path('../coverage/proftab.sql', __FILE__)
+        File.read(proftab_file).split(";\n").each do |sql|
+          if sql =~ /^drop/i
+            plsql(@connection_alias).execute sql rescue nil
+          elsif sql =~ /^(create|comment)/i
+            plsql(@connection_alias).execute sql
+          end
+        end
+        @created_profiler_tables = true
+      end
+    end
+
+    def drop_or_delete_profiler_tables
+      if @created_profiler_tables
+        %w(plsql_profiler_data plsql_profiler_units plsql_profiler_runs).each do |table|
+          plsql(@connection_alias).execute "DROP TABLE #{table} CASCADE CONSTRAINTS"
+        end
+        plsql(@connection_alias).execute "DROP SEQUENCE plsql_profiler_runnumber"
+      else @run_number
+        plsql(@connection_alias).execute <<-SQL, @run_number
+          DECLARE
+            PRAGMA AUTONOMOUS_TRANSACTION;
+            v_runid BINARY_INTEGER := :runid;
+          BEGIN
+            DELETE FROM plsql_profiler_data WHERE runid = v_runid;
+            DELETE FROM plsql_profiler_units WHERE runid = v_runid;
+            DELETE FROM plsql_profiler_runs WHERE runid = v_runid;
+            COMMIT;
+          END;
+        SQL
+      end
+    end
+
+    def quote_condition_string(string)
+      "'#{string.to_s.upcase.gsub(/[^\w\d\$\%\_]/,'')}'"
+    end
+
+    def create_static_files
+      FileUtils.mkdir_p("#{@directory}")
+      %w(coverage.css jquery.min.js jquery.tablesorter.min.js rcov.js).each do |file|
+        FileUtils.cp File.expand_path("../coverage/#{file}", __FILE__), "#{@directory}/#{file}"
+      end
+    end
+
+    def read_templates
+      %w(details table_line index).each do |template|
+        template_erb = File.read(File.expand_path("../coverage/#{template}.html.erb", __FILE__))
+        instance_variable_set("@#{template}_template", ERB.new(template_erb, nil, '><'))
+      end
+
+      @table_lines = []
+      @total_lines = @analyzed_lines = @executed_lines = 0
+    end
+
+    def details_report(schema, object)
+      source = plsql(@connection_alias).select_all <<-EOS, schema, object
+        SELECT s.line, s.text
+        FROM all_source s
+        WHERE s.owner = :owner
+          AND s.name = :name
+          AND s.type NOT IN ('PACKAGE')
+        ORDER BY s.line
+      EOS
+      coverage = (@coverage_data[schema]||{})[object]||{}
+
+      total_lines = source.length
+      # return if no access to source of database object
+      # or if package body is wrapped
+      return if total_lines == 0 || source[0][1] =~ /^\s*PACKAGE BODY .* WRAPPED/i
+
+      # sometimes first PROCEDURE or FUNCTION line is reported as not executed, force ignoring it
+      source.each do |line, text|
+        if text =~ /^\s*(PROCEDURE|FUNCTION)/ && coverage[line] == 0
+          coverage.delete(line)
+        end
+      end
+
+      @total_lines += total_lines
+      analyzed_lines = executed_lines = 0
+      coverage.each do |line, value|
+        analyzed_lines += 1
+        executed_lines += 1 if value > 0
+      end
+      @analyzed_lines += analyzed_lines
+      @executed_lines += executed_lines
+      total_coverage = (total_lines - analyzed_lines + executed_lines).to_f / total_lines * 100
+      code_coverage = analyzed_lines > 0 ? executed_lines.to_f / analyzed_lines * 100 : 0
+
+      file_name = "#{schema}-#{object}.html"
+      object_name = "#{schema}.#{object}"
+
+      table_line_html = @table_line_template.result binding
+      @table_lines << table_line_html
+      html = @details_template.result binding
+
+      File.open("#{@directory}/#{file_name}", "w") do |file|
+        file.write html
+      end
+    end
+
+    def index_report
+      schemas = @coverage_data.keys.sort
+      table_lines_html = @table_lines.join("\n")
+
+      total_lines, analyzed_lines, executed_lines = @total_lines, @analyzed_lines, @executed_lines
+      # return if no access to source of database objects
+      return if total_lines == 0
+
+      total_coverage = (total_lines - analyzed_lines + executed_lines).to_f / total_lines * 100
+      code_coverage = analyzed_lines > 0 ? executed_lines.to_f / analyzed_lines * 100 : 0
+
+      schema = file_name = nil
+      object_name = 'TOTAL'
+
+      table_footer_html = @table_line_template.result binding
+
+      html = @index_template.result binding
+
+      File.open("#{@directory}/index.html", "w") do |file|
+        file.write html
+      end
+    end
+
+  end
+end