diff --git a/docs/userguide/coverage.md b/docs/userguide/coverage.md index 3b968ccc4..893c2e3a6 100644 --- a/docs/userguide/coverage.md +++ b/docs/userguide/coverage.md @@ -1,7 +1,7 @@ ![version](https://img.shields.io/badge/version-v3.1.11.3392--develop-blue.svg) # Coverage -utPLSQL comes with a built-in coverage reporting engine. The code coverage reporting is based on the DBMS_PROFILER package provided with Oracle database. +utPLSQL comes with a built-in coverage reporting engine. The code coverage reporting uses DBMS_PROFILER package provided with Oracle database. Code coverage is gathered for the following source types: * package bodies * type bodies @@ -11,9 +11,9 @@ Code coverage is gathered for the following source types: **Note** -> The package and type specifications are explicitly excluded from code coverage analysis. This limitation is introduced to avoid false-negatives. Typically package specifications contain no executable code. The only exception is initialization of global constants and variables in package specification. Since most package specifications are not executable at all, there is no information available on the number of lines covered and those would be reported as 0% covered, which is not desirable. +> The package and type specifications are excluded from code coverage analysis. This limitation is introduced to avoid false-negatives. Typically package specifications contain no executable code. The only exception is initialization of global constants and variables in package specification. Since most package specifications are not executable at all, there is no information available on the number of lines covered and those would be reported as 0% covered, which is not desirable. -To obtain information about code coverage of your unit tests, all you need to do is run your unit tests with one of built-in code coverage reporters. +To obtain information about code coverage for unit tests, run utPLSQL with one of built-in code coverage reporters. The following code coverage reporters are supplied with utPLSQL: * `ut_coverage_html_reporter` - generates a HTML coverage report providing summary and detailed information on code coverage. The HTML reporter is based on the open-source [simplecov-html](https://github.com/colszowka/simplecov-html) reporter for Ruby. It includes source code of the code that was covered (if possible) * `ut_coveralls_reporter` - generates a [Coveralls compatible JSON](https://coveralls.zendesk.com/hc/en-us/articles/201774865-API-Introduction) coverage report providing detailed information on code coverage with line numbers. This coverage report is designed to be consumed by cloud services like [Coveralls](https://coveralls.io) @@ -33,8 +33,8 @@ If you have `execute` privilege only on the unit tests, but do not have `execute If the code that is being tested is complied as NATIVE, the code coverage will not be reported as well. ## Running unit tests with coverage -Using the code coverage functionality is as easy as using any other [reporter](reporters.md) for the utPLSQL project. You just run your tests from your preferred SQL tool and save the reporter results to a file. -All you need to do is pass the constructor of the reporter to your `ut.run` +Using the code coverage functionality is as easy as using any other [reporter](reporters.md) for the utPLSQL test-run. You just run your tests from your preferred SQL tool and save the reporter results to a file. +All you need to do is pass the constructor of the reporter to the `ut.run` procedure call. Example: ```sql @@ -43,10 +43,10 @@ begin end; / ``` -Executes all unit tests in the current schema, gathers information about code coverage and outputs the HTML text into DBMS_OUTPUT. +The above command executes all unit tests in the **current schema**, gathers information about code coverage and outputs the HTML report as text into DBMS_OUTPUT. The `ut_coverage_html_reporter` will produce an interactive HTML report. You can see a sample of code coverage for the utPLSQL project [here](https://utplsql.github.io/utPLSQL-coverage-html/) -The report provides summary information with a list of source code that was expected to be covered. +The report provides summary information with a list of source code that should be covered. ![Coverage Summary page](../images/coverage_html_summary.png) @@ -57,8 +57,8 @@ The report allow you to navigate to each source file and inspect line by line co #### Oracle 12.2 extended coverage with profiler and block coverage Using data collected from profiler and block coverage running parallel we are able to enrich information about coverage. -For every line recorded by profiler if we have a partially covered same line in block coverage we will display that information -presenting line as partially covered, displaying number of block and how many blocks been covered in that line.The feature will be automatically enabled in the Oracle database version 12.2 and higher, for older versions current profiler will be used. +For every line recorded by the profiler if we have a partially covered same line in block coverage we will display that information +presenting line as partially covered, displaying number of block and how many blocks have been covered in that line.The feature will be automatically enabled in the Oracle database version 12.2 and higher, for older versions current profiler will be used. utPLSQL installation automatically creates tables needed by `dbms_plsql_code_coverage` on databases in versions above 12c Release 1. Due to security model of `dbms_plsql_code_coverage` package, utPLSQL grants access to those tables and creates synonyms for those tables. @@ -92,7 +92,8 @@ The default behavior of coverage reporting can be altered using invocation param ### Schema based Coverage -To simply gather coverage for all objects in your current schema execute tests with coverage reporting. +To gather coverage for all objects in the **current schema** execute tests with coverage report as argument. +This is the default reporting option and therefore additional coverage options don't need to be provided. ```sql exec ut.run(ut_coverage_html_reporter()); @@ -109,7 +110,7 @@ exec ut.run(ut_coverage_html_reporter()); #### Setting coverage schema(s) By default, coverage is gathered on the schema(s) derived from suite paths provided to execute tests. -This is correct as long as your test packages and tested code share the same schema. +This is a valid approach as long as your test packages and tested code share the same schema. So when you run: ```sql @@ -531,8 +532,8 @@ Unit test code is mapped to files in `test_results.xml` In order to allow deterministic and accurate mapping of database source-code into project files, the project directory and file structure needs to meet certain criteria. - Source code is kept separate from test code (separate directories) -- Each database (source-code) object is stored in individual file. Package/type specification is kept separate from it's body. -- File name (file path) contains name of database object +- Each database (source-code) object is stored in an individual file. Package/type specification is kept separate from its body. +- File name (file path) contains the name of database object - Each file-path clearly identifies object type (by file extension) - Each file contains representation of database object "as is". No extra commands (like `set echo off` `ALTER SESSION SET PLSQL_CCFLAGS = 'debug:TRUE';`) or blank lines are present before `CREATE TYPE`,`CREATE TYPE` etc. - When project is spanning across multiple database schemes, each file-path clearly and uniformly identifies object owner @@ -659,3 +660,119 @@ begin end; ``` +## Reporting coverage outside of utPLSQL + +utPSLQL allows fo standalone reporting code coverage across multiple database sessions. This functionality enables coverage reporting for external testing tools. + +Following API calls enable the standalone coverage reporting. + +- `ut_runner.coverage_start( coverage_run_id );` - initiates code coverage within a session +- `ut_runner.coverage_stop();` - stops gathering of code coverage within a session +- `.get_report( ... )` - coverage reporters function producing coverage report as pipelined data-set (to be used in SQL query) +- `.get_report_cursor( ... )` - coverage reporters function producing coverage report as ref-cursor + +Example: +```sql +--SESSION 1 +-- gather coverage on code using specific coverage_run_id value +declare + l_coverage_run_id raw(32); +begin + l_coverage_run_id := 'A6AA5B7361251CE6E053020011ACA055'; +-- l_coverage_run_id := sys_guid; + ut_runner.coverage_start(l_coverage_run_id); + + --The code to gather coverage on goes here + + ut_runner.coverage_stop(); +end; +/ +``` + +```sql +--SESSION 2 +-- alternative approach +-- gather coverage on code using specific coverage_run_id value +exec ut_runner.coverage_start('A6AA5B7361251CE6E053020011ACA055'); + +--The code to gather coverage on goes here + +exec ut_runner.coverage_stop(); +``` + + +```sql +--SESSION 1 or SESSION2 2 or SESSION 3 +-- run after calls in SESSION 1 & 2 are finshed +-- retrieve coverage report in HTML format coverage_run_id value +select * + from table( + ut_coverage_html_reporter().get_report( + a_coverage_options => ut_coverage_options( + coverage_run_id => 'A6AA5B7361251CE6E053020011ACA055' + ) + ) + ); +``` + +```sql +--SESSION 1 or SESSION2 2 or SESSION 3 +-- run after calls in SESSION 1 & 2 are finshed +declare + l_results_cursor sys_refcursor; +begin + l_results_cursor := ut_coverage_html_reporter().get_report_cursor( + a_coverage_options => ut_coverage_options( + coverage_run_id => 'A6AA5B7361251CE6E053020011ACA055' + ) + ); + --fetch and process the cursor results + close l_results_cursor; +end; +/ +``` + +Specification of parameters for `get_report` and `get_report_cursor` +```sql +function get_report( + a_coverage_options ut_coverage_options, + a_client_character_set varchar2 := null +) return ut_varchar2_rows pipelined +``` + +```sql +function get_report_cursor( + a_coverage_options ut_coverage_options, + a_client_character_set varchar2 := null +) return sys_refcursor +``` +```sql +ut_coverage_options( + coverage_run_id raw, + schema_names ut_varchar2_rows := null, + exclude_objects ut_varchar2_rows := null, + include_objects ut_varchar2_rows := null, + file_mappings ut_file_mappings := null +); +``` + +The `a_client_character_set` is used to provide character set to the report. Coverage reports in XML and HTML format include this information to assure that HMTL/XML encoding tag is aligned with encoding of the report produced. +Use this parameter to provide encoding of your client application. + +The `a_coverage_options` parameter is used to control the scope and formatting of data returned by report. + +`ut_coverage_options` object accepts the following arguments + +- `coverage_run_id` - identifier of coverage run to generate report for - data-type `RAW(32)` +- `schema_names` - optional - list of schema names to include in coverage report - data-type `UT_VARCHAR2_ROWS` +- `exclude_objects` - optional - list of object names to exclude from report - data-type `UT_VARCHAR2_ROWS` +- `include_objects` - optional - list of object names to gather coverage on - data-type `UT_VARCHAR2_ROWS` +- `file_mappings` - optional - list of schema names to gather coverage on - data-type `UT_FILE_MAPPINGS` + +`coverage_run_id` parameter identifies a common coverage run. The valid value type for that parameter is RAW(32). +It is recommended to use `sys_guid()` to generate a common, unique identifier for a specific coverage run. +If the identifier is not unique, previous runs of coverage that used the same `coverage_run_id` will be aggregated to the resulting coverage report. + +For details on the meaning of `schema_names`, `exclude_objects`, `include_objects`, `file_mappings` see sections above. +Note that data-types of include/exclude/schema lists are different when calling `ut.run` vs. calling `get_report/get_report_cursor`. + diff --git a/examples/RunExpectations.sql b/examples/RunExpectations.sql index aeb5c40bc..eed123e72 100644 --- a/examples/RunExpectations.sql +++ b/examples/RunExpectations.sql @@ -11,7 +11,7 @@ set echo off @@demo_expectations.pck begin - ut_coverage.coverage_start(); + ut_coverage.coverage_start(sys_guid()); ut_coverage.set_develop_mode(true); ut.run(); ut_coverage.set_develop_mode(false); diff --git a/source/api/ut_runner.pkb b/source/api/ut_runner.pkb index 2f523e1dd..bb7d3e458 100644 --- a/source/api/ut_runner.pkb +++ b/source/api/ut_runner.pkb @@ -20,27 +20,6 @@ create or replace package body ut_runner is /** * Private functions */ - function to_ut_object_list(a_names ut_varchar2_list, a_schema_names ut_varchar2_rows) return ut_object_names is - l_result ut_object_names; - l_object_name ut_object_name; - begin - if a_names is not empty then - l_result := ut_object_names(); - for i in 1 .. a_names.count loop - l_object_name := ut_object_name(a_names(i)); - if l_object_name.owner is null then - for i in 1 .. cardinality(a_schema_names) loop - l_result.extend; - l_result(l_result.last) := ut_object_name(a_schema_names(i)||'.'||l_object_name.name); - end loop; - else - l_result.extend; - l_result(l_result.last) := l_object_name; - end if; - end loop; - end if; - return l_result; - end; procedure finish_run(a_run ut_run, a_force_manual_rollback boolean) is begin @@ -51,7 +30,6 @@ create or replace package body ut_runner is ut_compound_data_helper.cleanup_diff(); if not a_force_manual_rollback then rollback; - ut_utils.cleanup_session_temp_tables; end if; end; @@ -95,9 +73,7 @@ create or replace package body ut_runner is ) is l_run ut_run; l_coverage_schema_names ut_varchar2_rows; - l_exclude_object_names ut_object_names := ut_object_names(); - l_include_object_names ut_object_names; - l_paths ut_varchar2_list := ut_varchar2_list(); + l_paths ut_varchar2_list; l_random_test_order_seed positive; l_tags ut_varchar2_rows := ut_varchar2_rows(); begin @@ -113,18 +89,17 @@ create or replace package body ut_runner is ut_event_manager.trigger_event(ut_event_manager.gc_initialize); ut_event_manager.trigger_event(ut_event_manager.gc_debug, ut_run_info()); + if a_random_test_order_seed is not null then l_random_test_order_seed := a_random_test_order_seed; elsif a_random_test_order then dbms_random.seed( to_char(systimestamp,'yyyyddmmhh24missffff') ); l_random_test_order_seed := trunc(dbms_random.value(1, 1000000000)); end if; - if a_paths is null or a_paths is empty or a_paths.count = 1 and a_paths(1) is null then + + l_paths := ut_utils.filter_list(ut_utils.string_table_to_table(a_paths,','), '.+'); + if l_paths is null or l_paths is empty then l_paths := ut_varchar2_list(sys_context('userenv', 'current_schema')); - else - for i in 1..a_paths.count loop - l_paths := l_paths multiset union ut_utils.string_to_table(a_string => a_paths(i),a_delimiter => ','); - end loop; end if; begin @@ -132,36 +107,33 @@ create or replace package body ut_runner is ut_utils.save_dbms_output_to_cache(); ut_console_reporter_base.set_color_enabled(a_color_console); + if a_coverage_schemes is not empty then l_coverage_schema_names := ut_utils.convert_collection(a_coverage_schemes); else l_coverage_schema_names := ut_suite_manager.get_schema_names(l_paths); end if; - if a_exclude_objects is not empty then - l_exclude_object_names := to_ut_object_list(a_exclude_objects, l_coverage_schema_names); - end if; - + if a_tags is not null then - l_tags := l_tags multiset union distinct ut_utils.convert_collection( + l_tags := l_tags multiset union distinct ut_utils.convert_collection( ut_utils.trim_list_elements(ut_utils.filter_list(ut_utils.string_to_table(a_tags,','),ut_utils.gc_word_no_space)) ); end if; - l_exclude_object_names := l_exclude_object_names multiset union all ut_suite_manager.get_schema_ut_packages(l_coverage_schema_names); - - l_include_object_names := to_ut_object_list(a_include_objects, l_coverage_schema_names); l_run := ut_run( - null, - l_paths, - l_coverage_schema_names, - l_exclude_object_names, - l_include_object_names, - set(a_source_file_mappings), - set(a_test_file_mappings), - a_client_character_set, - l_random_test_order_seed, - l_tags + a_run_paths => l_paths, + a_coverage_options => ut_coverage_options( + coverage_run_id => sys_guid(), + schema_names => l_coverage_schema_names, + exclude_objects => ut_utils.convert_collection(a_exclude_objects), + include_objects => ut_utils.convert_collection(a_include_objects), + file_mappings => set(a_source_file_mappings) + ), + a_test_file_mappings => set(a_test_file_mappings), + a_client_character_set => a_client_character_set, + a_random_test_order_seed => l_random_test_order_seed, + a_run_tags => l_tags ); ut_suite_manager.configure_execution_by_path(l_paths, l_run.items, l_random_test_order_seed, l_tags); @@ -296,5 +268,15 @@ create or replace package body ut_runner is return l_result; end; + procedure coverage_start(a_coverage_run_id raw) is + begin + ut_coverage.coverage_start(a_coverage_run_id); + end; + + procedure coverage_stop is + begin + ut_coverage.coverage_stop; + end; + end ut_runner; / diff --git a/source/api/ut_runner.pks b/source/api/ut_runner.pks index 38167ac57..61578a4e0 100644 --- a/source/api/ut_runner.pks +++ b/source/api/ut_runner.pks @@ -145,5 +145,9 @@ create or replace package ut_runner authid current_user is */ function hash_suite_path(a_path varchar2, a_random_seed positiven) return varchar2; + procedure coverage_start(a_coverage_run_id raw); + + procedure coverage_stop; + end ut_runner; / diff --git a/source/core/coverage/ut_coverage.pkb b/source/core/coverage/ut_coverage.pkb index caa75ae51..a05fa554a 100644 --- a/source/core/coverage/ut_coverage.pkb +++ b/source/core/coverage/ut_coverage.pkb @@ -16,26 +16,20 @@ create or replace package body ut_coverage is limitations under the License. */ - g_coverage_id tt_coverage_id_arr; - g_develop_mode boolean not null := false; - g_is_started boolean not null := false; + g_develop_mode boolean not null := false; + g_is_started boolean not null := false; procedure set_develop_mode(a_develop_mode in boolean) is - begin - g_develop_mode := a_develop_mode; - end; - - function get_coverage_id(a_coverage_type in varchar2) return integer is - begin - return g_coverage_id(a_coverage_type); - end; + begin + g_develop_mode := a_develop_mode; + end; function is_develop_mode return boolean is - begin - return g_develop_mode; - end; + begin + return g_develop_mode; + end; - function get_cov_sources_sql(a_coverage_options ut_coverage_options, a_skip_objects ut_object_names) return varchar2 is + function get_cov_sources_sql(a_coverage_options ut_coverage_options, a_skip_objects ut_object_names) return varchar2 is l_result varchar2(32767); l_full_name varchar2(32767); l_join_mappings varchar2(32767); @@ -177,14 +171,16 @@ create or replace package body ut_coverage is /** * Public functions */ - procedure coverage_start(a_coverage_options ut_coverage_options default null) is + procedure coverage_start(a_coverage_run_id t_coverage_run_id) is l_run_comment varchar2(200) := 'utPLSQL Code coverage run '||ut_utils.to_string(systimestamp); + l_line_coverage_id integer; + l_block_coverage_id integer; begin if not is_develop_mode() and not g_is_started then - ut_coverage_helper_block.coverage_start( l_run_comment, g_coverage_id(gc_block_coverage) ); - ut_coverage_helper_profiler.coverage_start( l_run_comment, g_coverage_id(gc_proftab_coverage) ); - coverage_pause(); + l_line_coverage_id := ut_coverage_helper_profiler.coverage_start( l_run_comment ); + l_block_coverage_id := ut_coverage_helper_block.coverage_start( l_run_comment ); g_is_started := true; + ut_coverage_helper.set_coverage_run_ids(a_coverage_run_id, l_line_coverage_id, l_block_coverage_id); end if; end; @@ -200,20 +196,6 @@ create or replace package body ut_coverage is ut_coverage_helper_profiler.coverage_resume(); end; - procedure mock_coverage_id(a_coverage_id integer,a_coverage_type in varchar2) is - begin - g_develop_mode := true; - g_is_started := true; - g_coverage_id(a_coverage_type) := a_coverage_id; - end; - - procedure mock_coverage_id(a_coverage_id tt_coverage_id_arr) is - begin - g_develop_mode := true; - g_is_started := true; - g_coverage_id := a_coverage_id; - end; - procedure coverage_stop is begin if not is_develop_mode() then @@ -227,22 +209,23 @@ create or replace package body ut_coverage is function get_coverage_data(a_coverage_options ut_coverage_options) return t_coverage is l_result_block ut_coverage.t_coverage; l_result_profiler_enrich ut_coverage.t_coverage; - l_object ut_coverage.t_full_name; + l_object ut_coverage.t_object_name; l_line_no binary_integer; + l_coverage_options ut_coverage_options := a_coverage_options; begin --prepare global temp table with sources ut_event_manager.trigger_event('about to populate coverage temp table'); - populate_tmp_table(a_coverage_options); + populate_tmp_table(l_coverage_options); ut_event_manager.trigger_event('coverage temp table populated'); -- Get raw data for both reporters, order is important as tmp table will skip headers and dont populate -- tmp table for block again. - l_result_profiler_enrich:= ut_coverage_profiler.get_coverage_data( a_coverage_options, get_coverage_id(gc_proftab_coverage) ); + l_result_profiler_enrich := ut_coverage_profiler.get_coverage_data( l_coverage_options ); ut_event_manager.trigger_event('profiler coverage data retrieved'); -- If block coverage available we will use it. $if dbms_db_version.version = 12 and dbms_db_version.release >= 2 or dbms_db_version.version > 12 $then - l_result_block := ut_coverage_block.get_coverage_data( a_coverage_options, get_coverage_id(gc_block_coverage) ); + l_result_block := ut_coverage_block.get_coverage_data( l_coverage_options ); ut_event_manager.trigger_event('block coverage data retrieved'); -- Enrich profiler results with some of the block results diff --git a/source/core/coverage/ut_coverage.pks b/source/core/coverage/ut_coverage.pks index 1d87d50c9..ba5263dd2 100644 --- a/source/core/coverage/ut_coverage.pks +++ b/source/core/coverage/ut_coverage.pks @@ -16,25 +16,21 @@ create or replace package ut_coverage authid current_user is limitations under the License. */ - gc_proftab_coverage constant varchar2(32) := 'proftab'; - gc_block_coverage constant varchar2(32) := 'block'; - - type tt_coverage_id_arr is table of integer index by varchar2(30); + subtype t_coverage_run_id is raw(32) not null; -- total run coverage information - subtype t_full_name is varchar2(4000); - subtype t_object_name is varchar2(250); - - --subtype t_line_executions is binary_integer; + subtype t_object_name is varchar2(257); + subtype t_line_no is binary_integer; type t_line_executions is record( - executions binary_integer - ,partcove binary_integer - ,no_blocks binary_integer + executions binary_integer + ,partcove binary_integer + ,no_blocks binary_integer ,covered_blocks binary_integer); + -- line coverage information indexed by line no. - --type tt_lines is table of t_line_executions index by binary_integer; - type tt_lines is table of t_line_executions index by binary_integer; + type tt_lines is table of t_line_executions index by t_line_no; + --unit coverage information record type t_unit_coverage is record( owner varchar2(128) @@ -50,7 +46,7 @@ create or replace package ut_coverage authid current_user is ,lines tt_lines); -- coverage information indexed by full object name (schema.object) - type tt_program_units is table of t_unit_coverage index by t_full_name; + type tt_program_units is table of t_unit_coverage index by t_object_name; -- total run coverage information type t_coverage is record( @@ -64,21 +60,11 @@ create or replace package ut_coverage authid current_user is ,executions number(38, 0) := 0 ,objects tt_program_units); - function get_coverage_id(a_coverage_type in varchar2) return integer; - procedure set_develop_mode(a_develop_mode in boolean); function is_develop_mode return boolean; - /*** - * 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, a_coverage_type in varchar2); - - procedure mock_coverage_id(a_coverage_id tt_coverage_id_arr); - - procedure coverage_start(a_coverage_options ut_coverage_options default null); + procedure coverage_start(a_coverage_run_id t_coverage_run_id); procedure coverage_stop; diff --git a/source/core/coverage/ut_coverage_block.pkb b/source/core/coverage/ut_coverage_block.pkb index c6d0f409d..0e0373a48 100644 --- a/source/core/coverage/ut_coverage_block.pkb +++ b/source/core/coverage/ut_coverage_block.pkb @@ -23,7 +23,7 @@ create or replace package body ut_coverage_block is * Public functions */ - function get_coverage_data(a_coverage_options ut_coverage_options, a_coverage_id integer) return ut_coverage.t_coverage is + function get_coverage_data(a_coverage_options ut_coverage_options) return ut_coverage.t_coverage is l_line_calls ut_coverage_helper.t_unit_line_calls; l_result ut_coverage.t_coverage; l_new_unit ut_coverage.t_unit_coverage; @@ -40,7 +40,11 @@ create or replace package body ut_coverage_block is exit when l_source_objects_crsr%notfound; --get coverage data - l_line_calls := ut_coverage_helper_block.get_raw_coverage_data(l_source_object.owner, l_source_object.name, a_coverage_id); + l_line_calls := ut_coverage_helper_block.get_raw_coverage_data( + l_source_object.owner, + l_source_object.name, + a_coverage_options.coverage_run_id + ); --if there is coverage, we need to filter out the garbage (badly indicated data) if l_line_calls.count > 0 then --remove lines that should not be indicted as meaningful diff --git a/source/core/coverage/ut_coverage_block.pks b/source/core/coverage/ut_coverage_block.pks index 26c79317e..08de58e69 100644 --- a/source/core/coverage/ut_coverage_block.pks +++ b/source/core/coverage/ut_coverage_block.pks @@ -16,7 +16,7 @@ create or replace package ut_coverage_block authid current_user is limitations under the License. */ - function get_coverage_data(a_coverage_options ut_coverage_options, a_coverage_id integer) return ut_coverage.t_coverage; + function get_coverage_data(a_coverage_options ut_coverage_options) return ut_coverage.t_coverage; end; / diff --git a/source/core/coverage/ut_coverage_helper.pkb b/source/core/coverage/ut_coverage_helper.pkb index 12ee9e1f7..5762452c4 100644 --- a/source/core/coverage/ut_coverage_helper.pkb +++ b/source/core/coverage/ut_coverage_helper.pkb @@ -60,10 +60,10 @@ create or replace package body ut_coverage_helper 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, + select o.owner, o.name, o.full_name, max(o.line) as lines_count, cast( collect(decode(to_be_skipped, 'Y', to_char(line))) as ut_varchar2_list - ) to_be_skipped_list + ) as to_be_skipped_list from ut_coverage_sources_tmp o group by o.owner, o.name, o.full_name; @@ -73,7 +73,7 @@ create or replace package body ut_coverage_helper is 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 + select rtrim(s.text,chr(10)) as text bulk collect into l_result from ut_coverage_sources_tmp s where s.owner = a_owner @@ -83,5 +83,15 @@ create or replace package body ut_coverage_helper is return l_result; end; + procedure set_coverage_run_ids( a_coverage_run_id raw, a_line_coverage_id integer, a_block_coverage_id integer ) is + pragma autonomous_transaction; + begin + insert into ut_coverage_runs + ( coverage_run_id, line_coverage_id, block_coverage_id ) + values + ( a_coverage_run_id, a_line_coverage_id, a_block_coverage_id ); + commit; + end; + end; / diff --git a/source/core/coverage/ut_coverage_helper.pks b/source/core/coverage/ut_coverage_helper.pks index 85a54a7ca..955542633 100644 --- a/source/core/coverage/ut_coverage_helper.pks +++ b/source/core/coverage/ut_coverage_helper.pks @@ -59,5 +59,7 @@ create or replace package ut_coverage_helper authid definer is function get_tmp_table_object_lines(a_owner varchar2, a_object_name varchar2) return ut_varchar2_list; + procedure set_coverage_run_ids( a_coverage_run_id raw, a_line_coverage_id integer, a_block_coverage_id integer ); + end; / diff --git a/source/core/coverage/ut_coverage_helper_block.pkb b/source/core/coverage/ut_coverage_helper_block.pkb index fc64c507f..1ded434ba 100644 --- a/source/core/coverage/ut_coverage_helper_block.pkb +++ b/source/core/coverage/ut_coverage_helper_block.pkb @@ -16,13 +16,6 @@ create or replace package body ut_coverage_helper_block is limitations under the License. */ - type t_proftab_row is record ( - line binary_integer, - calls number(38,0) - ); - - type t_proftab_rows is table of t_proftab_row; - type t_block_row is record( line binary_integer ,blocks binary_integer @@ -30,12 +23,12 @@ create or replace package body ut_coverage_helper_block is type t_block_rows is table of t_block_row; - procedure coverage_start(a_run_comment varchar2, a_coverage_id out integer) is + function coverage_start(a_run_comment varchar2) return integer is begin $if dbms_db_version.version = 12 and dbms_db_version.release >= 2 or dbms_db_version.version > 12 $then - a_coverage_id := dbms_plsql_code_coverage.start_coverage(run_comment => a_run_comment); + return dbms_plsql_code_coverage.start_coverage(run_comment => a_run_comment); $else - null; + return null; $end end; @@ -48,45 +41,54 @@ create or replace package body ut_coverage_helper_block is $end end; - function block_results(a_object_owner varchar2, a_object_name varchar2, a_coverage_id integer) return t_block_rows is + function block_results(a_object_owner varchar2, a_object_name varchar2, a_coverage_run_id raw) return t_block_rows is l_coverage_rows t_block_rows; + l_ut_owner varchar2(250) := ut_utils.ut_owner; begin - - select ccb.line as line, - count(ccb.block) as blocks, - sum(ccb.covered) as covered_blocks - bulk collect into l_coverage_rows - from dbmspcc_units ccu - left outer join dbmspcc_blocks ccb - on ccu.run_id = ccb.run_id - and ccu.object_id = ccb.object_id - where ccu.run_id = a_coverage_id - and ccu.owner = a_object_owner - and ccu.name = a_object_name - group by ccb.line - order by 1; - - return l_coverage_rows; + execute immediate q'[ + select line as line, + count(block) as blocks, + sum(covered) as covered_blocks + from (select line, + block, + max(covered) as covered + from dbmspcc_units ccu + join ]'||l_ut_owner||q'[.ut_coverage_runs r + on r.block_coverage_id = ccu.run_id + left join dbmspcc_blocks ccb + on ccu.run_id = ccb.run_id + and ccu.object_id = ccb.object_id + where r.coverage_run_id = :a_coverage_run_id + and ccu.owner = :a_object_owner + and ccu.name = :a_object_name + group by ccb.line, ccb.block + ) + group by line + order by line]' + bulk collect into l_coverage_rows using a_coverage_run_id, a_object_owner, a_object_name; + return l_coverage_rows; end; - function get_raw_coverage_data(a_object_owner varchar2, a_object_name varchar2, a_coverage_id integer) return ut_coverage_helper.t_unit_line_calls is + function get_raw_coverage_data( + a_object_owner varchar2, a_object_name varchar2, a_coverage_run_id raw + ) return ut_coverage_helper.t_unit_line_calls is l_tmp_data t_block_rows; l_results ut_coverage_helper.t_unit_line_calls; begin $if dbms_db_version.version = 12 and dbms_db_version.release >= 2 or dbms_db_version.version > 12 $then - l_tmp_data := block_results(a_object_owner, a_object_name, a_coverage_id); + l_tmp_data := block_results(a_object_owner, a_object_name, a_coverage_run_id); for i in 1 .. l_tmp_data.count loop l_results(l_tmp_data(i).line).blocks := l_tmp_data(i).blocks; l_results(l_tmp_data(i).line).covered_blocks := l_tmp_data(i).covered_blocks; - l_results(l_tmp_data(i).line).partcovered := case - when (l_tmp_data(i).covered_blocks > 0) and - (l_tmp_data(i).blocks > l_tmp_data(i).covered_blocks) then - 1 - else - 0 - end; + l_results(l_tmp_data(i).line).partcovered := + case + when (l_tmp_data(i).covered_blocks > 0) + and (l_tmp_data(i).blocks > l_tmp_data(i).covered_blocks) + then 1 + else 0 + end; end loop; $end return l_results; diff --git a/source/core/coverage/ut_coverage_helper_block.pks b/source/core/coverage/ut_coverage_helper_block.pks index 0afa3ab15..9d24989d6 100644 --- a/source/core/coverage/ut_coverage_helper_block.pks +++ b/source/core/coverage/ut_coverage_helper_block.pks @@ -16,11 +16,13 @@ create or replace package ut_coverage_helper_block authid current_user is limitations under the License. */ - procedure coverage_start(a_run_comment in varchar2,a_coverage_id out integer); + function coverage_start(a_run_comment in varchar2) return integer; procedure coverage_stop; - function get_raw_coverage_data(a_object_owner varchar2, a_object_name varchar2, a_coverage_id integer) return ut_coverage_helper.t_unit_line_calls; + function get_raw_coverage_data( + a_object_owner varchar2, a_object_name varchar2, a_coverage_run_id raw + ) return ut_coverage_helper.t_unit_line_calls; end; / diff --git a/source/core/coverage/ut_coverage_helper_profiler.pkb b/source/core/coverage/ut_coverage_helper_profiler.pkb index c90a5b36a..dde3bf3ea 100644 --- a/source/core/coverage/ut_coverage_helper_profiler.pkb +++ b/source/core/coverage/ut_coverage_helper_profiler.pkb @@ -31,9 +31,11 @@ create or replace package body ut_coverage_helper_profiler is type t_block_rows is table of t_block_row; - procedure coverage_start(a_run_comment varchar2,a_coverage_id out integer) is + function coverage_start(a_run_comment varchar2) return integer is + l_coverage_id integer; begin - dbms_profiler.start_profiler(run_comment => a_run_comment, run_number => a_coverage_id); + dbms_profiler.start_profiler(run_comment => a_run_comment, run_number => l_coverage_id); + return l_coverage_id; end; procedure coverage_pause is @@ -53,7 +55,7 @@ create or replace package body ut_coverage_helper_profiler is dbms_profiler.stop_profiler(); end; - function proftab_results(a_object_owner varchar2, a_object_name varchar2, a_coverage_id integer) return t_proftab_rows is + function proftab_results(a_object_owner varchar2, a_object_name varchar2, a_coverage_run_id raw) return t_proftab_rows is l_coverage_rows t_proftab_rows; begin select @@ -64,20 +66,24 @@ create or replace package body ut_coverage_helper_profiler is join plsql_profiler_data d on u.runid = d.runid and u.unit_number = d.unit_number - where u.runid = a_coverage_id + join ut_coverage_runs r + on r.line_coverage_id = u.runid + where r.coverage_run_id = a_coverage_run_id and u.unit_owner = a_object_owner and u.unit_name = a_object_name and u.unit_type in ('PACKAGE BODY', 'TYPE BODY', 'PROCEDURE', 'FUNCTION', 'TRIGGER') group by d.line#; - + return l_coverage_rows; end; - function get_raw_coverage_data(a_object_owner varchar2, a_object_name varchar2, a_coverage_id integer) return ut_coverage_helper.t_unit_line_calls is + function get_raw_coverage_data( + a_object_owner varchar2, a_object_name varchar2, a_coverage_run_id raw + ) return ut_coverage_helper.t_unit_line_calls is l_tmp_data t_proftab_rows; l_results ut_coverage_helper.t_unit_line_calls; begin - l_tmp_data := proftab_results(a_object_owner, a_object_name, a_coverage_id); + l_tmp_data := proftab_results(a_object_owner, a_object_name, a_coverage_run_id); for i in 1 .. l_tmp_data.count loop l_results(l_tmp_data(i).line).calls := l_tmp_data(i).calls; diff --git a/source/core/coverage/ut_coverage_helper_profiler.pks b/source/core/coverage/ut_coverage_helper_profiler.pks index 9345f4b88..390495810 100644 --- a/source/core/coverage/ut_coverage_helper_profiler.pks +++ b/source/core/coverage/ut_coverage_helper_profiler.pks @@ -16,7 +16,7 @@ create or replace package ut_coverage_helper_profiler authid definer is limitations under the License. */ - procedure coverage_start(a_run_comment in varchar2,a_coverage_id out integer); + function coverage_start(a_run_comment in varchar2) return integer; procedure coverage_stop; @@ -24,7 +24,9 @@ create or replace package ut_coverage_helper_profiler authid definer is procedure coverage_resume; - function get_raw_coverage_data(a_object_owner varchar2, a_object_name varchar2, a_coverage_id integer) return ut_coverage_helper.t_unit_line_calls; + function get_raw_coverage_data( + a_object_owner varchar2, a_object_name varchar2, a_coverage_run_id raw + ) return ut_coverage_helper.t_unit_line_calls; end; / diff --git a/source/core/coverage/ut_coverage_profiler.pkb b/source/core/coverage/ut_coverage_profiler.pkb index 160e2dd41..274f6949c 100644 --- a/source/core/coverage/ut_coverage_profiler.pkb +++ b/source/core/coverage/ut_coverage_profiler.pkb @@ -19,7 +19,7 @@ create or replace package body ut_coverage_profiler is /** * Public functions */ - function get_coverage_data(a_coverage_options ut_coverage_options, a_coverage_id integer) return ut_coverage.t_coverage is + function get_coverage_data(a_coverage_options ut_coverage_options) return ut_coverage.t_coverage is l_line_calls ut_coverage_helper.t_unit_line_calls; l_result ut_coverage.t_coverage; l_new_unit ut_coverage.t_unit_coverage; @@ -34,7 +34,11 @@ create or replace package body ut_coverage_profiler is exit when l_source_objects_crsr%notfound; --get coverage data - l_line_calls := ut_coverage_helper_profiler.get_raw_coverage_data( l_source_object.owner, l_source_object.name, a_coverage_id); + l_line_calls := ut_coverage_helper_profiler.get_raw_coverage_data( + l_source_object.owner, + l_source_object.name, + a_coverage_options.coverage_run_id + ); --if there is coverage, we need to filter out the garbage (badly indicated data from dbms_profiler) if l_line_calls.count > 0 then diff --git a/source/core/coverage/ut_coverage_profiler.pks b/source/core/coverage/ut_coverage_profiler.pks index 8e671f899..59256ae65 100644 --- a/source/core/coverage/ut_coverage_profiler.pks +++ b/source/core/coverage/ut_coverage_profiler.pks @@ -16,7 +16,7 @@ create or replace package ut_coverage_profiler authid current_user is limitations under the License. */ - function get_coverage_data(a_coverage_options ut_coverage_options, a_coverage_id integer) return ut_coverage.t_coverage; + function get_coverage_data(a_coverage_options ut_coverage_options) return ut_coverage.t_coverage; end; / diff --git a/source/core/coverage/ut_coverage_reporter_base.tpb b/source/core/coverage/ut_coverage_reporter_base.tpb index 5067f9221..96c4b5066 100644 --- a/source/core/coverage/ut_coverage_reporter_base.tpb +++ b/source/core/coverage/ut_coverage_reporter_base.tpb @@ -19,7 +19,8 @@ create or replace type body ut_coverage_reporter_base is overriding final member procedure before_calling_run(self in out nocopy ut_coverage_reporter_base, a_run ut_run) as begin (self as ut_output_reporter_base).before_calling_run(a_run); - ut_coverage.coverage_start(a_coverage_options => a_run.coverage_options); + ut_coverage.coverage_start(a_coverage_run_id => a_run.coverage_options.coverage_run_id); + ut_coverage.coverage_pause(); end; overriding final member procedure before_calling_before_all(self in out nocopy ut_coverage_reporter_base, a_executable in ut_executable) is @@ -85,5 +86,30 @@ create or replace type body ut_coverage_reporter_base is ut_coverage.coverage_pause(); end; + final member function get_report( a_coverage_options ut_coverage_options, a_client_character_set varchar2 := null ) return ut_varchar2_rows pipelined is + l_reporter ut_coverage_reporter_base := self; + begin + ut_coverage_helper.cleanup_tmp_table(); + (l_reporter as ut_output_reporter_base).before_calling_run(null); + l_reporter.after_calling_run( ut_run( a_coverage_options => a_coverage_options, a_client_character_set => a_client_character_set ) ); + l_reporter.on_finalize(null); + for i in (select x.text from table(l_reporter.get_lines(1, 1)) x ) loop + pipe row (i.text); + end loop; + return; + end; + + final member function get_report_cursor( a_coverage_options ut_coverage_options, a_client_character_set varchar2 := null ) return sys_refcursor is + l_reporter ut_coverage_reporter_base := self; + l_result sys_refcursor; + begin + ut_coverage_helper.cleanup_tmp_table(); + (l_reporter as ut_output_reporter_base).before_calling_run(null); + l_reporter.after_calling_run( ut_run( a_coverage_options => a_coverage_options, a_client_character_set => a_client_character_set ) ); + l_reporter.on_finalize(null); + open l_result for select x.text from table(l_reporter.get_lines(1, 1)) x; + return l_result; + end; + end; / diff --git a/source/core/coverage/ut_coverage_reporter_base.tps b/source/core/coverage/ut_coverage_reporter_base.tps index 2b9d1c625..cae165258 100644 --- a/source/core/coverage/ut_coverage_reporter_base.tps +++ b/source/core/coverage/ut_coverage_reporter_base.tps @@ -36,8 +36,9 @@ create or replace type ut_coverage_reporter_base under ut_output_reporter_base( overriding final member procedure after_calling_after_each (self in out nocopy ut_coverage_reporter_base, a_executable in ut_executable), overriding final member procedure before_calling_after_all(self in out nocopy ut_coverage_reporter_base, a_executable in ut_executable), - overriding final member procedure after_calling_after_all (self in out nocopy ut_coverage_reporter_base, a_executable in ut_executable) - + overriding final member procedure after_calling_after_all (self in out nocopy ut_coverage_reporter_base, a_executable in ut_executable), + final member function get_report( a_coverage_options ut_coverage_options, a_client_character_set varchar2 := null ) return ut_varchar2_rows pipelined, + final member function get_report_cursor( a_coverage_options ut_coverage_options, a_client_character_set varchar2 := null ) return sys_refcursor ) not final not instantiable / diff --git a/source/core/coverage/ut_coverage_runs.sql b/source/core/coverage/ut_coverage_runs.sql new file mode 100644 index 000000000..78230240d --- /dev/null +++ b/source/core/coverage/ut_coverage_runs.sql @@ -0,0 +1,20 @@ +declare + l_tab_exist number; +begin + select count(*) into l_tab_exist + from all_tables + where table_name = 'UT_COVERAGE_RUNS' and owner = sys_context('USERENV','CURRENT_SCHEMA'); + if l_tab_exist = 0 then + execute immediate q'[create table ut_coverage_runs + ( + coverage_run_id raw(32) not null, + line_coverage_id number(38,0) unique not null, + block_coverage_id number(38,0) unique, + constraint ut_coverage_runs primary key (coverage_run_id, line_coverage_id) + ) organization index ]'; + execute immediate q'[comment on table ut_coverage_runs is + 'Map of block and line coverage runs for a test-run']'; + dbms_output.put_line('UT_COVERAGE_RUNS table created'); + end if; +end; +/ diff --git a/source/core/output_buffers/ut_output_buffer_base.tpb b/source/core/output_buffers/ut_output_buffer_base.tpb index 018250e4b..38f008e75 100644 --- a/source/core/output_buffers/ut_output_buffer_base.tpb +++ b/source/core/output_buffers/ut_output_buffer_base.tpb @@ -44,7 +44,7 @@ create or replace type body ut_output_buffer_base is return l_lines; end; - member procedure lines_to_dbms_output(self in ut_output_buffer_base, a_initial_timeout natural := null, a_timeout_sec natural := null) is + member procedure lines_to_dbms_output(self in ut_output_buffer_base, a_initial_timeout natural := null, a_timeout_sec natural := null) is l_data sys_refcursor; l_clob clob; l_item_type varchar2(32767); diff --git a/source/core/types/ut_coverage_options.tpb b/source/core/types/ut_coverage_options.tpb new file mode 100644 index 000000000..6eb4921a7 --- /dev/null +++ b/source/core/types/ut_coverage_options.tpb @@ -0,0 +1,64 @@ +create or replace type body ut_coverage_options as + /* + utPLSQL - Version 3 + Copyright 2016 - 2019 utPLSQL Project + + Licensed under the Apache License, Version 2.0 (the "License"): + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + */ + + constructor function ut_coverage_options( + self in out nocopy ut_coverage_options, + coverage_run_id raw, + schema_names ut_varchar2_rows := null, + exclude_objects ut_varchar2_rows := null, + include_objects ut_varchar2_rows := null, + file_mappings ut_file_mappings := null + ) return self as result is + function to_ut_object_list(a_names ut_varchar2_rows, a_schema_names ut_varchar2_rows) return ut_object_names is + l_result ut_object_names; + l_object_name ut_object_name; + begin + if a_names is not empty then + l_result := ut_object_names(); + for i in 1 .. a_names.count loop + l_object_name := ut_object_name(a_names(i)); + if l_object_name.owner is null then + for i in 1 .. cardinality(a_schema_names) loop + l_result.extend; + l_result(l_result.last) := ut_object_name(a_schema_names(i)||'.'||l_object_name.name); + end loop; + else + l_result.extend; + l_result(l_result.last) := l_object_name; + end if; + end loop; + end if; + return l_result; + end; + begin + self.coverage_run_id := coverage_run_id; + self.file_mappings := file_mappings; + self.schema_names := schema_names; + self.exclude_objects := ut_object_names(); + + if exclude_objects is not empty then + self.exclude_objects := to_ut_object_list(exclude_objects, self.schema_names); + end if; +-- self.exclude_objects := self.exclude_objects multiset union all ut_suite_manager.get_schema_ut_packages(schema_names); + + self.include_objects := to_ut_object_list(include_objects, self.schema_names); + + return; + end; +end; +/ diff --git a/source/core/types/ut_coverage_options.tps b/source/core/types/ut_coverage_options.tps index bcdbc0b32..d6e86b653 100644 --- a/source/core/types/ut_coverage_options.tps +++ b/source/core/types/ut_coverage_options.tps @@ -16,9 +16,18 @@ create or replace type ut_coverage_options force as object ( limitations under the License. */ + coverage_run_id raw(32), schema_names ut_varchar2_rows, exclude_objects ut_object_names, include_objects ut_object_names, - file_mappings ut_file_mappings + file_mappings ut_file_mappings, + constructor function ut_coverage_options( + self in out nocopy ut_coverage_options, + coverage_run_id raw, + schema_names ut_varchar2_rows := null, + exclude_objects ut_varchar2_rows := null, + include_objects ut_varchar2_rows := null, + file_mappings ut_file_mappings := null + ) return self as result ) / diff --git a/source/core/types/ut_run.tpb b/source/core/types/ut_run.tpb index bff16dc69..395b164f0 100644 --- a/source/core/types/ut_run.tpb +++ b/source/core/types/ut_run.tpb @@ -18,12 +18,9 @@ create or replace type body ut_run as constructor function ut_run( self in out nocopy ut_run, - a_items ut_suite_items, + a_items ut_suite_items := null, a_run_paths ut_varchar2_list := null, - a_schema_names ut_varchar2_rows := null, - a_exclude_objects ut_object_names := null, - a_include_objects ut_object_names := null, - a_project_file_mappings ut_file_mappings := null, + a_coverage_options ut_coverage_options := null, a_test_file_mappings ut_file_mappings := null, a_client_character_set varchar2 := null, a_random_test_order_seed positive := null, @@ -38,12 +35,7 @@ create or replace type body ut_run as self.random_test_order_seed := a_random_test_order_seed; self.results_count := ut_results_counter(); self.test_file_mappings := coalesce(a_test_file_mappings, ut_file_mappings()); - self.coverage_options := ut_coverage_options( - a_schema_names, - a_exclude_objects, - a_include_objects, - a_project_file_mappings - ); + self.coverage_options := a_coverage_options; return; end; diff --git a/source/core/types/ut_run.tps b/source/core/types/ut_run.tps index 2a4e11656..617347b25 100644 --- a/source/core/types/ut_run.tps +++ b/source/core/types/ut_run.tps @@ -28,12 +28,9 @@ create or replace type ut_run under ut_suite_item ( random_test_order_seed number(38,0), constructor function ut_run( self in out nocopy ut_run, - a_items ut_suite_items, + a_items ut_suite_items := null, a_run_paths ut_varchar2_list := null, - a_schema_names ut_varchar2_rows := null, - a_exclude_objects ut_object_names := null, - a_include_objects ut_object_names := null, - a_project_file_mappings ut_file_mappings := null, + a_coverage_options ut_coverage_options := null, a_test_file_mappings ut_file_mappings := null, a_client_character_set varchar2 := null, a_random_test_order_seed positive := null, diff --git a/source/core/ut_utils.pkb b/source/core/ut_utils.pkb index 6bceb5261..c6a1b0657 100644 --- a/source/core/ut_utils.pkb +++ b/source/core/ut_utils.pkb @@ -229,6 +229,19 @@ create or replace package body ut_utils is return l_result; end; + function string_table_to_table(a_list ut_varchar2_list, a_delimiter varchar2:= chr(10), a_skip_leading_delimiter varchar2 := 'N') return ut_varchar2_list is + l_result ut_varchar2_list; + begin + if a_delimiter is null then + l_result := a_list; + elsif a_list is not empty then + for i in 1 .. a_list.count loop + ut_utils.append_to_list(l_result, ut_utils.string_to_table(a_list(i), a_delimiter, a_skip_leading_delimiter) ); + end loop; + end if; + return l_result; + end; + function clob_to_table(a_clob clob, a_max_amount integer := 8191, a_delimiter varchar2:= chr(10)) return ut_varchar2_list is l_offset integer := 1; l_length integer := dbms_lob.getlength(a_clob); @@ -369,6 +382,19 @@ create or replace package body ut_utils is end if; end; + procedure append_to_list(a_list in out nocopy ut_varchar2_list, a_items ut_varchar2_list) is + begin + if a_items is not null then + if a_list is null then + a_list := ut_varchar2_list(); + end if; + for i in 1 .. a_items.count loop + a_list.extend; + a_list(a_list.last) := a_items(i); + end loop; + end if; + end; + procedure append_to_list(a_list in out nocopy ut_varchar2_rows, a_item clob) is begin append_to_list( @@ -479,13 +505,6 @@ create or replace package body ut_utils is return l_xpath; end; - procedure cleanup_session_temp_tables is - begin - execute immediate 'truncate table dbmspcc_blocks'; - execute immediate 'truncate table dbmspcc_units'; - execute immediate 'truncate table dbmspcc_runs'; - end; - function to_version(a_version_no varchar2) return t_version is l_result t_version; c_version_part_regex constant varchar2(20) := '[0-9]+'; diff --git a/source/core/ut_utils.pks b/source/core/ut_utils.pks index ec8781391..8d3093108 100644 --- a/source/core/ut_utils.pks +++ b/source/core/ut_utils.pks @@ -216,8 +216,10 @@ create or replace package ut_utils authid definer is * * Splits a given string into table of string by delimiter. * The delimiter gets removed. - * If null passed as any of the parameters, empty table is returned. - * If no occurence of a_delimiter found in a_text then text is returned as a single row of the table. + * If null a_string passed, empty table is returned. + * If null a_delimiter passed, a_string is returned as element of result table. + * If null a_skip_leading_delimiter, it defaults to 'N' + * If no occurrence of a_delimiter found in a_text then text is returned as a single row of the table. * If no text between delimiters found then an empty row is returned, example: * string_to_table( 'a,,b', ',' ) gives table ut_varchar2_list( 'a', null, 'b' ); * @@ -229,14 +231,36 @@ create or replace package ut_utils authid definer is */ function string_to_table(a_string varchar2, a_delimiter varchar2:= chr(10), a_skip_leading_delimiter varchar2 := 'N') return ut_varchar2_list; + /** + * + * Splits each string in table of string into a table of string using specified delimiter. + * The delimiter gets removed. + * If null a_delimiter passed, a_list is returned as-is. + * If null a_list passed, empty table is returned. + * If null a_skip_leading_delimiter, it defaults to 'N' + * If no occurrence of a_delimiter found in a_text then text is returned as a single row of the table. + * If no text between delimiters found then an empty row is returned, example: + * string_table_to_table( a_list => ut_varchar2_list('x','y',null,'a,,b'), a_delimiter=>',' ) gives table ut_varchar2_list( 'x', 'y', null, 'a', null, 'b' ); + * + * @param a_list the table of texts to be split. + * @param a_delimiter the delimiter character or string + * @param a_skip_leading_delimiter determines if the leading delimiter should be ignored, used by clob_to_table + * + * @return table of varchar2 values + */ + function string_table_to_table(a_list ut_varchar2_list, a_delimiter varchar2:= chr(10), a_skip_leading_delimiter varchar2 := 'N') return ut_varchar2_list; + /** * Splits a given string into table of string by delimiter. * Default value of a_max_amount is 8191 because of code can contains multibyte character. * The delimiter gets removed. - * If null passed as any of the parameters, empty table is returned. + * If null a_clob passed, empty table is returned. + * If null a_delimiter passed, a_string is returned as element of result table. + * If null a_skip_leading_delimiter, it defaults to 'N' + * If no occurrence of a_delimiter found in a_text then text is returned as a single row of the table. * If split text is longer than a_max_amount it gets split into pieces of a_max_amount. * If no text between delimiters found then an empty row is returned, example: - * string_to_table( 'a,,b', ',' ) gives table ut_varchar2_list( 'a', null, 'b' ); + * clob_to_table( 'a,,b', ',' ) gives table ut_varchar2_list( 'a', null, 'b' ); * * @param a_clob the text to be split. * @param a_delimiter the delimiter character or string (default chr(10) ) @@ -287,6 +311,11 @@ create or replace package ut_utils authid definer is */ procedure append_to_list(a_list in out nocopy ut_varchar2_rows, a_items ut_varchar2_rows); + /** + * Append a list of items to the end of ut_varchar2_list + */ + procedure append_to_list(a_list in out nocopy ut_varchar2_list, a_items ut_varchar2_list); + procedure append_to_clob(a_src_clob in out nocopy clob, a_clob_table t_clob_tab, a_delimiter varchar2 := chr(10)); procedure append_to_clob(a_src_clob in out nocopy clob, a_new_data clob); @@ -299,12 +328,6 @@ create or replace package ut_utils authid definer is function to_xpath(a_list ut_varchar2_list, a_ancestors varchar2 := '/*/') return varchar2; - /* - * Truncates session-level GTT's (on commit preserve rows) - * IMPORTANT: Procedure will do an implicit commit when called - */ - procedure cleanup_session_temp_tables; - /** * Converts version string into version record * diff --git a/source/create_grants.sql b/source/create_grants.sql index 4553c52f6..db26faa24 100644 --- a/source/create_grants.sql +++ b/source/create_grants.sql @@ -61,6 +61,7 @@ grant execute on &&ut3_owner..ut_file_mapper to &ut3_user; grant execute on &&ut3_owner..ut_suite_items_info to &ut3_user; grant execute on &&ut3_owner..ut_suite_item_info to &ut3_user; grant execute on &&ut3_owner..ut_run_info to &ut3_user; +grant execute on &&ut3_owner..ut_coverage_options to &ut3_user; --generic types grant execute on &&ut3_owner..ut_varchar2_list to &ut3_user; @@ -133,6 +134,7 @@ grant execute on &&ut3_owner..ut_suite_cache_rows to &ut3_user; grant select, insert, delete, update on &&ut3_owner..dbmspcc_blocks to &ut3_user; grant select, insert, delete, update on &&ut3_owner..dbmspcc_runs to &ut3_user; grant select, insert, delete, update on &&ut3_owner..dbmspcc_units to &ut3_user; +grant select on &&ut3_owner..ut_coverage_runs to &ut3_user; grant execute on &&ut3_owner..ut_matcher_options to &ut3_user; grant execute on &&ut3_owner..ut_matcher_options_items to &ut3_user; diff --git a/source/create_synonyms.sql b/source/create_synonyms.sql index 425ca57a6..3f18ba3ed 100644 --- a/source/create_synonyms.sql +++ b/source/create_synonyms.sql @@ -77,6 +77,7 @@ create &action_type. synonym &ut3_user.ut_file_mapper for &&ut3_owner..ut_file_m create &action_type. synonym &ut3_user.ut_suite_items_info for &&ut3_owner..ut_suite_items_info; create &action_type. synonym &ut3_user.ut_suite_item_info for &&ut3_owner..ut_suite_item_info; create &action_type. synonym &ut3_user.ut_run_info for &&ut3_owner..ut_run_info; +create &action_type. synonym &ut3_user.ut_coverage_options for &&ut3_owner..ut_coverage_options; --generic types create &action_type. synonym &ut3_user.ut_varchar2_list for &&ut3_owner..ut_varchar2_list; diff --git a/source/install.sql b/source/install.sql index 253b13fb2..3249e3e49 100644 --- a/source/install.sql +++ b/source/install.sql @@ -177,6 +177,7 @@ prompt Installing DBMSPLSQL Tables objects into &&ut3_owner schema --gathering coverage @@install_component.sql 'core/coverage/ut_coverage_sources_tmp.sql' +@@install_component.sql 'core/coverage/ut_coverage_runs.sql' @@install_component.sql 'core/coverage/ut_coverage_helper.pks' @@install_component.sql 'core/coverage/ut_coverage_helper_block.pks' @@install_component.sql 'core/coverage/ut_coverage_helper_profiler.pks' @@ -199,6 +200,7 @@ prompt Installing DBMSPLSQL Tables objects into &&ut3_owner schema @@install_component.sql 'core/types/ut_logical_suite.tpb' @@install_component.sql 'core/types/ut_suite.tpb' @@install_component.sql 'core/types/ut_suite_context.tpb' +@@install_component.sql 'core/types/ut_coverage_options.tpb' @@install_component.sql 'core/types/ut_run.tpb' @@install_component.sql 'core/types/ut_expectation_result.tpb' @@install_component.sql 'core/types/ut_reporter_base.tpb' diff --git a/source/reporters/ut_coverage_cobertura_reporter.tpb b/source/reporters/ut_coverage_cobertura_reporter.tpb index eed8e8e73..2b34193ce 100644 --- a/source/reporters/ut_coverage_cobertura_reporter.tpb +++ b/source/reporters/ut_coverage_cobertura_reporter.tpb @@ -70,7 +70,7 @@ create or replace type body ut_coverage_cobertura_reporter is ) return ut_varchar2_rows is l_file_part varchar2(32767); l_result ut_varchar2_rows := ut_varchar2_rows(); - l_unit ut_coverage.t_full_name; + l_unit ut_coverage.t_object_name; l_obj_name ut_coverage.t_object_name; c_coverage_def constant varchar2(200) := ''; c_file_footer constant varchar2(30) := ''; diff --git a/source/reporters/ut_coverage_report_html_helper.pkb b/source/reporters/ut_coverage_report_html_helper.pkb index 00a53c4c6..d673a7f6c 100644 --- a/source/reporters/ut_coverage_report_html_helper.pkb +++ b/source/reporters/ut_coverage_report_html_helper.pkb @@ -287,7 +287,7 @@ create or replace package body ut_coverage_report_html_helper is l_coverage_pct number(5, 2); l_time_str varchar2(50); l_using varchar2(1000); - l_unit ut_coverage.t_full_name; + l_unit ut_coverage.t_object_name; l_charset varchar2(1000); begin l_charset := coalesce(upper(a_charset),'UTF-8'); diff --git a/source/reporters/ut_coverage_sonar_reporter.tpb b/source/reporters/ut_coverage_sonar_reporter.tpb index bfe0d890b..68f4a7989 100644 --- a/source/reporters/ut_coverage_sonar_reporter.tpb +++ b/source/reporters/ut_coverage_sonar_reporter.tpb @@ -61,7 +61,7 @@ create or replace type body ut_coverage_sonar_reporter is a_run ut_run ) return ut_varchar2_rows is l_result ut_varchar2_rows := ut_varchar2_rows(); - l_unit ut_coverage.t_full_name; + l_unit ut_coverage.t_object_name; c_coverage_header constant varchar2(30) := ''; c_file_footer constant varchar2(30) := ''; c_coverage_footer constant varchar2(30) := ''; diff --git a/source/reporters/ut_coveralls_reporter.tpb b/source/reporters/ut_coveralls_reporter.tpb index 1ca317c69..f2cb73abe 100644 --- a/source/reporters/ut_coveralls_reporter.tpb +++ b/source/reporters/ut_coveralls_reporter.tpb @@ -62,7 +62,7 @@ create or replace type body ut_coveralls_reporter is a_coverage_data ut_coverage.t_coverage ) return ut_varchar2_rows is l_result ut_varchar2_rows := ut_varchar2_rows(); - l_unit ut_coverage.t_full_name; + l_unit ut_coverage.t_object_name; c_coverage_header constant varchar2(30) := '{"source_files":['; c_coverage_footer constant varchar2(30) := ']}'||chr(10)||' '; begin diff --git a/source/uninstall_coverage_tables.sql b/source/uninstall_coverage_tables.sql index 8de75b51e..890aa7090 100644 --- a/source/uninstall_coverage_tables.sql +++ b/source/uninstall_coverage_tables.sql @@ -11,7 +11,7 @@ begin and owner = sys_context( 'USERENV', 'CURRENT_SCHEMA' ) ) loop - execute immediate 'drop table '||to_be_dopped.table_name||' cascade constraints'; + execute immediate 'drop table '||to_be_dopped.table_name||' cascade constraints purge'; dbms_output.put_line('Table '||to_be_dopped.table_name||' dropped'); end loop; end; diff --git a/source/uninstall_objects.sql b/source/uninstall_objects.sql index c905153f4..230e394ee 100644 --- a/source/uninstall_objects.sql +++ b/source/uninstall_objects.sql @@ -74,6 +74,8 @@ drop package ut_coverage_helper; drop table ut_coverage_sources_tmp purge; +drop table ut_coverage_runs purge; + drop package ut_teamcity_reporter_helper; drop package ut_runner; @@ -196,7 +198,7 @@ drop table ut_compound_data_tmp purge; drop table ut_compound_data_diff_tmp purge; -drop table ut_json_data_diff_tmp; +drop table ut_json_data_diff_tmp purge; drop package ut_annotation_manager; diff --git a/test/install_ut3_tester_helper.sql b/test/install_ut3_tester_helper.sql index c0c20634e..9841252a0 100644 --- a/test/install_ut3_tester_helper.sql +++ b/test/install_ut3_tester_helper.sql @@ -29,6 +29,7 @@ alter session set plsql_optimize_level=0; @@ut3_tester_helper/annotation_cache_helper.pks @@ut3_tester_helper/annotation_cache_helper.pkb create or replace synonym ut3_tester.annotation_cache_helper for ut3_tester_helper.annotation_cache_helper; +create or replace synonym ut3$user#.coverage_helper for ut3_tester_helper.coverage_helper; set linesize 200 set define on diff --git a/test/install_ut3_user_tests.sql b/test/install_ut3_user_tests.sql index 05f2634e8..e790293c8 100644 --- a/test/install_ut3_user_tests.sql +++ b/test/install_ut3_user_tests.sql @@ -42,16 +42,16 @@ set define off @@ut3_user/reporters/test_debug_reporter.pks @@ut3_user/reporters/test_realtime_reporter.pks @@ut3_user/reporters/test_coverage.pks +@@ut3_user/reporters/test_coverage/test_coverage_standalone.pks set define on -@@install_above_12_1.sql 'ut3_user/reporters/test_extended_coverage.pks' -@@install_above_12_1.sql 'ut3_user/reporters/test_coverage/test_html_extended_reporter.pks' +@@ut3_user/reporters/test_coverage/test_extended_coverage.pks +@@ut3_user/reporters/test_coverage/test_html_coverage_reporter.pks set define off @@ut3_user/reporters/test_coverage/test_coveralls_reporter.pks @@ut3_user/reporters/test_coverage/test_cov_cobertura_reporter.pks @@ut3_user/reporters/test_coverage/test_coverage_sonar_reporter.pks set define on -@@install_below_12_2.sql 'ut3_user/reporters/test_proftab_coverage.pks' -@@install_below_12_2.sql 'ut3_user/reporters/test_coverage/test_html_proftab_reporter.pks' +@@ut3_user/reporters/test_coverage/test_proftab_coverage.pks set define off @@ut3_user/test_user.pkb @@ -82,17 +82,16 @@ set define off @@ut3_user/reporters/test_documentation_reporter.pkb @@ut3_user/reporters/test_debug_reporter.pkb @@ut3_user/reporters/test_realtime_reporter.pkb -@@ut3_user/reporters/test_coverage.pkb +@@ut3_user/reporters/test_coverage/test_coverage_standalone.pkb set define on -@@install_above_12_1.sql 'ut3_user/reporters/test_extended_coverage.pkb' -@@install_above_12_1.sql 'ut3_user/reporters/test_coverage/test_html_extended_reporter.pkb' +@@ut3_user/reporters/test_coverage/test_extended_coverage.pkb +@@ut3_user/reporters/test_coverage/test_html_coverage_reporter.pkb set define off @@ut3_user/reporters/test_coverage/test_coveralls_reporter.pkb @@ut3_user/reporters/test_coverage/test_cov_cobertura_reporter.pkb @@ut3_user/reporters/test_coverage/test_coverage_sonar_reporter.pkb set define on -@@install_below_12_2.sql 'ut3_user/reporters/test_proftab_coverage.pkb' -@@install_below_12_2.sql 'ut3_user/reporters/test_coverage/test_html_proftab_reporter.pkb' +@@ut3_user/reporters/test_coverage/test_proftab_coverage.pkb set define off diff --git a/test/ut3_tester/core/test_output_buffer.pkb b/test/ut3_tester/core/test_output_buffer.pkb index a552cc567..2e8b3337c 100644 --- a/test/ut3_tester/core/test_output_buffer.pkb +++ b/test/ut3_tester/core/test_output_buffer.pkb @@ -132,7 +132,7 @@ create or replace package body test_output_buffer is --Assert -- Data in "fresh" buffer remains ut.expect( l_fresh_buffer.get_lines_cursor(0,0), l_buffer.self_type ).to_have_count(1); - -- Data in "slate" buffer is purged and so the call to get_lines_cursor throws ORA-20218 + -- Data in "stale" buffer is purged and so the call to get_lines_cursor throws ORA-20218 ut.expect( l_stale_buffer.get_lines_cursor(0,0), l_buffer.self_type ).to_be_empty(); end; diff --git a/test/ut3_tester/core/test_ut_executable.pkb b/test/ut3_tester/core/test_ut_executable.pkb index 337095607..e27a2e432 100644 --- a/test/ut3_tester/core/test_ut_executable.pkb +++ b/test/ut3_tester/core/test_ut_executable.pkb @@ -51,36 +51,6 @@ create or replace package body test_ut_executable is ut.expect(l_executable.get_error_stack_trace()).to_be_like('ORA-06501: PL/SQL: program error%'); end; - procedure modify_stateful_package is - l_job_name varchar2(30) := 'recreate_stateful_package'; - l_cnt integer := 1; - pragma autonomous_transaction; - begin - dbms_scheduler.create_job( - job_name => l_job_name, - job_type => 'PLSQL_BLOCK', - job_action => q'/ - begin - execute immediate q'[ - create or replace package stateful_package as - g_state varchar2(3) := 'abc'; - end;]'; - end;/', - start_date => localtimestamp, - enabled => TRUE, - auto_drop => TRUE, - comments => 'one-time job' - ); - $if dbms_db_version.version >= 18 $then - dbms_session.sleep(0.4); - $else - dbms_lock.sleep(0.4); - $end - while l_cnt > 0 loop - l_cnt:=ut3_tester_helper.main_helper.get_job_count(l_job_name); - end loop; - end; - procedure form_name is begin ut.expect(ut3_develop.ut_executable_test( user, ' package ', 'proc', null ).form_name()).to_equal(user||'.package.proc'); diff --git a/test/ut3_tester/core/test_ut_test.pks b/test/ut3_tester/core/test_ut_test.pks index 18ea6613f..caf75eb6c 100644 --- a/test/ut3_tester/core/test_ut_test.pks +++ b/test/ut3_tester/core/test_ut_test.pks @@ -29,7 +29,7 @@ create or replace package test_ut_test is --%test(Fails test when aftereach procedure name invalid) procedure after_each_proc_name_invalid; - --%test(Tails test when aftereach procedure name null) + --%test(Fails test when aftereach procedure name null) procedure after_each_procedure_name_null; procedure create_app_info_package; diff --git a/test/ut3_tester_helper/coverage_helper.pkb b/test/ut3_tester_helper/coverage_helper.pkb index e86a155fa..9b595a0b3 100644 --- a/test/ut3_tester_helper/coverage_helper.pkb +++ b/test/ut3_tester_helper/coverage_helper.pkb @@ -1,175 +1,94 @@ create or replace package body coverage_helper is - g_run_ids ut3_develop.ut_coverage.tt_coverage_id_arr; - g_profiler_run_id integer; - g_block_run_id integer; + g_job_no integer := 0; - function get_mock_proftab_run_id return integer is - v_result integer; + function block_coverage_available return boolean is begin - select nvl(min(runid),0) - 1 into v_result - from ut3_develop.plsql_profiler_runs; - return v_result; - end; - - function get_mock_block_run_id return integer is - v_result integer; - begin - select nvl(min(run_id),0) - 1 into v_result - from ut3_develop.dbmspcc_runs; - return v_result; + $if dbms_db_version.version = 12 and dbms_db_version.release >= 2 or dbms_db_version.version > 12 $then + return true; + $else + return false; + $end end; - procedure setup_mock_coverage_ids(a_profiler_run_id integer, a_block_run_id integer) is - l_coverage_ids ut3_develop.ut_coverage.tt_coverage_id_arr; + function covered_package_name return varchar2 is begin - l_coverage_ids(ut3_develop.ut_coverage.gc_proftab_coverage) := a_profiler_run_id; - l_coverage_ids(ut3_develop.ut_coverage.gc_block_coverage) := a_block_run_id; - ut3_develop.ut_coverage.mock_coverage_id(l_coverage_ids); + $if dbms_db_version.version = 12 and dbms_db_version.release >= 2 or dbms_db_version.version > 12 $then + return 'dummy_coverage_package_with_an_amazingly_long_name_that_you_would_not_think_of_in_real_life_project_because_its_simply_too_long'; + $else + return 'dummy_coverage'; + $end end; - procedure setup_mock_coverage_id is + function substitute_covered_package( a_text varchar2, a_substitution varchar2 ) return varchar2 is begin - g_profiler_run_id := get_mock_proftab_run_id(); - g_block_run_id := get_mock_block_run_id(); - setup_mock_coverage_ids(g_profiler_run_id, g_block_run_id); + return replace( replace( a_text, a_substitution, covered_package_name() ), upper(a_substitution), upper(covered_package_name()) ); end; - procedure setup_dummy_coverage is - pragma autonomous_transaction; - begin - create_dummy_12_2_cov_pck(); - create_dummy_12_2_cov_test(); - grant_exec_on_12_2_cov(); - - g_profiler_run_id := get_mock_proftab_run_id(); - g_block_run_id := get_mock_block_run_id(); - setup_mock_coverage_ids(g_profiler_run_id, g_block_run_id); - - mock_block_coverage_data(g_block_run_id, user); - mock_profiler_coverage_data(g_profiler_run_id, user); - commit; - end; - - procedure mock_coverage_data(a_user in varchar2) is - c_unit_id constant integer := 1; - begin - insert into ut3_develop.plsql_profiler_runs ( runid, run_owner, run_date, run_comment) - values(g_profiler_run_id, a_user, sysdate, 'unit testing utPLSQL'); - - insert into ut3_develop.plsql_profiler_units ( runid, unit_number, unit_type, unit_owner, unit_name) - values(g_profiler_run_id, c_unit_id, 'PACKAGE BODY', 'UT3_DEVELOP', 'DUMMY_COVERAGE'); - - insert into ut3_develop.plsql_profiler_data ( runid, unit_number, line#, total_occur, total_time) - select g_profiler_run_id, c_unit_id, 4, 1, 1 from dual union all - select g_profiler_run_id, c_unit_id, 5, 0, 0 from dual union all - select g_profiler_run_id, c_unit_id, 7, 1, 1 from dual; - end; - - procedure cleanup_dummy_coverage(a_run_id in integer) is - pragma autonomous_transaction; - begin - delete from ut3_develop.plsql_profiler_data where runid = a_run_id; - delete from ut3_develop.plsql_profiler_units where runid = a_run_id; - delete from ut3_develop.plsql_profiler_runs where runid = a_run_id; - commit; - end; - - procedure cleanup_dummy_coverage(a_block_id in integer, a_prof_id in integer) is - pragma autonomous_transaction; + procedure set_develop_mode is begin - begin execute immediate q'[drop package ut3_develop.test_block_dummy_coverage]'; exception when others then null; end; - begin execute immediate q'[drop package ut3_develop.dummy_coverage_package_with_an_amazingly_long_name_that_you_would_not_think_of_in_real_life_project_because_its_simply_too_long]'; exception when others then null; end; - delete from dbmspcc_blocks where run_id = a_block_id; - delete from dbmspcc_units where run_id = a_block_id; - delete from dbmspcc_runs where run_id = a_block_id; - cleanup_dummy_coverage(a_prof_id); - commit; + ut3_develop.ut_coverage.set_develop_mode(true); end; - procedure cleanup_dummy_coverage is - begin - cleanup_dummy_coverage( - g_block_run_id, - g_profiler_run_id - ); - end; - procedure create_dummy_coverage_package is + procedure create_dummy_coverage is pragma autonomous_transaction; begin - execute immediate q'[create or replace package UT3_DEVELOP.DUMMY_COVERAGE is - procedure do_stuff; - - procedure grant_myself; + execute immediate q'[create or replace package ut3_develop.]'||covered_package_name||q'[ is + procedure do_stuff(i_input in number); end;]'; - execute immediate q'[create or replace package body UT3_DEVELOP.DUMMY_COVERAGE is - procedure do_stuff is + + execute immediate q'[create or replace package body ut3_develop.]'||covered_package_name||q'[ is + procedure do_stuff(i_input in number) is begin - if 1 = 2 then - dbms_output.put_line('should not get here'); + if i_input = 2 then dbms_output.put_line('should not get here'); elsif i_input = 1 then dbms_output.put_line('should get here'); else - dbms_output.put_line('should get here'); + dbms_output.put_line('should not get here'); end if; end; - - procedure grant_myself is - begin - execute immediate 'grant debug,execute on UT3_DEVELOP.DUMMY_COVERAGE to ut3$user#'; - end; end;]'; - - end; - procedure create_dummy_coverage_test is - pragma autonomous_transaction; - begin - execute immediate q'[create or replace package UT3_DEVELOP.TEST_DUMMY_COVERAGE is + execute immediate q'[create or replace package ut3_develop.test_dummy_coverage is --%suite(dummy coverage test) --%suitepath(coverage_testing) --%test procedure test_do_stuff; - - procedure grant_myself; + + --%test + procedure zero_coverage; end;]'; - execute immediate q'[create or replace package body UT3_DEVELOP.TEST_DUMMY_COVERAGE is + + execute immediate q'[create or replace package body ut3_develop.test_dummy_coverage is procedure test_do_stuff is begin - dummy_coverage.do_stuff; + ]'||covered_package_name||q'[.do_stuff(1); + ut.expect(1).to_equal(1); end; - - procedure grant_myself is + procedure zero_coverage is begin - execute immediate 'grant debug,execute on UT3_DEVELOP.TEST_DUMMY_COVERAGE to ut3$user#'; + null; end; end;]'; - - end; - - procedure grant_exec_on_cov is - pragma autonomous_transaction; - begin - execute immediate 'begin UT3_DEVELOP.DUMMY_COVERAGE.grant_myself(); end;'; - execute immediate 'begin UT3_DEVELOP.TEST_DUMMY_COVERAGE.grant_myself(); end;'; + end; - - procedure drop_dummy_coverage_pkg is + + procedure drop_dummy_coverage is pragma autonomous_transaction; begin - begin execute immediate q'[drop package ut3_develop.test_dummy_coverage]'; exception when others then null; end; - begin execute immediate q'[drop package ut3_develop.dummy_coverage]'; exception when others then null; end; + begin execute immediate q'[drop package ut3_develop.test_dummy_coverage]'; exception when others then null; end; + begin execute immediate q'[drop package ut3_develop.]'||covered_package_name; exception when others then null; end; end; - procedure create_dummy_coverage_test_1 is + procedure create_dummy_coverage_1 is pragma autonomous_transaction; begin - execute immediate q'[create or replace package UT3_DEVELOP.DUMMY_COVERAGE_1 is + execute immediate q'[create or replace package ut3_develop.dummy_coverage_1 is procedure do_stuff; - procedure grant_myself; end;]'; - execute immediate q'[create or replace package body UT3_DEVELOP.DUMMY_COVERAGE_1 is + + execute immediate q'[create or replace package body ut3_develop.dummy_coverage_1 is procedure do_stuff is begin if 1 = 2 then @@ -178,141 +97,153 @@ create or replace package body coverage_helper is dbms_output.put_line('should get here'); end if; end; - - procedure grant_myself is - begin - execute immediate 'grant debug,execute on UT3_DEVELOP.DUMMY_COVERAGE_1 to ut3$user#'; - end; - end;]'; - execute immediate q'[create or replace package UT3_DEVELOP.TEST_DUMMY_COVERAGE_1 is + + execute immediate q'[create or replace package ut3_develop.test_dummy_coverage_1 is --%suite(dummy coverage test 1) --%suitepath(coverage_testing) --%test procedure test_do_stuff; - - procedure grant_myself; end;]'; - execute immediate q'[create or replace package body UT3_DEVELOP.TEST_DUMMY_COVERAGE_1 is + + execute immediate q'[create or replace package body ut3_develop.test_dummy_coverage_1 is procedure test_do_stuff is begin dummy_coverage_1.do_stuff; end; - procedure grant_myself is - begin - execute immediate 'grant debug,execute on UT3_DEVELOP.TEST_DUMMY_COVERAGE_1 to ut3$user#'; - end; - end;]'; - execute immediate 'begin UT3_DEVELOP.DUMMY_COVERAGE_1.grant_myself(); end;'; - execute immediate 'begin UT3_DEVELOP.TEST_DUMMY_COVERAGE_1.grant_myself(); end;'; end; - procedure drop_dummy_coverage_test_1 is + procedure drop_dummy_coverage_1 is pragma autonomous_transaction; begin - execute immediate q'[drop package UT3_DEVELOP.DUMMY_COVERAGE_1]'; - execute immediate q'[drop package UT3_DEVELOP.TEST_DUMMY_COVERAGE_1]'; + begin execute immediate q'[drop package ut3_develop.dummy_coverage_1]'; exception when others then null; end; + begin execute immediate q'[drop package ut3_develop.test_dummy_coverage_1]'; exception when others then null; end; end; - --12.2 Setup - procedure create_dummy_12_2_cov_pck is - pragma autonomous_transaction; + procedure run_standalone_coverage(a_coverage_run_id raw, a_input integer) is begin - execute immediate q'[create or replace package UT3_DEVELOP.DUMMY_COVERAGE_PACKAGE_WITH_AN_AMAZINGLY_LONG_NAME_THAT_YOU_WOULD_NOT_THINK_OF_IN_REAL_LIFE_PROJECT_BECAUSE_ITS_SIMPLY_TOO_LONG is - procedure do_stuff(i_input in number); - - procedure grant_myself; - end;]'; - execute immediate q'[create or replace package body UT3_DEVELOP.DUMMY_COVERAGE_PACKAGE_WITH_AN_AMAZINGLY_LONG_NAME_THAT_YOU_WOULD_NOT_THINK_OF_IN_REAL_LIFE_PROJECT_BECAUSE_ITS_SIMPLY_TOO_LONG is - procedure do_stuff(i_input in number) is - begin - if i_input = 2 then - dbms_output.put_line('should not get here'); - else - dbms_output.put_line('should get here'); - end if; - end; - - procedure grant_myself is - begin - execute immediate 'grant debug,execute on UT3_DEVELOP.DUMMY_COVERAGE_PACKAGE_WITH_AN_AMAZINGLY_LONG_NAME_THAT_YOU_WOULD_NOT_THINK_OF_IN_REAL_LIFE_PROJECT_BECAUSE_ITS_SIMPLY_TOO_LONG to ut3$user#'; - end; - - end;]'; + ut3_develop.ut_runner.coverage_start(a_coverage_run_id); + execute immediate 'begin ut3_develop.'||covered_package_name||'.do_stuff(:a_input); end;' using in a_input; + ut3_develop.ut_runner.coverage_stop(); end; - procedure create_dummy_12_2_cov_test is - pragma autonomous_transaction; + function get_job_status(a_job_name varchar2, a_job_started_after timestamp with time zone) return varchar2 is + l_status varchar2(1000); begin - execute immediate q'[create or replace package UT3_DEVELOP.TEST_BLOCK_DUMMY_COVERAGE is - --%suite(dummy coverage test) - --%suitepath(coverage_testing) - - --%test - procedure test_do_stuff; - - procedure grant_myself; - - end;]'; - execute immediate q'[create or replace package body UT3_DEVELOP.TEST_BLOCK_DUMMY_COVERAGE is - procedure test_do_stuff is - begin - dummy_coverage_package_with_an_amazingly_long_name_that_you_would_not_think_of_in_real_life_project_because_its_simply_too_long.do_stuff(1); - ut.expect(1).to_equal(1); - end; - - procedure grant_myself is - begin - execute immediate 'grant debug,execute on UT3_DEVELOP.TEST_BLOCK_DUMMY_COVERAGE to ut3$user#'; - end; - end;]'; + begin + select status into l_status + from user_scheduler_job_run_details + where job_name = upper(a_job_name) + and req_start_date >= a_job_started_after; + exception + when no_data_found then + null; + end; + return l_status; end; - procedure mock_block_coverage_data(a_run_id integer,a_user in varchar2) is - c_unit_id constant integer := 1; + procedure sleep(a_time number) is begin - insert into dbmspcc_runs ( run_id, run_owner, run_timestamp, run_comment) - values(a_run_id, a_user, sysdate, 'unit testing utPLSQL'); - - insert into dbmspcc_units ( run_id, object_id, type, owner, name,last_ddl_time) - values(a_run_id, c_unit_id, 'PACKAGE BODY', 'UT3_DEVELOP', 'DUMMY_COVERAGE_PACKAGE_WITH_AN_AMAZINGLY_LONG_NAME_THAT_YOU_WOULD_NOT_THINK_OF_IN_REAL_LIFE_PROJECT_BECAUSE_ITS_SIMPLY_TOO_LONG',sysdate); + $if dbms_db_version.version >= 18 $then + dbms_session.sleep(a_time); + $else + dbms_lock.sleep(a_time ); + $end + end; - insert into dbmspcc_blocks ( run_id, object_id, line,block,col,covered,not_feasible) - select a_run_id, c_unit_id,4,1,1,1,0 from dual union all - select a_run_id, c_unit_id,4,2,2,0,0 from dual union all - select a_run_id, c_unit_id,5,3,0,1,0 from dual union all - select a_run_id, c_unit_id,7,4,1,1,0 from dual; + procedure run_job_and_wait_for_finish(a_job_action varchar2) is + l_status varchar2(1000); + l_job_name varchar2(30); + l_timestamp timestamp with time zone := current_timestamp; + i integer := 0; + pragma autonomous_transaction; + begin + g_job_no := g_job_no + 1; + l_job_name := 'utPLSQL_selftest_job_'||g_job_no; + sleep(0.01); + dbms_scheduler.create_job( + job_name => l_job_name, + job_type => 'PLSQL_BLOCK', + job_action => a_job_action, + start_date => l_timestamp, + enabled => TRUE, + auto_drop => TRUE, + comments => 'one-time-job' + ); + while (l_status is null or l_status not in ('SUCCEEDED','FAILED')) and i < 30 loop + l_status := get_job_status( l_job_name, l_timestamp ); + sleep(0.1); + i := i + 1; + end loop; + commit; + if l_status = 'FAILED' then + raise_application_error(-20000, 'Running a scheduler job failed'); + end if; end; - procedure mock_profiler_coverage_data(a_run_id integer,a_user in varchar2) is - c_unit_id constant integer := 1; + procedure run_coverage_job(a_coverage_run_id raw, a_input integer) is begin - insert into ut3_develop.plsql_profiler_runs ( runid, run_owner, run_date, run_comment) - values(a_run_id, a_user, sysdate, 'unit testing utPLSQL'); + run_job_and_wait_for_finish( + 'begin coverage_helper.run_standalone_coverage('''||a_coverage_run_id||''', '||a_input||'); end;' + ); + end; - insert into ut3_develop.plsql_profiler_units ( runid, unit_number, unit_type, unit_owner, unit_name) - values(a_run_id, c_unit_id, 'PACKAGE BODY', 'UT3_DEVELOP', 'DUMMY_COVERAGE_PACKAGE_WITH_AN_AMAZINGLY_LONG_NAME_THAT_YOU_WOULD_NOT_THINK_OF_IN_REAL_LIFE_PROJECT_BECAUSE_ITS_SIMPLY_TOO_LONG'); + procedure create_test_results_table is + pragma autonomous_transaction; + e_exists exception; + pragma exception_init ( e_exists, -955 ); + begin + execute immediate 'create table test_results (text varchar2(4000))'; + exception + when e_exists then + null; + end; - insert into ut3_develop.plsql_profiler_data ( runid, unit_number, line#, total_occur, total_time) - select a_run_id, c_unit_id, 4, 1, 1 from dual union all - select a_run_id, c_unit_id, 5, 0, 0 from dual union all - select a_run_id, c_unit_id, 6, 1, 0 from dual union all - select a_run_id, c_unit_id, 7, 1, 1 from dual; + procedure drop_test_results_table is + pragma autonomous_transaction; + e_not_exists exception; + pragma exception_init ( e_not_exists, -942 ); + begin + execute immediate 'drop table test_results'; + exception + when e_not_exists then + null; end; - procedure grant_exec_on_12_2_cov is - pragma autonomous_transaction; + function run_code_as_job( a_plsql_block varchar2 ) return clob is + l_result_clob clob; + pragma autonomous_transaction; begin - execute immediate 'begin UT3_DEVELOP.DUMMY_COVERAGE_PACKAGE_WITH_AN_AMAZINGLY_LONG_NAME_THAT_YOU_WOULD_NOT_THINK_OF_IN_REAL_LIFE_PROJECT_BECAUSE_ITS_SIMPLY_TOO_LONG.grant_myself(); end;'; - execute immediate 'begin UT3_DEVELOP.TEST_BLOCK_DUMMY_COVERAGE.grant_myself(); end;'; + run_job_and_wait_for_finish( a_plsql_block ); + + execute immediate q'[ + declare + l_results ut3_develop.ut_varchar2_list; + begin + select * + bulk collect into l_results + from test_results; + delete from test_results; + commit; + :clob_results := ut3_tester_helper.main_helper.table_to_clob(l_results); + end; + ]' + using out l_result_clob; + + return l_result_clob; end; - procedure set_develop_mode is + function run_tests_as_job( a_run_command varchar2 ) return clob is + l_plsql_block varchar2(32767); + l_result_clob clob; + pragma autonomous_transaction; begin - ut3_develop.ut_coverage.set_develop_mode(true); + l_plsql_block := 'begin insert into test_results select * from table( {a_run_command} ); commit; end;'; + l_plsql_block := replace(l_plsql_block,'{a_run_command}',a_run_command); + return run_code_as_job( l_plsql_block ); end; end; diff --git a/test/ut3_tester_helper/coverage_helper.pks b/test/ut3_tester_helper/coverage_helper.pks index c240ed490..b044c897b 100644 --- a/test/ut3_tester_helper/coverage_helper.pks +++ b/test/ut3_tester_helper/coverage_helper.pks @@ -1,34 +1,26 @@ create or replace package coverage_helper is - type prof_runs_tab is table of ut3_develop.plsql_profiler_runs%rowtype; - - function get_mock_proftab_run_id return integer; + function block_coverage_available return boolean; - procedure setup_mock_coverage_id; + function covered_package_name return varchar2; - procedure mock_coverage_data(a_user in varchar2); + function substitute_covered_package( a_text varchar2, a_substitution varchar2 := '{p}' ) return varchar2; - procedure cleanup_dummy_coverage; + procedure set_develop_mode; - procedure setup_dummy_coverage; + procedure create_dummy_coverage; + procedure drop_dummy_coverage; - --Profiler coverage - procedure create_dummy_coverage_package; - procedure create_dummy_coverage_test; - procedure grant_exec_on_cov; - procedure mock_profiler_coverage_data(a_run_id integer,a_user in varchar2); - procedure drop_dummy_coverage_pkg; + procedure create_dummy_coverage_1; + procedure drop_dummy_coverage_1; - procedure create_dummy_coverage_test_1; - procedure drop_dummy_coverage_test_1; + procedure run_standalone_coverage(a_coverage_run_id raw, a_input integer); + procedure run_coverage_job(a_coverage_run_id raw, a_input integer); - --Block coverage - procedure create_dummy_12_2_cov_pck; - procedure create_dummy_12_2_cov_test; - procedure mock_block_coverage_data(a_run_id integer,a_user in varchar2); - procedure grant_exec_on_12_2_cov; + function run_tests_as_job( a_run_command varchar2 ) return clob; + function run_code_as_job( a_plsql_block varchar2 ) return clob; + procedure create_test_results_table; + procedure drop_test_results_table; - procedure set_develop_mode; - end; / diff --git a/test/ut3_tester_helper/main_helper.pkb b/test/ut3_tester_helper/main_helper.pkb index 5c3032b75..76245ea12 100644 --- a/test/ut3_tester_helper/main_helper.pkb +++ b/test/ut3_tester_helper/main_helper.pkb @@ -126,14 +126,6 @@ create or replace package body main_helper is execute immediate 'begin ut3$user#.parse_annotations; end;'; end; - function get_job_count(a_job_name varchar2) return number is - l_cnt number; - begin - select count(1) into l_cnt - from dba_scheduler_running_jobs srj - where srj.job_name = a_job_name; - end; - procedure append_to_list(a_list in out nocopy ut3_develop.ut_varchar2_list, a_item varchar2) is begin ut3_develop.ut_utils.append_to_list(a_list,a_item); diff --git a/test/ut3_tester_helper/main_helper.pks b/test/ut3_tester_helper/main_helper.pks index e675e267e..6dd453446 100644 --- a/test/ut3_tester_helper/main_helper.pks +++ b/test/ut3_tester_helper/main_helper.pks @@ -1,7 +1,7 @@ create or replace package main_helper is - gc_success number := ut3_develop.ut_utils.gc_success; - gc_failure number := ut3_develop.ut_utils.gc_failure; + gc_success number := ut3_develop.ut_utils.gc_success; + gc_failure number := ut3_develop.ut_utils.gc_failure; procedure execute_autonomous(a_sql varchar2); @@ -35,8 +35,6 @@ create or replace package main_helper is procedure parse_dummy_test_as_ut3$user#; - function get_job_count(a_job_name varchar2) return number; - procedure append_to_list(a_list in out nocopy ut3_develop.ut_varchar2_list, a_item varchar2); procedure append_to_list(a_list in out nocopy ut3_develop.ut_varchar2_rows, a_item varchar2); diff --git a/test/ut3_tester_helper/run_helper.pks b/test/ut3_tester_helper/run_helper.pks index 88f55d961..0657c1a51 100644 --- a/test/ut3_tester_helper/run_helper.pks +++ b/test/ut3_tester_helper/run_helper.pks @@ -3,7 +3,6 @@ create or replace package run_helper is g_run_id integer; type t_out_buff_tab is table of ut3_develop.ut_output_buffer_tmp%rowtype; - type prof_runs_tab is table of ut3_develop.plsql_profiler_runs%rowtype; procedure setup_cache_objects; procedure setup_cache_objectstag; diff --git a/test/ut3_user/reporters/test_coverage.pkb b/test/ut3_user/reporters/test_coverage.pkb deleted file mode 100644 index 738ce67e4..000000000 --- a/test/ut3_user/reporters/test_coverage.pkb +++ /dev/null @@ -1,19 +0,0 @@ -create or replace package body test_coverage is - - procedure create_dummy_coverage_pkg is - begin - ut3_tester_helper.coverage_helper.create_dummy_coverage_package(); - ut3_tester_helper.coverage_helper.create_dummy_coverage_test(); - ut3_tester_helper.coverage_helper.grant_exec_on_cov(); - end; - - procedure setup_dummy_coverage is - pragma autonomous_transaction; - begin - ut3_tester_helper.coverage_helper.setup_mock_coverage_id(); - ut3_tester_helper.coverage_helper.mock_coverage_data(user); - commit; - end; - -end; -/ diff --git a/test/ut3_user/reporters/test_coverage.pks b/test/ut3_user/reporters/test_coverage.pks index 4c19e125a..11bc6d480 100644 --- a/test/ut3_user/reporters/test_coverage.pks +++ b/test/ut3_user/reporters/test_coverage.pks @@ -3,15 +3,12 @@ create or replace package test_coverage is --%suite --%suitepath(utplsql.test_user.reporters) - --%beforeall - procedure create_dummy_coverage_pkg; - --%beforeall - procedure setup_dummy_coverage; + --%beforeall(ut3_tester_helper.coverage_helper.create_test_results_table) + --%beforeall(ut3_tester_helper.coverage_helper.create_dummy_coverage) - --%afterall(ut3_tester_helper.coverage_helper.drop_dummy_coverage_pkg) - - --%afterall(ut3_tester_helper.coverage_helper.cleanup_dummy_coverage) + --%afterall(ut3_tester_helper.coverage_helper.drop_dummy_coverage) + --%afterall(ut3_tester_helper.coverage_helper.drop_test_results_table) end; / diff --git a/test/ut3_user/reporters/test_coverage/test_cov_cobertura_reporter.pkb b/test/ut3_user/reporters/test_coverage/test_cov_cobertura_reporter.pkb index 7ae4b6f0d..098405ff9 100644 --- a/test/ut3_user/reporters/test_coverage/test_cov_cobertura_reporter.pkb +++ b/test/ut3_user/reporters/test_coverage/test_cov_cobertura_reporter.pkb @@ -1,100 +1,54 @@ create or replace package body test_cov_cobertura_reporter is procedure report_on_file is - l_results ut3_develop.ut_varchar2_list; l_expected clob; l_actual clob; + l_block_cov clob; + l_name varchar2(250); + l_file_path varchar2(250); begin - --Arrange - l_expected := - q'[ - - - -test/ut3_develop.dummy_coverage.pkb - - - - - - - - - - - - -]'; - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_cobertura_reporter( ), - a_source_files => ut3_develop.ut_varchar2_list( 'test/ut3_develop.dummy_coverage.pkb' ), - a_test_files => ut3_develop.ut_varchar2_list( ) - ) - ); - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); - --Assert - ut.expect(l_actual).to_be_like(l_expected); - end; - procedure report_zero_coverage is - l_results ut3_develop.ut_varchar2_list; - l_expected clob; - l_actual clob; - begin + --Arrange + l_name := ut3_tester_helper.coverage_helper.covered_package_name; + l_file_path := 'test/ut3_develop.'||ut3_tester_helper.coverage_helper.covered_package_name||'.pkb'; + if ut3_tester_helper.coverage_helper.block_coverage_available then + l_block_cov := ''; + else + l_block_cov := ''; + end if; l_expected := q'[ - + -ut3_develop.dummy_coverage +]'||l_file_path||q'[ - - + + - - - - - +]'||l_block_cov||q'[ - - - - - - - - - ]'; - - ut3_tester_helper.coverage_helper.cleanup_dummy_coverage(); --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_cobertura_reporter( ), - a_include_objects => ut3_develop.ut_varchar2_list('UT3_DEVELOP.DUMMY_COVERAGE') - ) - ); - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + q'[ + ut3_develop.ut.run( + a_path => 'ut3_develop.test_dummy_coverage', + a_reporter => ut3_develop.ut_coverage_cobertura_reporter( ), + a_source_files => ut3_develop.ut_varchar2_list( ']'||l_file_path||q'[' ), + a_test_files => ut3_develop.ut_varchar2_list( ) + ) + ]' + ); --Assert ut.expect(l_actual).to_be_like(l_expected); - --Cleanup - test_coverage.setup_dummy_coverage; end; end; diff --git a/test/ut3_user/reporters/test_coverage/test_cov_cobertura_reporter.pks b/test/ut3_user/reporters/test_coverage/test_cov_cobertura_reporter.pks index 0016641d5..365815964 100644 --- a/test/ut3_user/reporters/test_coverage/test_cov_cobertura_reporter.pks +++ b/test/ut3_user/reporters/test_coverage/test_cov_cobertura_reporter.pks @@ -6,8 +6,5 @@ create or replace package test_cov_cobertura_reporter is --%test(reports on a project file mapped to database object) procedure report_on_file; - --%test(reports zero coverage on each line of non-executed database object - Issue #917) - procedure report_zero_coverage; - end test_cov_cobertura_reporter; / diff --git a/test/ut3_user/reporters/test_coverage/test_coverage_sonar_reporter.pkb b/test/ut3_user/reporters/test_coverage/test_coverage_sonar_reporter.pkb index b0cb05a5b..50d7bfe4c 100644 --- a/test/ut3_user/reporters/test_coverage/test_coverage_sonar_reporter.pkb +++ b/test/ut3_user/reporters/test_coverage/test_coverage_sonar_reporter.pkb @@ -1,31 +1,35 @@ create or replace package body test_coverage_sonar_reporter is procedure report_on_file is - l_results ut3_develop.ut_varchar2_list; l_expected clob; l_actual clob; + l_block_cov clob; begin --Arrange + if ut3_tester_helper.coverage_helper.block_coverage_available then + l_block_cov := ''; + else + l_block_cov := ''; + end if; l_expected := ' - - - - + +'||l_block_cov||' + '; --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), - a_source_files => ut3_develop.ut_varchar2_list( 'test/ut3_develop.dummy_coverage.pkb' ), - a_test_files => ut3_develop.ut_varchar2_list( ) - ) - ); - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + q'[ + ut3_develop.ut.run( + a_path => 'ut3_develop.test_dummy_coverage', + a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), + a_source_files => ut3_develop.ut_varchar2_list( 'test/ut3_develop.]'||ut3_tester_helper.coverage_helper.covered_package_name||q'[.pkb' ), + a_test_files => ut3_develop.ut_varchar2_list( ) + ) + ]' + ); --Assert ut.expect(l_actual).to_equal(l_expected); end; diff --git a/test/ut3_user/reporters/test_coverage/test_coverage_standalone.pkb b/test/ut3_user/reporters/test_coverage/test_coverage_standalone.pkb new file mode 100644 index 000000000..ef7014235 --- /dev/null +++ b/test/ut3_user/reporters/test_coverage/test_coverage_standalone.pkb @@ -0,0 +1,99 @@ +create or replace package body test_coverage_standalone is + + function run_coverage_twice(a_overage_run_id raw, a_object_name varchar2, a_charset varchar2) return clob is + l_expected clob; + l_block_cov clob; + l_file_path varchar2(250); + begin + l_file_path := 'ut3_develop.'||a_object_name; + --Arrange + if ut3_tester_helper.coverage_helper.block_coverage_available then + l_block_cov := ''; + else + l_block_cov := ''; + end if; + l_expected := + q'[ + + + +]'||l_file_path||q'[ + + + + + +]'||l_block_cov||q'[ + + + + + +]'; + --Act + ut3_tester_helper.coverage_helper.run_coverage_job(a_overage_run_id, 1); + ut3_tester_helper.coverage_helper.run_coverage_job(a_overage_run_id, 3); + return l_expected; + end; + + procedure coverage_without_ut_run is + l_coverage_run_id raw(32) := sys_guid(); + l_actual ut3_develop.ut_varchar2_list; + l_expected clob; + l_name varchar2(250); + l_charset varchar2(100) := 'ISO-8859-1'; + begin + l_name := ut3_tester_helper.coverage_helper.covered_package_name; + + --Arrange and Act + l_expected := run_coverage_twice(l_coverage_run_id, l_name, l_charset); + + select * + bulk collect into l_actual + from + table ( + ut3_develop.ut_coverage_cobertura_reporter().get_report( + a_coverage_options => ut3_develop.ut_coverage_options( + coverage_run_id => l_coverage_run_id, + include_objects => ut3_develop.ut_varchar2_rows(l_name), + schema_names => ut3_develop.ut_varchar2_rows('UT3_DEVELOP') + ), + a_client_character_set => l_charset + ) + ); + + --Assert + ut.expect(ut3_tester_helper.main_helper.table_to_clob(l_actual)).to_be_like( l_expected ); + end; + + procedure coverage_cursor_without_ut_run is + l_coverage_run_id raw(32) := sys_guid(); + l_coverage_cursor sys_refcursor; + l_actual ut3_develop.ut_varchar2_list; + l_expected clob; + l_name varchar2(250); + l_charset varchar2(100) := 'ISO-8859-1'; + begin + l_name := ut3_tester_helper.coverage_helper.covered_package_name; + + --Arrange and Act + l_expected := run_coverage_twice(l_coverage_run_id, l_name, l_charset); + + l_coverage_cursor := + ut3_develop.ut_coverage_cobertura_reporter( ).get_report_cursor( + a_coverage_options => ut3_develop.ut_coverage_options( + coverage_run_id => l_coverage_run_id, + include_objects => ut3_develop.ut_varchar2_rows(l_name), + schema_names => ut3_develop.ut_varchar2_rows('UT3_DEVELOP') + ), + a_client_character_set => l_charset + ); + fetch l_coverage_cursor bulk collect into l_actual; + close l_coverage_cursor; + + --Assert + ut.expect(ut3_tester_helper.main_helper.table_to_clob(l_actual)).to_be_like( l_expected ); + end; + +end; +/ diff --git a/test/ut3_user/reporters/test_coverage/test_coverage_standalone.pks b/test/ut3_user/reporters/test_coverage/test_coverage_standalone.pks new file mode 100644 index 000000000..1d5bb9a2c --- /dev/null +++ b/test/ut3_user/reporters/test_coverage/test_coverage_standalone.pks @@ -0,0 +1,12 @@ +create or replace package test_coverage_standalone authid current_user is + + --%suite + --%suitepath(utplsql.test_user.reporters.test_coverage) + + --%test(Coverage can be invoked standalone in multiple sessions and a combined report can be produced at the end) + procedure coverage_without_ut_run; + + --%test(Coverage can be invoked standalone in multiple sessions and a combined report can be produced at the end as cursor) + procedure coverage_cursor_without_ut_run; +end; +/ diff --git a/test/ut3_user/reporters/test_coverage/test_coveralls_reporter.pkb b/test/ut3_user/reporters/test_coverage/test_coveralls_reporter.pkb index 73dde1b78..48a62f7f6 100644 --- a/test/ut3_user/reporters/test_coverage/test_coveralls_reporter.pkb +++ b/test/ut3_user/reporters/test_coverage/test_coveralls_reporter.pkb @@ -1,50 +1,47 @@ create or replace package body test_coveralls_reporter is procedure report_on_file is - l_results ut3_develop.ut_varchar2_list; l_expected clob; l_actual clob; + l_file_path varchar2(250); begin --Arrange + l_file_path := 'test/ut3_develop.'||ut3_tester_helper.coverage_helper.covered_package_name||'.pkb'; l_expected := q'[{"source_files":[ -{ "name": "test/ut3_develop.dummy_coverage.pkb", +{ "name": "]'||l_file_path||q'[", "coverage": [ null, null, null, -1, -0, +3, null, -1 +0 ] } ]} ]'; - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_dummy_coverage', - a_reporter=> ut3_develop.ut_coveralls_reporter( ), - a_source_files => ut3_develop.ut_varchar2_list( 'test/ut3_develop.dummy_coverage.pkb' ), - a_test_files => ut3_develop.ut_varchar2_list( ) - ) + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + q'[ + ut3_develop.ut.run( + a_path => 'ut3_develop.test_dummy_coverage', + a_reporter => ut3_develop.ut_coveralls_reporter( ), + a_source_files => ut3_develop.ut_varchar2_list( ']'||l_file_path||q'[' ), + a_test_files => ut3_develop.ut_varchar2_list( ) + ) + ]' ); - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); --Assert ut.expect(l_actual).to_equal(l_expected); end; procedure report_zero_coverage is - l_results ut3_develop.ut_varchar2_list; l_expected clob; l_actual clob; - pragma autonomous_transaction; begin --Arrange l_expected := q'[{"source_files":[ -{ "name": "ut3_develop.dummy_coverage", +{ "name": "ut3_develop.]'||ut3_tester_helper.coverage_helper.covered_package_name||q'[", "coverage": [ 0, 0, @@ -54,36 +51,26 @@ null, 0, 0, 0, -0, -0, -0, -0, -0, -0, 0 ] } ]} ]'; - ut3_tester_helper.coverage_helper.cleanup_dummy_coverage(); - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - 'ut3_develop.test_dummy_coverage', - ut3_develop.ut_coveralls_reporter(), - a_include_objects => ut3_develop.ut_varchar2_list('UT3_DEVELOP.DUMMY_COVERAGE') - ) - ); - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + q'[ + ut3_develop.ut.run( + 'ut3_develop.test_dummy_coverage.zero_coverage', + ut3_develop.ut_coveralls_reporter(), + a_include_objects => ut3_develop.ut_varchar2_list('UT3_DEVELOP.]'||ut3_tester_helper.coverage_helper.covered_package_name||q'[') + ) + ]' + ); --Assert ut.expect(l_actual).to_equal(l_expected); - test_coverage.setup_dummy_coverage; - end; end; diff --git a/test/ut3_user/reporters/test_coverage/test_extended_coverage.pkb b/test/ut3_user/reporters/test_coverage/test_extended_coverage.pkb new file mode 100644 index 000000000..4b995b7c8 --- /dev/null +++ b/test/ut3_user/reporters/test_coverage/test_extended_coverage.pkb @@ -0,0 +1,87 @@ +create or replace package body test_extended_coverage is + + function get_block_coverage_line return clob is + begin + return + case + when ut3_tester_helper.coverage_helper.block_coverage_available then + '%' + else + '%' + end; + end; + procedure coverage_for_object is + l_expected clob; + l_actual clob; + begin + --Arrange + l_expected := '%' || + get_block_coverage_line|| + '%%'; + --Act + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + q'[ + ut3_develop.ut.run( + a_path => 'ut3_develop.test_dummy_coverage', + a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), + a_include_objects => ut3_develop.ut_varchar2_list( 'ut3_develop.]'||ut3_tester_helper.coverage_helper.covered_package_name||q'[' ) + ) + ]' + ); + --Assert + ut.expect(l_actual).to_be_like(l_expected); + end; + + procedure coverage_for_schema is + l_expected clob; + l_actual clob; + begin + --Arrange + l_expected := '%' || + get_block_coverage_line || + '%%'; + --Act + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + q'[ + ut3_develop.ut.run( + a_path => 'ut3_develop.test_dummy_coverage', + a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), + a_coverage_schemes => ut3_develop.ut_varchar2_list( 'ut3_develop' ) + ) + ]' + ); + --Assert + ut.expect(l_actual).to_be_like(l_expected); + ut.expect(l_actual).to_be_like('%%%'); + end; + + procedure coverage_for_file is + l_expected clob; + l_actual clob; + l_file_path varchar2(250); + begin + --Arrange + l_file_path := 'test/ut3_develop.'||ut3_tester_helper.coverage_helper.covered_package_name||'.pkb'; + l_expected := '%' || + get_block_coverage_line || + '%%'; + --Act + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + q'[ + ut3_develop.ut.run( + a_path => 'ut3_develop.test_dummy_coverage', + a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), + a_source_files => ut3_develop.ut_varchar2_list( ']'||l_file_path||q'[' ), + a_test_files => ut3_develop.ut_varchar2_list( ) + ) + ]' + ); + --Assert + ut.expect(l_actual).to_be_like(l_expected); + end; + +end; +/ diff --git a/test/ut3_user/reporters/test_extended_coverage.pks b/test/ut3_user/reporters/test_coverage/test_extended_coverage.pks similarity index 68% rename from test/ut3_user/reporters/test_extended_coverage.pks rename to test/ut3_user/reporters/test_coverage/test_extended_coverage.pks index a8460aa3a..600a87e16 100644 --- a/test/ut3_user/reporters/test_extended_coverage.pks +++ b/test/ut3_user/reporters/test_coverage/test_extended_coverage.pks @@ -1,11 +1,7 @@ create or replace package test_extended_coverage is --%suite - --%suitepath(utplsql.test_user.reporters) - - --%beforeall(ut3_tester_helper.coverage_helper.setup_dummy_coverage) - - --%afterall(ut3_tester_helper.coverage_helper.cleanup_dummy_coverage) + --%suitepath(utplsql.test_user.reporters.test_coverage) --%test(Coverage is gathered for specified object - extended coverage type) procedure coverage_for_object; diff --git a/test/ut3_user/reporters/test_coverage/test_html_coverage_reporter.pkb b/test/ut3_user/reporters/test_coverage/test_html_coverage_reporter.pkb new file mode 100644 index 000000000..d1645acae --- /dev/null +++ b/test/ut3_user/reporters/test_coverage/test_html_coverage_reporter.pkb @@ -0,0 +1,36 @@ +create or replace package body test_html_coverage_reporter is + + procedure report_on_file is + l_expected varchar2(32767); + l_actual clob; + l_block_cov clob; + l_name varchar2(250); + l_charset varchar2(100) := 'ISO-8859-1'; + begin + --Arrange + l_name := ut3_tester_helper.coverage_helper.covered_package_name; + if ut3_tester_helper.coverage_helper.block_coverage_available then + l_block_cov := '(including 1 lines partially covered ) '; + end if; + l_expected := '%%

UT3_DEVELOP.'||upper(l_name)||'

' || + '%2 relevant lines. 1 lines covered ' || + l_block_cov || 'and 1 lines missed%'; + + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + q'[ + ut3_develop.ut.run( + a_path => 'ut3_develop.test_dummy_coverage', + a_reporter=> ut3_develop.ut_coverage_html_reporter(), + a_source_files => ut3_develop.ut_varchar2_list( 'test/ut3_develop.]'||l_name||q'[.pkb' ), + a_test_files => ut3_develop.ut_varchar2_list( ), + a_client_character_set => ']'||l_charset||q'[' + ) + ]' + ); + --Assert + ut.expect(l_actual).to_be_like(l_expected); + end; + +end test_html_coverage_reporter; +/ diff --git a/test/ut3_user/reporters/test_coverage/test_html_coverage_reporter.pks b/test/ut3_user/reporters/test_coverage/test_html_coverage_reporter.pks new file mode 100644 index 000000000..629d41793 --- /dev/null +++ b/test/ut3_user/reporters/test_coverage/test_html_coverage_reporter.pks @@ -0,0 +1,10 @@ +create or replace package test_html_coverage_reporter is + + --%suite(ut_html_extended_reporter) + --%suitepath(utplsql.test_user.reporters.test_coverage.test_extended_coverage) + + --%test(reports on a project file mapped to database object in extended profiler coverage) + procedure report_on_file; + +end test_html_coverage_reporter; +/ diff --git a/test/ut3_user/reporters/test_coverage/test_html_extended_reporter.pkb b/test/ut3_user/reporters/test_coverage/test_html_extended_reporter.pkb deleted file mode 100644 index 8c6ae9e02..000000000 --- a/test/ut3_user/reporters/test_coverage/test_html_extended_reporter.pkb +++ /dev/null @@ -1,29 +0,0 @@ -create or replace package body test_html_extended_reporter is - - procedure report_on_file is - l_results ut3_develop.ut_varchar2_list; - l_expected varchar2(32767); - l_actual clob; - l_charset varchar2(100) := 'ISO-8859-1'; - begin - --Arrange - l_expected := '%%

UT3_DEVELOP.DUMMY_COVERAGE_PACKAGE_WITH_AN_AMAZINGLY_LONG_NAME_THAT_YOU_WOULD_NOT_THINK_OF_IN_REAL_LIFE_PROJECT_BECAUSE_ITS_SIMPLY_TOO_LONG

%4 relevant lines. 3 lines covered (including 1 lines partially covered ) and 1 lines missed%'; - - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_block_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_html_reporter(), - a_source_files => ut3_develop.ut_varchar2_list( 'test/ut3_develop.dummy_coverage_package_with_an_amazingly_long_name_that_you_would_not_think_of_in_real_life_project_because_its_simply_too_long.pkb' ), - a_test_files => ut3_develop.ut_varchar2_list( ), - a_client_character_set => l_charset - ) - ); - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); - --Assert - ut.expect(l_actual).to_be_like(l_expected); - end; - -end test_html_extended_reporter; -/ diff --git a/test/ut3_user/reporters/test_coverage/test_html_extended_reporter.pks b/test/ut3_user/reporters/test_coverage/test_html_extended_reporter.pks deleted file mode 100644 index dbe31b83d..000000000 --- a/test/ut3_user/reporters/test_coverage/test_html_extended_reporter.pks +++ /dev/null @@ -1,10 +0,0 @@ -create or replace package test_html_extended_reporter is - - --%suite(ut_html_extended_reporter) - --%suitepath(utplsql.test_user.reporters.test_extended_coverage) - - --%test(reports on a project file mapped to database object in extended profiler coverage) - procedure report_on_file; - -end test_html_extended_reporter; -/ diff --git a/test/ut3_user/reporters/test_coverage/test_html_proftab_reporter.pkb b/test/ut3_user/reporters/test_coverage/test_html_proftab_reporter.pkb deleted file mode 100644 index 9f3fb90e5..000000000 --- a/test/ut3_user/reporters/test_coverage/test_html_proftab_reporter.pkb +++ /dev/null @@ -1,29 +0,0 @@ -create or replace package body test_html_proftab_reporter is - - procedure report_on_file is - l_results ut3_develop.ut_varchar2_list; - l_expected varchar2(32767); - l_actual clob; - l_charset varchar2(100) := 'ISO-8859-1'; - begin - --Arrange - l_expected := '%%

UT3_DEVELOP.DUMMY_COVERAGE

%3 relevant lines. 2 lines covered and 1 lines missed%'; - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_html_reporter(), - a_source_files => ut3_develop.ut_varchar2_list( 'test/ut3_develop.dummy_coverage.pkb' ), - a_test_files => ut3_develop.ut_varchar2_list( ), - a_client_character_set => l_charset - ) - ); - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); - --Assert - ut.expect(l_actual).to_be_like(l_expected); - end; - -end test_html_proftab_reporter; -/ diff --git a/test/ut3_user/reporters/test_coverage/test_html_proftab_reporter.pks b/test/ut3_user/reporters/test_coverage/test_html_proftab_reporter.pks deleted file mode 100644 index 02973fbe0..000000000 --- a/test/ut3_user/reporters/test_coverage/test_html_proftab_reporter.pks +++ /dev/null @@ -1,10 +0,0 @@ -create or replace package test_html_proftab_reporter is - - --%suite(ut_html_proftab_reporter) - --%suitepath(utplsql.test_user.reporters.test_coverage.test_proftab_coverage) - - --%test(reports on a project file mapped to database object in profiler coverage) - procedure report_on_file; - -end test_html_proftab_reporter; -/ diff --git a/test/ut3_user/reporters/test_coverage/test_proftab_coverage.pkb b/test/ut3_user/reporters/test_coverage/test_proftab_coverage.pkb new file mode 100644 index 000000000..c6e087462 --- /dev/null +++ b/test/ut3_user/reporters/test_coverage/test_proftab_coverage.pkb @@ -0,0 +1,185 @@ +create or replace package body test_proftab_coverage is + + procedure coverage_for_object is + l_expected clob; + l_actual clob; + begin + --Arrange + l_expected := coverage_helper.substitute_covered_package('%%'); + --Act + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + coverage_helper.substitute_covered_package( + q'[ + ut3_develop.ut.run( + a_path => 'ut3_develop.test_dummy_coverage', + a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), + a_include_objects => ut3_develop.ut_varchar2_list( 'ut3_develop.{p}' ) + ) + ]' + ) + ); + --Assert + ut.expect(l_actual).to_be_like(l_expected); + end; + + procedure coverage_for_object_no_owner is + l_expected clob; + l_actual clob; + begin + --Arrange + l_expected := coverage_helper.substitute_covered_package('%%'); + --Act + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + coverage_helper.substitute_covered_package( + q'[ + ut3_develop.ut.run( + a_path => 'ut3_develop.test_dummy_coverage', + a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), + a_include_objects => ut3_develop.ut_varchar2_list( '{p}' ) + ) + ]' + ) + ); + --Assert + ut.expect(l_actual).to_be_like(l_expected); + end; + + procedure coverage_for_schema is + l_expected clob; + l_actual clob; + begin + --Arrange + l_expected := ''; + l_expected := '%'||l_expected||'%'||l_expected||'%'; + --Act + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + q'[ + ut3_develop.ut.run( + a_path => 'ut3_develop.test_dummy_coverage', + a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), + a_coverage_schemes => ut3_develop.ut_varchar2_list( 'ut3_develop' ) + ) + ]' + ); + --Assert + ut.expect(l_actual).to_be_like(l_expected); + end; + + procedure coverage_for_file is + l_expected clob; + l_actual clob; + l_file_path varchar2(250); + begin + --Arrange + l_file_path := coverage_helper.substitute_covered_package('test/ut3_develop.{p}.pkb'); + l_expected := '%%'; + --Act + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + q'[ + ut3_develop.ut.run( + a_path => 'ut3_develop.test_dummy_coverage', + a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), + a_source_files => ut3_develop.ut_varchar2_list( ']'||l_file_path||q'[' ), + a_test_files => ut3_develop.ut_varchar2_list( ) + ) + ]' + ); + --Assert + ut.expect(l_actual).to_be_like(l_expected); + end; + + procedure coverage_tmp_data_refresh is + l_actual clob; + l_test_code varchar2(32767); + begin + l_test_code := q'[ + declare + l_tmp_data ut3_develop.ut_varchar2_list; + begin + --Arrange + select * bulk collect into l_tmp_data + from table( + ut3_develop.ut.run( + a_path => 'ut3_develop:coverage_testing', + a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), + a_include_objects => ut3_develop.ut_varchar2_list( 'ut3_develop.{p}' ) + ) + ); + coverage_helper.drop_dummy_coverage(); + coverage_helper.create_dummy_coverage_1(); + + --Act + insert into test_results + select * + from table( + ut3_develop.ut.run( + a_path => 'ut3_develop:coverage_testing', + a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), + a_include_objects => ut3_develop.ut_varchar2_list( 'ut3_develop.{p}' ) + ) + ); + commit; + end; + ]'; + + l_actual := ut3_tester_helper.coverage_helper.run_code_as_job( coverage_helper.substitute_covered_package(l_test_code) ); + --Assert + ut.expect(l_actual).to_equal(to_clob(' + +')); + end; + + procedure report_zero_coverage is + l_expected clob; + l_actual clob; + begin + --Arrange + l_expected := + q'[ + + + +ut3_develop.{p} + + + + + + + + + + + + + + + + + + +]'; + + --Act + l_actual := + ut3_tester_helper.coverage_helper.run_tests_as_job( + coverage_helper.substitute_covered_package( + q'[ + ut3_develop.ut.run( + 'ut3_develop.test_dummy_coverage.zero_coverage', + ut3_develop.ut_coverage_cobertura_reporter(), + a_include_objects => ut3_develop.ut_varchar2_list('UT3_DEVELOP.{P}') + ) + ]' + ) + ); + --Assert + ut.expect(l_actual).to_be_like(coverage_helper.substitute_covered_package(l_expected)); + end; + +end; +/ diff --git a/test/ut3_user/reporters/test_proftab_coverage.pks b/test/ut3_user/reporters/test_coverage/test_proftab_coverage.pks similarity index 77% rename from test/ut3_user/reporters/test_proftab_coverage.pks rename to test/ut3_user/reporters/test_coverage/test_proftab_coverage.pks index 6f2548158..055422bf7 100644 --- a/test/ut3_user/reporters/test_proftab_coverage.pks +++ b/test/ut3_user/reporters/test_coverage/test_proftab_coverage.pks @@ -16,10 +16,12 @@ create or replace package test_proftab_coverage is procedure coverage_for_file; --%test(Coverage data is not cached between runs - issue #562 ) - --%aftertest(ut3$user#.test_coverage.create_dummy_coverage_pkg) - --%aftertest(ut3$user#.test_coverage.setup_dummy_coverage) - --%aftertest(ut3_tester_helper.coverage_helper.drop_dummy_coverage_test_1) + --%aftertest(ut3_tester_helper.coverage_helper.drop_dummy_coverage_1) + --%aftertest(ut3_tester_helper.coverage_helper.create_dummy_coverage) procedure coverage_tmp_data_refresh; + --%test(reports zero coverage on each line of non-executed database object - Issue #917) + procedure report_zero_coverage; + end; / diff --git a/test/ut3_user/reporters/test_extended_coverage.pkb b/test/ut3_user/reporters/test_extended_coverage.pkb deleted file mode 100644 index 28742aa70..000000000 --- a/test/ut3_user/reporters/test_extended_coverage.pkb +++ /dev/null @@ -1,74 +0,0 @@ -create or replace package body test_extended_coverage is - - procedure coverage_for_object is - l_expected clob; - l_actual clob; - l_results ut3_develop.ut_varchar2_list; - begin - --Arrange - l_expected := '%%%'; - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_block_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), - a_include_objects => ut3_develop.ut_varchar2_list( 'ut3_develop.dummy_coverage_package_with_an_amazingly_long_name_that_you_would_not_think_of_in_real_life_project_because_its_simply_too_long' ) - ) - ); - --Assert - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); - ut.expect(l_actual).to_be_like(l_expected); - end; - - procedure coverage_for_schema is - l_expected clob; - l_actual clob; - l_results ut3_develop.ut_varchar2_list; - begin - --Arrange - l_expected := '%%%'; - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_block_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), - a_coverage_schemes => ut3_develop.ut_varchar2_list( 'ut3_develop' ) - ) - ); - --Assert - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); - ut.expect(l_actual).to_be_like(l_expected); - ut.expect(l_actual).to_be_like('%%%'); - end; - - procedure coverage_for_file is - l_expected clob; - l_actual clob; - l_results ut3_develop.ut_varchar2_list; - l_file_path varchar2(250); - begin - --Arrange - l_file_path := lower('test/ut3_develop.dummy_coverage_package_with_an_amazingly_long_name_that_you_would_not_think_of_in_real_life_project_because_its_simply_too_long.pkb'); - l_expected := '%%%'; - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_block_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), - a_source_files => ut3_develop.ut_varchar2_list( l_file_path ), - a_test_files => ut3_develop.ut_varchar2_list( ) - ) - ); - --Assert - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); - ut.expect(l_actual).to_be_like(l_expected); - end; - -end; -/ diff --git a/test/ut3_user/reporters/test_proftab_coverage.pkb b/test/ut3_user/reporters/test_proftab_coverage.pkb deleted file mode 100644 index c132517a7..000000000 --- a/test/ut3_user/reporters/test_proftab_coverage.pkb +++ /dev/null @@ -1,132 +0,0 @@ -create or replace package body test_proftab_coverage is - - procedure coverage_for_object is - l_expected clob; - l_actual clob; - l_results ut3_develop.ut_varchar2_list; - begin - --Arrange - l_expected := '%%'; - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), - a_include_objects => ut3_develop.ut_varchar2_list( 'ut3_develop.dummy_coverage' ) - ) - ); - --Assert - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); - ut.expect(l_actual).to_be_like(l_expected); - end; - - procedure coverage_for_object_no_owner is - l_expected clob; - l_actual clob; - l_results ut3_develop.ut_varchar2_list; - begin - --Arrange - l_expected := '%%'; - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), - a_include_objects => ut3_develop.ut_varchar2_list( 'dummy_coverage' ) - ) - ); - --Assert - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); - ut.expect(l_actual).to_be_like(l_expected); - end; - - procedure coverage_for_schema is - l_expected clob; - l_actual clob; - l_results ut3_develop.ut_varchar2_list; - begin - --Arrange - l_expected := ''; - l_expected := '%'||l_expected||'%'||l_expected||'%'; - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), - a_coverage_schemes => ut3_develop.ut_varchar2_list( 'ut3_develop' ) - ) - ); - --Assert - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); - ut.expect(l_actual).to_be_like(l_expected); - end; - - procedure coverage_for_file is - l_expected clob; - l_actual clob; - l_results ut3_develop.ut_varchar2_list; - l_file_path varchar2(100); - begin - --Arrange - l_file_path := lower('test/ut3_develop.dummy_coverage.pkb'); - l_expected := '%%'; - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop.test_dummy_coverage', - a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), - a_source_files => ut3_develop.ut_varchar2_list( l_file_path ), - a_test_files => ut3_develop.ut_varchar2_list( ) - ) - ); - --Assert - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); - ut.expect(l_actual).to_be_like(l_expected); - end; - - procedure coverage_tmp_data_refresh is - l_actual clob; - l_results ut3_develop.ut_varchar2_list; - begin - --Arrange - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop:coverage_testing', - a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), - a_include_objects => ut3_develop.ut_varchar2_list( 'ut3_develop.dummy_coverage' ) - ) - ); - ut3_tester_helper.coverage_helper.cleanup_dummy_coverage(); - ut3_tester_helper.coverage_helper.drop_dummy_coverage_pkg(); - ut3_tester_helper.coverage_helper.create_dummy_coverage_test_1(); - - --Act - select * - bulk collect into l_results - from table( - ut3_develop.ut.run( - a_path => 'ut3_develop:coverage_testing', - a_reporter=> ut3_develop.ut_coverage_sonar_reporter( ), - a_include_objects => ut3_develop.ut_varchar2_list( 'ut3_develop.dummy_coverage' ) - ) - ); - - --Assert - l_actual := ut3_tester_helper.main_helper.table_to_clob(l_results); - ut.expect(l_actual).to_equal(to_clob(' - -')); - end; - -end; -/