Fixed issues with framework accessing wrong tables when running self-…

…test. the TMP table for coverage is now always accessed from package with authid DEFINER.
utPLSQL · Pazus · Aug 21, 2017 · Jul 21, 2017 · Jul 22, 2017 · Jul 23, 2017
commit 41b484990dd38aa667d625f06be64c03c660bb61
diff --git a/source/core/coverage/ut_coverage.pkb b/source/core/coverage/ut_coverage.pkb
@@ -30,7 +30,7 @@ create or replace package body ut_coverage is
   -- The subquery is optimized by:
   -- - COALESCE function -> it will execute only for TRIGGERS
   -- - scalar subquery cache -> it will only execute once for one trigger source code.
-  function get_populate_sources_tmp_sql(a_coverage_options ut_coverage_options) return varchar2 is
+  function get_cov_sources_sql(a_coverage_options ut_coverage_options) return varchar2 is
     l_result varchar2(32767);
     l_full_name varchar2(100);
     l_view_name      varchar2(200) := ut_metadata.get_dba_view('dba_source');
@@ -41,10 +41,9 @@ create or replace package body ut_coverage is
       l_full_name := 'lower(s.owner||''.''||s.name)';
     end if;
     l_result := '
-      insert /*+ append */ into ut_coverage_sources_tmp(full_name,owner,name,line,text, to_be_skipped)
-      select *
+      select full_name, owner, name, line, to_be_skipped, text
         from (
-          select '||l_full_name||q'[,
+          select '||l_full_name||q'[ as full_name,
                  s.owner,
                  s.name,
                  s.line -
@@ -101,26 +100,46 @@ create or replace package body ut_coverage is
     return l_result;
   end;
 
-  function is_tmp_table_populated return boolean is
-    l_result integer;
+  function get_cov_sources_cursor(a_coverage_options ut_coverage_options) return sys_refcursor is
+    l_cursor        sys_refcursor;
+    l_skip_objects  ut_object_names;
+    l_schema_names  ut_varchar2_rows;
+    l_sql           varchar2(32767);
   begin
-    select 1 into l_result from ut_coverage_sources_tmp where rownum = 1;
-    return (l_result = 1);
-  exception
-    when no_data_found then
-      return false;
+    l_schema_names := coalesce(a_coverage_options.schema_names, ut_varchar2_rows(sys_context('USERENV','CURRENT_SCHEMA')));
+    if not ut_coverage_helper.is_develop_mode() then
+      --skip all the utplsql framework objects and all the unit test packages that could potentially be reported by coverage.
+      l_skip_objects := ut_utils.get_utplsql_objects_list() multiset union all coalesce(a_coverage_options.exclude_objects, ut_object_names());
+    end if;
+    l_sql := get_cov_sources_sql(a_coverage_options);
+    if a_coverage_options.file_mappings is not empty then
+      open l_cursor for l_sql using a_coverage_options.file_mappings, l_skip_objects, a_coverage_options.include_objects;
+    else
+      open l_cursor for l_sql using l_schema_names, l_skip_objects, a_coverage_options.include_objects;
+    end if;
+    return l_cursor;
   end;
 
-  procedure populate_tmp_table(a_coverage_options ut_coverage_options, a_skipped_objects ut_object_names) is
+  procedure populate_tmp_table(a_coverage_options ut_coverage_options) is
     pragma autonomous_transaction;
-    l_schema_names     ut_varchar2_rows;
+    l_cov_sources_crsr sys_refcursor;
+    l_cov_sources_data ut_coverage_helper.t_coverage_sources_tmp_rows;
   begin
-    delete from ut_coverage_sources_tmp;
-    l_schema_names := coalesce(a_coverage_options.schema_names, ut_varchar2_rows(sys_context('USERENV','CURRENT_SCHEMA')));
-    if a_coverage_options.file_mappings is not empty then
-      execute immediate get_populate_sources_tmp_sql(a_coverage_options) using a_coverage_options.file_mappings, a_skipped_objects, a_coverage_options.include_objects;
-    else
-      execute immediate get_populate_sources_tmp_sql(a_coverage_options) using l_schema_names, a_skipped_objects, a_coverage_options.include_objects;
+
+    if not ut_coverage_helper.is_tmp_table_populated() or ut_coverage_helper.is_develop_mode() then
+      ut_coverage_helper.cleanup_tmp_table();
+
+      l_cov_sources_crsr := get_cov_sources_cursor(a_coverage_options);
+
+      loop
+        fetch l_cov_sources_crsr bulk collect into l_cov_sources_data limit 1000;
+
+        ut_coverage_helper.insert_into_tmp_table(l_cov_sources_data);
+
+        exit when l_cov_sources_crsr%notfound;
+      end loop;
+
+      close l_cov_sources_crsr;
     end if;
     commit;
   end;
@@ -159,94 +178,80 @@ create or replace package body ut_coverage is
     ut_coverage_helper.coverage_stop_develop();
   end;
 
-  function get_lines_to_skip(a_object_owner varchar2, a_object_name varchar2) return t_source_lines is
-    l_result    t_source_lines;
-  begin
-    select line
-      bulk collect into l_result
-      from ut_coverage_sources_tmp o
-     where to_be_skipped = 'Y'
-       and o.owner = a_object_owner
-       and o.name = a_object_name;
-
-    return l_result;
-  end;
-
   function get_coverage_data(a_coverage_options ut_coverage_options) return t_coverage is
-    l_line_calls       ut_coverage_helper.unit_line_calls;
-    l_result           t_coverage;
-    l_new_unit         t_unit_coverage;
-    l_skipped_objects  ut_object_names := ut_object_names();
-    l_lines_to_skip    t_source_lines;
-    line_no            binary_integer;
+    l_line_calls          ut_coverage_helper.t_unit_line_calls;
+    l_result              t_coverage;
+    l_new_unit            t_unit_coverage;
+    line_no               binary_integer;
+    l_source_objects_crsr ut_coverage_helper.t_tmp_table_objects_crsr;
+    l_source_object       ut_coverage_helper.t_tmp_table_object;
   begin
 
-    if not ut_coverage_helper.is_develop_mode() then
-      --skip all the utplsql framework objects and all the unit test packages that could potentially be reported by coverage.
-      l_skipped_objects := ut_utils.get_utplsql_objects_list() multiset union all coalesce(a_coverage_options.exclude_objects, ut_object_names());
-    end if;
-
     --prepare global temp table with sources
-    if not is_tmp_table_populated() or ut_coverage_helper.is_develop_mode() then
-      populate_tmp_table(a_coverage_options, l_skipped_objects);
-    end if;
+    populate_tmp_table(a_coverage_options);
 
-    for src_object in (
-      select o.owner, o.name, o.full_name, max(o.line) lines_count
-        from ut_coverage_sources_tmp o
-       group by o.owner, o.name, o.full_name
-    ) loop
-
-      l_lines_to_skip := get_lines_to_skip( src_object.owner, src_object.name );
+    l_source_objects_crsr := ut_coverage_helper.get_tmp_table_objects_cursor();
+    loop
+      fetch l_source_objects_crsr into l_source_object;
+      exit when l_source_objects_crsr%notfound;
 
       --get coverage data
-      l_line_calls := ut_coverage_helper.get_raw_coverage_data( src_object.owner, src_object.name );
+      l_line_calls := ut_coverage_helper.get_raw_coverage_data( l_source_object.owner, l_source_object.name );
 
       --if there is coverage, we need to filter out the garbage (badly indicated data from dbms_profiler)
       if l_line_calls.count > 0 then
         --remove lines that should not be indicted as meaningful
-        for i in 1 .. l_lines_to_skip.count loop
-          l_line_calls.delete(l_lines_to_skip(i));
+        for i in 1 .. l_source_object.to_be_skipped_list.count loop
+          if l_source_object.to_be_skipped_list(i) is not null then
+            l_line_calls.delete(l_source_object.to_be_skipped_list(i));
+          end if;
         end loop;
       end if;
 
       --if there are no file mappings or object was actually captured by profiler
       if a_coverage_options.file_mappings is null or l_line_calls.count > 0 then
-        if not l_result.objects.exists(src_object.full_name) then
-          l_result.objects(src_object.full_name) := l_new_unit;
-          l_result.objects(src_object.full_name).owner := src_object.owner;
-          l_result.objects(src_object.full_name).name  := src_object.name;
+
+        --populate total stats
+        l_result.total_lines := l_result.total_lines + l_source_object.lines_count;
+
+        --populate object level coverage stats
+        if not l_result.objects.exists(l_source_object.full_name) then
+          l_result.objects(l_source_object.full_name) := l_new_unit;
+          l_result.objects(l_source_object.full_name).owner := l_source_object.owner;
+          l_result.objects(l_source_object.full_name).name  := l_source_object.name;
+          l_result.objects(l_source_object.full_name).total_lines := l_source_object.lines_count;
         end if;
-        l_result.total_lines := l_result.total_lines + src_object.lines_count;
-        l_result.objects(src_object.full_name).total_lines := src_object.lines_count;
         --map to results
         line_no := l_line_calls.first;
         if line_no is null then
-          l_result.uncovered_lines := l_result.uncovered_lines + src_object.lines_count;
-          l_result.objects(src_object.full_name).uncovered_lines := src_object.lines_count;
+          l_result.uncovered_lines := l_result.uncovered_lines + l_source_object.lines_count;
+          l_result.objects(l_source_object.full_name).uncovered_lines := l_source_object.lines_count;
         else
           loop
             exit when line_no is null;
 
             if l_line_calls(line_no) > 0 then
+              --total stats
               l_result.covered_lines := l_result.covered_lines + 1;
               l_result.executions := l_result.executions + l_line_calls(line_no);
-              l_result.objects(src_object.full_name).covered_lines := l_result.objects(src_object.full_name).covered_lines + 1;
-              l_result.objects(src_object.full_name).executions := l_result.objects(src_object.full_name).executions + l_line_calls(line_no);
+              --object level stats
+              l_result.objects(l_source_object.full_name).covered_lines := l_result.objects(l_source_object.full_name).covered_lines + 1;
+              l_result.objects(l_source_object.full_name).executions := l_result.objects(l_source_object.full_name).executions + l_line_calls(line_no);
             elsif l_line_calls(line_no) = 0 then
               l_result.uncovered_lines := l_result.uncovered_lines + 1;
-              l_result.objects(src_object.full_name).uncovered_lines := l_result.objects(src_object.full_name).uncovered_lines + 1;
+              l_result.objects(l_source_object.full_name).uncovered_lines := l_result.objects(l_source_object.full_name).uncovered_lines + 1;
             end if;
-            l_result.objects(src_object.full_name).lines(line_no) := l_line_calls(line_no);
+            l_result.objects(l_source_object.full_name).lines(line_no) := l_line_calls(line_no);
 
             line_no := l_line_calls.next(line_no);
           end loop;
         end if;
       end if;
 
-
     end loop;
 
+    close l_source_objects_crsr;
+
     return l_result;
   end get_coverage_data;
 

diff --git a/source/core/coverage/ut_coverage_helper.pkb b/source/core/coverage/ut_coverage_helper.pkb
@@ -77,14 +77,14 @@ create or replace package body ut_coverage_helper is
     dbms_profiler.stop_profiler();
   end;
 
-  function get_raw_coverage_data(a_object_owner varchar2, a_object_name varchar2) return unit_line_calls is
+  function get_raw_coverage_data(a_object_owner varchar2, a_object_name varchar2) return t_unit_line_calls is
     type coverage_row is record (
       line  binary_integer,
       calls number(38,0)
     );
     type coverage_rows is table of coverage_row;
     l_tmp_data coverage_rows;
-    l_results  unit_line_calls;
+    l_results  t_unit_line_calls;
   begin
       select d.line#,
         -- This transformation addresses two issues:
@@ -112,9 +112,62 @@ create or replace package body ut_coverage_helper is
 
   procedure mock_coverage_id(a_coverage_id integer) is
   begin
-    if g_develop_mode and g_is_started then
-      g_coverage_id := a_coverage_id;
-    end if;
+    g_develop_mode := true;
+    g_is_started := true;
+    g_coverage_id := a_coverage_id;
+  end;
+
+  procedure insert_into_tmp_table(a_data t_coverage_sources_tmp_rows) is
+  begin
+    forall i in 1 .. a_data.count
+      insert into ut_coverage_sources_tmp
+             (full_name,owner,name,line,text, to_be_skipped)
+       values(a_data(i).full_name,a_data(i).owner,a_data(i).name,a_data(i).line,a_data(i).text,a_data(i).to_be_skipped);
+  end;
+
+  procedure cleanup_tmp_table is
+    pragma autonomous_transaction;
+  begin
+    null;
+    execute immediate 'truncate table ut_coverage_sources_tmp$';
+    commit;
+  end;
+
+  function is_tmp_table_populated return boolean is
+    l_result integer;
+  begin
+    select 1 into l_result from ut_coverage_sources_tmp where rownum = 1;
+    return (l_result = 1);
+  exception
+    when no_data_found then
+      return false;
+  end;
+
+  function get_tmp_table_objects_cursor return t_tmp_table_objects_crsr is
+    l_result t_tmp_table_objects_crsr;
+  begin
+    open l_result for
+      select o.owner, o.name, o.full_name, max(o.line) lines_count,
+             cast(
+               collect(decode(to_be_skipped, 'Y', to_char(line))) as ut_varchar2_list
+             ) to_be_skipped_list
+        from ut_coverage_sources_tmp o
+       group by o.owner, o.name, o.full_name;
+
+    return l_result;
+  end;
+
+  function get_tmp_table_object_lines(a_owner varchar2, a_object_name varchar2) return ut_varchar2_list is
+    l_result ut_varchar2_list;
+  begin
+    select rtrim(s.text,chr(10)) text
+      bulk collect into l_result
+      from ut_coverage_sources_tmp s
+     where s.owner = a_owner
+       and s.name = a_object_name
+     order by s.line;
+
+    return l_result;
   end;
 
 end;

diff --git a/source/core/coverage/ut_coverage_helper.pks b/source/core/coverage/ut_coverage_helper.pks
@@ -18,7 +18,28 @@ create or replace package ut_coverage_helper authid definer is
 
   --table of line calls indexed by line number
   --!!! this table is sparse!!!
-  type unit_line_calls is table of number(38,0) index by binary_integer;
+  type t_unit_line_calls is table of number(38,0) index by binary_integer;
+
+  type t_coverage_sources_tmp_row is record (
+    full_name      ut_coverage_sources_tmp.full_name%type,
+    owner          ut_coverage_sources_tmp.owner%type,
+    name           ut_coverage_sources_tmp.name%type,
+    line           ut_coverage_sources_tmp.line%type,
+    to_be_skipped  ut_coverage_sources_tmp.to_be_skipped%type,
+    text           ut_coverage_sources_tmp.text%type
+  );
+
+  type t_coverage_sources_tmp_rows is table of t_coverage_sources_tmp_row;
+
+  type t_tmp_table_object is record(
+    owner              ut_coverage_sources_tmp.owner%type,
+    name               ut_coverage_sources_tmp.name%type,
+    full_name          ut_coverage_sources_tmp.full_name%type,
+    lines_count        integer,
+    to_be_skipped_list ut_varchar2_list
+  );
+
+  type t_tmp_table_objects_crsr is ref cursor return t_tmp_table_object;
 
   function  is_develop_mode return boolean;
 
@@ -37,12 +58,23 @@ create or replace package ut_coverage_helper authid definer is
 
   procedure coverage_resume;
 
-  function get_raw_coverage_data(a_object_owner varchar2, a_object_name varchar2) return unit_line_calls;
+  function get_raw_coverage_data(a_object_owner varchar2, a_object_name varchar2) return t_unit_line_calls;
 
   /***
   * Allows overwriting of private global variable g_coverage_id
   * Used internally, only for unit testing of the framework only
   */
   procedure mock_coverage_id(a_coverage_id integer);
+
+  procedure insert_into_tmp_table(a_data t_coverage_sources_tmp_rows);
+
+  procedure cleanup_tmp_table;
+
+  function is_tmp_table_populated return boolean;
+
+  function get_tmp_table_objects_cursor return t_tmp_table_objects_crsr;
+
+  function get_tmp_table_object_lines(a_owner varchar2, a_object_name varchar2) return ut_varchar2_list;
+
 end;
 /
diff --git a/source/core/ut_utils.pkb b/source/core/ut_utils.pkb
@@ -340,12 +340,12 @@ create or replace package body ut_utils is
     end if;
     return l_result;
   end;
-  
+
   procedure set_action(a_text in varchar2) is
   begin
     dbms_application_info.set_module('utPLSQL', a_text);
   end;
-  
+
   procedure set_client_info(a_text in varchar2) is
   begin
     dbms_application_info.set_client_info(a_text);
@@ -381,7 +381,6 @@ create or replace package body ut_utils is
     pragma autonomous_transaction;
   begin
     execute immediate 'truncate table ut_cursor_data';
-    execute immediate 'truncate table ut_coverage_sources_tmp$';
     commit;
   end;
 

diff --git a/source/create_synonyms_and_grants_for_public.sql b/source/create_synonyms_and_grants_for_public.sql
@@ -59,7 +59,6 @@ grant execute on &&ut3_owner..ut_reporter_base to public;
 grant execute on &&ut3_owner..ut_coverage to public;
 grant execute on &&ut3_owner..ut_coverage_options to public;
 grant execute on &&ut3_owner..ut_coverage_helper to public;
-grant insert, delete, select on &&ut3_owner..ut_coverage_sources_tmp to public;
 grant execute on &&ut3_owner..ut_output_buffer to public;
 grant execute on &&ut3_owner..ut_file_mappings to public;
 grant execute on &&ut3_owner..ut_file_mapping to public;
@@ -99,7 +98,6 @@ create public synonym ut_reporter_base for &&ut3_owner..ut_reporter_base;
 create public synonym ut_coverage for &&ut3_owner..ut_coverage;
 create public synonym ut_coverage_options for &&ut3_owner..ut_coverage_options;
 create public synonym ut_coverage_helper for &&ut3_owner..ut_coverage_helper;
-create public synonym ut_coverage_sources_tmp for &&ut3_owner..ut_coverage_sources_tmp;
 create public synonym ut_output_buffer for &&ut3_owner..ut_output_buffer;
 create public synonym ut_file_mappings for &&ut3_owner..ut_file_mappings;
 create public synonym ut_file_mapping for &&ut3_owner..ut_file_mapping;