ruby-plsql 0.8.0 → 0.9.0

data/spec/plsql/table_spec.rb

@@ -1,376 +0,0 @@
-require "spec_helper"
-
-describe "Table" do
-  before(:all) do
-    plsql.connect! CONNECTION_PARAMS
-    plsql.connection.autocommit = false
-    plsql.execute <<-SQL
-      CREATE TABLE test_employees (
-        employee_id   NUMBER(15) NOT NULL,
-        first_name    VARCHAR2(50),
-        last_name     VARCHAR(50),
-        hire_date     DATE,
-        created_at    TIMESTAMP,
-        status        VARCHAR2(1) DEFAULT 'N'
-      )
-    SQL
-
-    plsql.execute <<-SQL
-      CREATE OR REPLACE TYPE t_address AS OBJECT (
-        street    VARCHAR2(50),
-        city      VARCHAR2(50),
-        country   VARCHAR2(50)
-      )
-    SQL
-    plsql.execute <<-SQL
-      CREATE OR REPLACE TYPE t_phone AS OBJECT (
-        type            VARCHAR2(10),
-        phone_number    VARCHAR2(50)
-      )
-    SQL
-    plsql.execute <<-SQL
-      CREATE OR REPLACE TYPE t_phones AS VARRAY(10) OF T_PHONE
-    SQL
-    plsql.execute <<-SQL
-      CREATE TABLE test_employees2 (
-        employee_id   NUMBER(15) NOT NULL,
-        first_name    VARCHAR2(50),
-        last_name     VARCHAR(50),
-        hire_date     DATE DEFAULT SYSDATE,
-        address       t_address,
-        phones        t_phones
-      )
-    SQL
-    @employees = (1..10).map do |i|
-      {
-        employee_id: i,
-        first_name: "First #{i}",
-        last_name: "Last #{i}",
-        hire_date: Time.local(2000, 01, i),
-        created_at: Time.local(2000, 01, i, 9, 15, 30, i),
-        status: "A"
-      }
-    end
-    @employees_all_fields = [:employee_id, :first_name, :last_name, :hire_date, :created_at, :status]
-    @employees_all_values = @employees.map { |e| @employees_all_fields.map { |f| e[f] } }
-    @employees_some_fields = [:employee_id, :first_name, :last_name]
-    @employees_some_values = @employees.map { |e| @employees_some_fields.map { |f| e[f] } }
-    @employee_default_values = { hire_date: nil, created_at: nil, status: "N" }
-
-    @employees2 = (1..10).map do |i|
-      {
-        employee_id: i,
-        first_name: "First #{i}",
-        last_name: "Last #{i}",
-        hire_date: Time.local(2000, 01, i),
-        address: { street: "Street #{i}", city: "City #{i}", country: "County #{i}" },
-        phones: [{ type: "mobile", phone_number: "Mobile#{i}" }, { type: "fixed", phone_number: "Fixed#{i}" }]
-      }
-    end
-  end
-
-  after(:all) do
-    plsql.execute "DROP TABLE test_employees"
-    plsql.execute "DROP TABLE test_employees2"
-    plsql.execute "DROP TYPE t_phones"
-    plsql.execute "DROP TYPE t_phone"
-    plsql.execute "DROP TYPE t_address"
-    plsql.logoff
-  end
-
-  after(:each) do
-    plsql.rollback
-  end
-
-  describe "find" do
-
-    it "should find existing table" do
-      expect(PLSQL::Table.find(plsql, :test_employees)).not_to be_nil
-    end
-
-    it "should not find nonexisting table" do
-      expect(PLSQL::Table.find(plsql, :qwerty123456)).to be_nil
-    end
-
-    it "should find existing table in schema" do
-      expect(plsql.test_employees).to be_a(PLSQL::Table)
-    end
-
-  end
-
-  describe "synonym" do
-
-    before(:all) do
-      plsql.execute "CREATE SYNONYM test_employees_synonym FOR hr.test_employees"
-    end
-
-    after(:all) do
-      plsql.execute "DROP SYNONYM test_employees_synonym" rescue nil
-    end
-
-    it "should find synonym to table" do
-      expect(PLSQL::Table.find(plsql, :test_employees_synonym)).not_to be_nil
-    end
-
-    it "should find table using synonym in schema" do
-      expect(plsql.test_employees_synonym).to be_a(PLSQL::Table)
-    end
-
-  end
-
-  describe "public synonym" do
-
-    it "should find public synonym to table" do
-      expect(PLSQL::Table.find(plsql, :dual)).not_to be_nil
-    end
-
-    it "should find table using public synonym in schema" do
-      expect(plsql.dual).to be_a(PLSQL::Table)
-    end
-
-  end
-
-  describe "columns" do
-
-    it "should get column names for table" do
-      expect(plsql.test_employees.column_names).to eq(@employees_all_fields)
-    end
-
-    it "should get columns metadata for table" do
-      expect(plsql.test_employees.columns).to eq(
-        employee_id: {
-          position: 1, data_type: "NUMBER", data_length: 22, data_precision: 15, data_scale: 0, char_used: nil,
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: false, data_default: nil },
-        first_name: {
-          position: 2, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, char_used: "B",
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
-        last_name: {
-          position: 3, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, char_used: "B",
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
-        hire_date: {
-          position: 4, data_type: "DATE", data_length: 7, data_precision: nil, data_scale: nil, char_used: nil,
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
-        created_at: {
-          position: 5, data_type: "TIMESTAMP", data_length: 11, data_precision: nil, data_scale: 6, char_used: nil,
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
-        status: {
-          position: 6, data_type: "VARCHAR2", data_length: 1, data_precision: nil, data_scale: nil, char_used: "B",
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: "'N'" }
-      )
-    end
-
-    it "should get columns metadata for table with object columns" do
-      expect(plsql.test_employees2.columns).to eq(
-        employee_id: {
-          position: 1, data_type: "NUMBER", data_length: 22, data_precision: 15, data_scale: 0, char_used: nil,
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: false, data_default: nil },
-        first_name: {
-          position: 2, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, char_used: "B",
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
-        last_name: {
-          position: 3, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, char_used: "B",
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
-        hire_date: {
-          position: 4, data_type: "DATE", data_length: 7, data_precision: nil, data_scale: nil, char_used: nil,
-          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: "SYSDATE" },
-        address: {
-          position: 5, data_type: "OBJECT", data_length: nil, data_precision: nil, data_scale: nil,
-          char_used: nil, type_owner: "HR", type_name: "T_ADDRESS", sql_type_name: "HR.T_ADDRESS", nullable: true, data_default: nil },
-        phones: {
-          position: 6, data_type: "TABLE", data_length: nil, data_precision: nil, data_scale: nil, char_used: nil,
-          type_owner: "HR", type_name: "T_PHONES", sql_type_name: "HR.T_PHONES", nullable: true, data_default: nil }
-      )
-    end
-
-  end
-
-  describe "insert" do
-    it "should insert a record in table" do
-      plsql.test_employees.insert @employees.first
-      expect(plsql.test_employees.all).to eq([@employees.first])
-    end
-
-    it "should insert a record in table using partial list of columns" do
-      plsql.test_employees.insert @employees.first.except(:hire_date)
-      expect(plsql.test_employees.all).to eq([@employees.first.merge(hire_date: nil)])
-    end
-
-    it "should insert default value from table definition if value not provided" do
-      plsql.test_employees.insert @employees.first.except(:status)
-      expect(plsql.test_employees.all).to eq([@employees.first.merge(status: "N")])
-    end
-
-    it "should insert array of records in table" do
-      plsql.test_employees.insert @employees
-      expect(plsql.test_employees.all("ORDER BY employee_id")).to eq(@employees)
-    end
-
-    it "should insert a record in table with object types" do
-      plsql.test_employees2.insert @employees2.first
-      expect(plsql.test_employees2.all).to eq([@employees2.first])
-    end
-
-    it "should insert array of records in table with object types" do
-      plsql.test_employees2.insert @employees2
-      expect(plsql.test_employees2.all("ORDER BY employee_id")).to eq(@employees2)
-    end
-
-    it "should insert with case-insensetive table name" do
-      plsql.test_employees.insert @employees.first.map { |k, v| [k.upcase.to_sym, v] }.to_h
-      expect(plsql.test_employees.all).to eq([@employees.first])
-    end
-
-  end
-
-  describe "insert values" do
-    it "should insert a record with array of values" do
-      plsql.test_employees.insert_values @employees_all_values.first
-      expect(plsql.test_employees.all).to eq([@employees.first])
-    end
-
-    it "should insert a record with list of all fields and array of values" do
-      plsql.test_employees.insert_values @employees_all_fields, @employees_all_values.first
-      expect(plsql.test_employees.all).to eq([@employees.first])
-    end
-
-    it "should insert a record with list of some fields and array of values" do
-      plsql.test_employees.insert_values @employees_some_fields, @employees_some_values.first
-      expect(plsql.test_employees.all).to eq([@employees.first.merge(@employee_default_values)])
-    end
-
-    it "should insert many records with array of values" do
-      plsql.test_employees.insert_values *@employees_all_values
-      expect(plsql.test_employees.all).to eq(@employees)
-    end
-
-    it "should insert many records with list of all fields and array of values" do
-      plsql.test_employees.insert_values @employees_all_fields, *@employees_all_values
-      expect(plsql.test_employees.all).to eq(@employees)
-    end
-
-    it "should insert many records with list of some fields and array of values" do
-      plsql.test_employees.insert_values @employees_some_fields, *@employees_some_values
-      expect(plsql.test_employees.all).to eq(@employees.map { |e| e.merge(@employee_default_values) })
-    end
-
-  end
-
-  describe "select" do
-    before(:each) do
-      plsql.test_employees.insert @employees
-    end
-
-    it "should select first record in table" do
-      expect(plsql.test_employees.select(:first, "ORDER BY employee_id")).to eq(@employees.first)
-      expect(plsql.test_employees.first("ORDER BY employee_id")).to eq(@employees.first)
-    end
-
-    it "should select all records in table" do
-      expect(plsql.test_employees.select(:all, "ORDER BY employee_id")).to eq(@employees)
-      expect(plsql.test_employees.all("ORDER BY employee_id")).to eq(@employees)
-      expect(plsql.test_employees.all(order_by: :employee_id)).to eq(@employees)
-    end
-
-    it "should select record in table using WHERE condition" do
-      expect(plsql.test_employees.select(:first, "WHERE employee_id = :1", @employees.first[:employee_id])).to eq(@employees.first)
-      expect(plsql.test_employees.first("WHERE employee_id = :1", @employees.first[:employee_id])).to eq(@employees.first)
-      expect(plsql.test_employees.first(employee_id: @employees.first[:employee_id])).to eq(@employees.first)
-    end
-
-    it "should select records in table using WHERE condition and ORDER BY sorting" do
-      expect(plsql.test_employees.all(employee_id: @employees.first[:employee_id], order_by: :employee_id)).to eq([@employees.first])
-    end
-
-    it "should select record in table using :column => nil condition" do
-      employee = @employees.last.dup
-      employee[:employee_id] = employee[:employee_id] + 1
-      employee[:hire_date] = nil
-      plsql.test_employees.insert employee
-      expect(plsql.test_employees.first("WHERE hire_date IS NULL")).to eq(employee)
-      expect(plsql.test_employees.first(hire_date: nil)).to eq(employee)
-    end
-
-    it "should select record in table using :column => :is_null condition" do
-      employee = @employees.last.dup
-      employee[:employee_id] = employee[:employee_id] + 1
-      employee[:hire_date] = nil
-      plsql.test_employees.insert employee
-      expect(plsql.test_employees.first(hire_date: :is_null)).to eq(employee)
-    end
-
-    it "should select record in table using :column => :is_not_null condition" do
-      employee = @employees.last.dup
-      employee[:employee_id] = employee[:employee_id] + 1
-      employee[:hire_date] = nil
-      plsql.test_employees.insert employee
-      expect(plsql.test_employees.all(hire_date: :is_not_null, order_by: :employee_id)).to eq(@employees)
-    end
-
-    it "should count records in table" do
-      expect(plsql.test_employees.select(:count)).to eq(@employees.size)
-      expect(plsql.test_employees.count).to eq(@employees.size)
-    end
-
-    it "should count records in table using condition" do
-      expect(plsql.test_employees.select(:count, "WHERE employee_id <= :1", @employees[2][:employee_id])).to eq(3)
-      expect(plsql.test_employees.count("WHERE employee_id <= :1", @employees[2][:employee_id])).to eq(3)
-    end
-
-  end
-
-  describe "update" do
-    it "should update a record in table" do
-      employee_id = @employees.first[:employee_id]
-      plsql.test_employees.insert @employees.first
-      plsql.test_employees.update first_name: "Test", where: { employee_id: employee_id }
-      expect(plsql.test_employees.first(employee_id: employee_id)[:first_name]).to eq("Test")
-    end
-
-    it "should update a record in table using String WHERE condition" do
-      employee_id = @employees.first[:employee_id]
-      plsql.test_employees.insert @employees
-      plsql.test_employees.update first_name: "Test", where: "employee_id = #{employee_id}"
-      expect(plsql.test_employees.first(employee_id: employee_id)[:first_name]).to eq("Test")
-      # all other records should not be changed
-      plsql.test_employees.all("WHERE employee_id > :1", employee_id) do |employee|
-        expect(employee[:first_name]).not_to eq("Test")
-      end
-    end
-
-    it "should update all records in table" do
-      plsql.test_employees.insert @employees
-      plsql.test_employees.update first_name: "Test"
-      plsql.test_employees.all do |employee|
-        expect(employee[:first_name]).to eq("Test")
-      end
-    end
-
-    it "should update a record in table with object type" do
-      employee = @employees2[0]
-      employee2 = @employees2[1]
-      plsql.test_employees2.insert employee
-      plsql.test_employees2.update address: employee2[:address], phones: employee2[:phones], where: { employee_id: employee[:employee_id] }
-      updated_employee = plsql.test_employees2.first(employee_id: employee[:employee_id])
-      expect(updated_employee[:address]).to eq(employee2[:address])
-      expect(updated_employee[:phones]).to eq(employee2[:phones])
-    end
-
-  end
-
-  describe "delete" do
-    it "should delete record from table" do
-      employee_id = @employees.first[:employee_id]
-      plsql.test_employees.insert @employees
-      plsql.test_employees.delete employee_id: employee_id
-      expect(plsql.test_employees.first(employee_id: employee_id)).to be_nil
-      expect(plsql.test_employees.all(order_by: :employee_id)).to eq(@employees[1, @employees.size - 1])
-    end
-
-    it "should delete all records from table" do
-      plsql.test_employees.insert @employees
-      plsql.test_employees.delete
-      expect(plsql.test_employees.all).to be_empty
-    end
-  end
-
-end

data/spec/plsql/type_spec.rb

@@ -1,299 +0,0 @@
-require "spec_helper"
-
-describe "Type" do
-  before(:all) do
-    plsql.connection = get_connection
-    plsql.execute "DROP TYPE t_employee" rescue nil
-    plsql.execute "DROP TYPE t_phones" rescue nil
-    plsql.execute "DROP TYPE t_phone" rescue nil
-    plsql.execute <<-SQL
-      CREATE OR REPLACE TYPE t_address AS OBJECT (
-        street    VARCHAR2(50),
-        city      VARCHAR2(50),
-        country   VARCHAR2(50),
-        CONSTRUCTOR FUNCTION t_address(p_full_address VARCHAR2)
-          RETURN SELF AS RESULT,
-        MEMBER FUNCTION display_address(p_separator VARCHAR2 DEFAULT ',') RETURN VARCHAR2,
-        MEMBER FUNCTION display_address(p_uppercase BOOLEAN, p_separator VARCHAR2 DEFAULT ',') RETURN VARCHAR2,
-        MEMBER PROCEDURE set_country(p_country VARCHAR2),
-        MEMBER PROCEDURE set_country2(p_country VARCHAR2, x_display_address OUT VARCHAR2),
-        STATIC FUNCTION create_address(p_full_address VARCHAR2) RETURN t_address
-      );
-    SQL
-    plsql.execute <<-SQL
-      CREATE OR REPLACE TYPE BODY t_address AS
-        CONSTRUCTOR FUNCTION t_address(p_full_address VARCHAR2)
-          RETURN SELF AS RESULT
-        AS
-          l_comma1_pos INTEGER;
-          l_comma2_pos INTEGER;
-        BEGIN
-          l_comma1_pos := INSTR(p_full_address, ',', 1, 1);
-          l_comma2_pos := INSTR(p_full_address, ',', 1, 2);
-          SELF.street := TRIM(SUBSTR(p_full_address, 1, l_comma1_pos - 1));
-          SELF.city := TRIM(SUBSTR(p_full_address, l_comma1_pos+1, l_comma2_pos - l_comma1_pos - 1));
-          SELF.country := TRIM(SUBSTR(p_full_address, l_comma2_pos+1));
-          RETURN;
-        END;
-        MEMBER FUNCTION display_address(p_separator VARCHAR2) RETURN VARCHAR2 IS
-          l_separator VARCHAR2(10) := p_separator;
-        BEGIN
-          IF SUBSTR(l_separator,-1) != ' ' THEN
-            l_separator := l_separator || ' ';
-          END IF;
-          RETURN SELF.street || l_separator || SELF.city || l_separator || SELF.country;
-        END;
-        MEMBER FUNCTION display_address(p_uppercase BOOLEAN, p_separator VARCHAR2) RETURN VARCHAR2 IS
-          l_separator VARCHAR2(10) := p_separator;
-        BEGIN
-          IF p_uppercase THEN
-            RETURN UPPER(SELF.display_address(p_separator));
-          ELSE
-            RETURN SELF.display_address(p_separator);
-          END IF;
-        END;
-        MEMBER PROCEDURE set_country(p_country VARCHAR2) IS
-        BEGIN
-          SELF.country := p_country;
-        END;
-        MEMBER PROCEDURE set_country2(p_country VARCHAR2, x_display_address OUT VARCHAR2) IS
-        BEGIN
-          SELF.country := p_country;
-          x_display_address := SELF.display_address();
-        END;
-        STATIC FUNCTION create_address(p_full_address VARCHAR2) RETURN t_address IS
-        BEGIN
-          RETURN t_address(p_full_address);
-        END;
-      END;
-    SQL
-    plsql.execute <<-SQL
-      CREATE OR REPLACE TYPE t_phone AS OBJECT (
-        type            VARCHAR2(10),
-        phone_number    VARCHAR2(50)
-      )
-    SQL
-    plsql.execute <<-SQL
-      CREATE OR REPLACE TYPE t_phones AS VARRAY(10) OF T_PHONE
-    SQL
-    plsql.execute <<-SQL
-      CREATE OR REPLACE TYPE t_employee AS OBJECT (
-        employee_id   NUMBER(15),
-        first_name    VARCHAR2(50),
-        last_name     VARCHAR(50),
-        hire_date     DATE,
-        address       t_address,
-        phones        t_phones
-      )
-    SQL
-  end
-
-  after(:all) do
-    plsql.execute "DROP TYPE t_employee"
-    plsql.execute "DROP TYPE t_address"
-    plsql.execute "DROP TYPE t_phones"
-    plsql.execute "DROP TYPE t_phone"
-    plsql.logoff
-  end
-
-  after(:each) do
-    plsql.rollback
-  end
-
-  describe "find" do
-
-    it "should find existing type" do
-      expect(PLSQL::Type.find(plsql, :t_employee)).not_to be_nil
-    end
-
-    it "should not find nonexisting type" do
-      expect(PLSQL::Type.find(plsql, :qwerty123456)).to be_nil
-    end
-
-    it "should find existing type in schema" do
-      expect(plsql.t_employee).to be_a(PLSQL::Type)
-    end
-
-  end
-
-  describe "synonym" do
-
-    before(:all) do
-      plsql.execute "CREATE SYNONYM t_employee_synonym FOR hr.t_employee"
-    end
-
-    after(:all) do
-      plsql.execute "DROP SYNONYM t_employee_synonym" rescue nil
-    end
-
-    it "should find synonym to type" do
-      expect(PLSQL::Type.find(plsql, :t_employee_synonym)).not_to be_nil
-    end
-
-    it "should find type using synonym in schema" do
-      expect(plsql.t_employee_synonym).to be_a(PLSQL::Type)
-    end
-
-  end
-
-  describe "public synonym" do
-
-    it "should find public synonym to type" do
-      expect(PLSQL::Type.find(plsql, :xmltype)).not_to be_nil
-    end
-
-    it "should find type using public synonym in schema" do
-      expect(plsql.xmltype).to be_a(PLSQL::Type)
-    end
-
-  end
-
-  describe "typecode" do
-
-    it "should get typecode of object type" do
-      expect(plsql.t_employee.typecode).to eq("OBJECT")
-    end
-
-    it "should get typecode of collection type" do
-      expect(plsql.t_phones.typecode).to eq("COLLECTION")
-    end
-
-  end
-
-  describe "attributes" do
-
-    it "should get attribute names" do
-      expect(plsql.t_employee.attribute_names).to eq([:employee_id, :first_name, :last_name, :hire_date, :address, :phones])
-    end
-
-    it "should get attributes metadata" do
-      expect(plsql.t_employee.attributes).to eq(
-        employee_id:           { position: 1, data_type: "NUMBER", data_length: nil, data_precision: 15, data_scale: 0, type_owner: nil, type_name: nil, sql_type_name: nil },
-        first_name:           { position: 2, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, type_owner: nil, type_name: nil, sql_type_name: nil },
-        last_name:           { position: 3, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, type_owner: nil, type_name: nil, sql_type_name: nil },
-        hire_date:           { position: 4, data_type: "DATE", data_length: nil, data_precision: nil, data_scale: nil, type_owner: nil, type_name: nil, sql_type_name: nil },
-        address:           { position: 5, data_type: "OBJECT", data_length: nil, data_precision: nil, data_scale: nil, type_owner: "HR", type_name: "T_ADDRESS", sql_type_name: "HR.T_ADDRESS" },
-        phones:           { position: 6, data_type: "TABLE", data_length: nil, data_precision: nil, data_scale: nil, type_owner: "HR", type_name: "T_PHONES", sql_type_name: "HR.T_PHONES" }
-      )
-    end
-
-  end
-
-  describe "object instance" do
-    before(:all) do
-      @phone_attributes = { type: "mobile", phone_number: "123456" }
-      @address_attributes = { street: "Street", city: "City", country: "Country" }
-      @full_address = "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{@address_attributes[:country]}"
-    end
-
-    it "should get new object instance using named parameters" do
-      expect(plsql.t_phone(@phone_attributes)).to eq(@phone_attributes)
-    end
-
-    it "should be an ObjectInstance" do
-      expect(plsql.t_phone(@phone_attributes)).to be_a(PLSQL::ObjectInstance)
-    end
-
-    it "should get new object instance using sequential parameters" do
-      expect(plsql.t_phone(@phone_attributes[:type], @phone_attributes[:phone_number])).to eq(@phone_attributes)
-    end
-
-    it "should get new object instance using custom constructor" do
-      expect(plsql.t_address(@full_address)).to eq(@address_attributes)
-      expect(plsql.t_address(p_full_address: @full_address)).to eq(@address_attributes)
-    end
-
-    it "should get new object instance using default constructor when custom constructor exists" do
-      expect(plsql.t_address(@address_attributes)).to eq(@address_attributes)
-      expect(plsql.t_address(@address_attributes[:street], @address_attributes[:city], @address_attributes[:country])).to eq(@address_attributes)
-    end
-
-    it "should get new empty collection of objects instance" do
-      expect(plsql.t_phones.new).to eq([])
-      expect(plsql.t_phones([])).to eq([])
-    end
-
-    it "should get new collection of objects instances" do
-      phone = plsql.t_phone(@phone_attributes)
-      expect(plsql.t_phones([phone, phone])).to eq([phone, phone])
-      expect(plsql.t_phones(phone, phone)).to eq([phone, phone])
-      expect(plsql.t_phones(@phone_attributes, @phone_attributes)).to eq([phone, phone])
-    end
-
-  end
-
-  describe "member procedures" do
-    before(:all) do
-      @address_attributes = { street: "Street", city: "City", country: "Country" }
-      @full_address = "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{@address_attributes[:country]}"
-    end
-
-    it "should call object instance member function without parameters" do
-      expect(plsql.t_address(@address_attributes).display_address).to eq(@full_address)
-    end
-
-    it "should call object instance member function with parameters" do
-      expect(plsql.t_address(@address_attributes).display_address(",")).to eq(@full_address)
-    end
-
-    it "should call object instance member function with named parameters" do
-      expect(plsql.t_address(@address_attributes).display_address(p_separator: ",")).to eq(@full_address)
-    end
-
-    it "should call object overloaded instance member function" do
-      expect(plsql.t_address(@address_attributes).display_address(true)).to eq(@full_address.upcase)
-      expect(plsql.t_address(@address_attributes).display_address(true, ",")).to eq(@full_address.upcase)
-    end
-
-    it "should call object instance member function with explicit first SELF parameter" do
-      expect(plsql.t_address.display_address(@address_attributes, ",")).to eq(@full_address)
-    end
-
-    it "should call object instance member function with explicit named SELF parameter" do
-      expect(plsql.t_address.display_address(self: @address_attributes, p_separator: ",")).to eq(@full_address)
-    end
-
-    it "should call object instance member procedure" do
-      other_country = "Other"
-      expect(plsql.t_address(@address_attributes).set_country(other_country)).to eq(@address_attributes.merge(country: other_country))
-    end
-
-    it "should call object instance member procedure with output parameters" do
-      other_country = "Other"
-      expect(plsql.t_address(@address_attributes).set_country2(other_country)).to eq(
-        [@address_attributes.merge(country: other_country),
-        { x_display_address: "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{other_country}" }]
-      )
-    end
-
-    it "should raise error if invalid member procedure is called" do
-      expect do
-        plsql.t_address(@address_attributes).invalid_procedure
-      end.to raise_error(ArgumentError)
-    end
-
-  end
-
-  describe "static procedures" do
-    before(:all) do
-      @address_attributes = { street: "Street", city: "City", country: "Country" }
-      @full_address = "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{@address_attributes[:country]}"
-    end
-
-    it "should call object type static function" do
-      expect(plsql.t_address.create_address(@full_address)).to eq(@address_attributes)
-    end
-
-    it "should call object type static function with named parameters" do
-      expect(plsql.t_address.create_address(p_full_address: @full_address)).to eq(@address_attributes)
-    end
-
-    it "should raise error if invalid static procedure is called" do
-      expect do
-        plsql.t_address.invalid_procedure
-      end.to raise_error(ArgumentError)
-    end
-
-  end
-
-end