Added tests and negated code

utPLSQL · jgebal · Mar 15, 2019 · Oct 6, 2018 · Oct 6, 2018 · Oct 6, 2018
commit f798e3919fed7dee7aadef54a5084b0d1493c8a6
diff --git a/source/expectations/data_values/ut_compound_data_helper.pkb b/source/expectations/data_values/ut_compound_data_helper.pkb
@@ -607,14 +607,42 @@ create or replace package body ut_compound_data_helper is
     return l_sql;
   end;
 
+   function get_not_inclusion_matcher_sql(a_owner in varchar2) return varchar2 is
+    l_sql varchar2(32767);
+  begin
+    /* Self set does not contain any values from other set */
+    l_sql := 'with source_data as
+                       ( select t.data_id,t.item_hash,row_number() over (partition by t.pk_hash,t.item_hash,t.data_id order by 1,2) duplicate_no,
+                           pk_hash
+                           from  ' || a_owner || '.ut_compound_data_tmp t
+                           where data_id = :self_guid or data_id = :other_guid
+                        )           
+                       select distinct :diff_id,tmp.item_hash,tmp.pk_hash,tmp.duplicate_no
+                       from
+                         (
+                         select act.item_hash,act. duplicate_no,act.pk_hash
+                         from  source_data act where act.data_id = :self_guid
+                         and exists ( select 1
+                                      from  source_data exp
+                                      where exp.data_id = :other_guid
+                                      and exp.item_hash = act.item_hash
+                                     )
+                        union all
+                        select null,null,null
+                        from dual where :other_guid = :self_guid
+                        )
+                        tmp';
+    return l_sql;
+  end;  
+
   function get_refcursor_matcher_sql(a_owner in varchar2,a_inclusion_matcher boolean := false, a_negated_match boolean := false) return varchar2  is
     l_sql varchar2(32767);
   begin
     l_sql := 'insert into ' || a_owner || '.ut_compound_data_diff_tmp ( diff_id,item_hash,pk_hash,duplicate_no)'||chr(10);
     if a_inclusion_matcher and not(a_negated_match) then
       l_sql := l_sql || get_inclusion_matcher_sql(a_owner);
     elsif a_inclusion_matcher and a_negated_match then
-      null;
+      l_sql := l_sql || get_not_inclusion_matcher_sql(a_owner);
     elsif not(a_inclusion_matcher) then
       l_sql := l_sql || get_unordered(a_owner);
     end if;

diff --git a/source/expectations/data_values/ut_compound_data_value.tpb b/source/expectations/data_values/ut_compound_data_value.tpb
@@ -193,7 +193,7 @@ create or replace type body ut_compound_data_value as
   end;
 
   member function compare_implementation(a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2, a_join_by_xpath varchar2, 
-                                         a_unordered boolean , a_inclusion_compare boolean := false ) return integer is
+                                         a_unordered boolean , a_inclusion_compare boolean := false, a_is_negated boolean := false ) return integer is
     l_other           ut_compound_data_value;
     l_ut_owner        varchar2(250) := ut_utils.ut_owner;
     l_column_filter   varchar2(32767);
@@ -255,14 +255,14 @@ create or replace type body ut_compound_data_value as
     * SELF is expected. 
     * Due to growing complexity I have moved a dynamic SQL into helper package.
     */
-    l_sql := ut_compound_data_helper.get_refcursor_matcher_sql(l_ut_owner,a_inclusion_compare);
-    
+    l_sql := ut_compound_data_helper.get_refcursor_matcher_sql(l_ut_owner,a_inclusion_compare,a_is_negated);
+
     execute immediate l_sql
     using self.data_id, l_other.data_id,
           l_diff_id, 
           self.data_id, l_other.data_id,
           l_other.data_id,self.data_id;
-                     
+
     /*!*
     * Result OK when is not inclusion matcher and both are the same 
     * Resullt OK when is inclusion matcher and left contains right set

diff --git a/source/expectations/data_values/ut_compound_data_value.tps b/source/expectations/data_values/ut_compound_data_value.tps
@@ -45,6 +45,6 @@ create or replace type ut_compound_data_value force under ut_data_value(
   member function get_data_diff(a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2, a_join_by_xpath varchar2, a_unordered boolean) return clob,
   member function compare_implementation(a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2) return integer,
   member function compare_implementation(a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2, a_join_by_xpath varchar2, 
-                                         a_unordered boolean , a_inclusion_compare boolean := false) return integer
+                                         a_unordered boolean , a_inclusion_compare boolean := false, a_is_negated boolean := false) return integer
 ) not final not instantiable
 /
diff --git a/source/expectations/data_values/ut_data_value_refcursor.tpb b/source/expectations/data_values/ut_data_value_refcursor.tpb
@@ -221,7 +221,7 @@ create or replace type body ut_data_value_refcursor as
   end;
 
   overriding member function compare_implementation (a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2, a_join_by_xpath varchar2, 
-                                                     a_unordered boolean, a_inclusion_compare boolean := false) return integer is
+                                                     a_unordered boolean, a_inclusion_compare boolean := false, a_is_negated boolean := false) return integer is
     l_result          integer := 0;
     l_other           ut_data_value_refcursor;
     function is_pk_missing (a_pk_missing_tab ut_compound_data_helper.tt_missing_pk) return integer is
@@ -251,7 +251,7 @@ create or replace type body ut_data_value_refcursor as
 
       if a_unordered then
         l_result := l_result + (self as ut_compound_data_value).compare_implementation(a_other, a_exclude_xpath, a_include_xpath, 
-                                a_join_by_xpath, a_unordered, a_inclusion_compare);      
+                                a_join_by_xpath, a_unordered, a_inclusion_compare, a_is_negated);      
       else
         l_result := l_result + (self as ut_compound_data_value).compare_implementation(a_other, a_exclude_xpath, a_include_xpath);
       end if;
@@ -265,6 +265,5 @@ create or replace type body ut_data_value_refcursor as
     return self.elements_count = 0;
   end;
 
-
 end;
 /
diff --git a/source/expectations/data_values/ut_data_value_refcursor.tps b/source/expectations/data_values/ut_data_value_refcursor.tps
@@ -45,8 +45,7 @@ create or replace type ut_data_value_refcursor under ut_compound_data_value(
   overriding member function to_string return varchar2,
   overriding member function diff( a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2, a_join_by_xpath varchar2, a_unordered boolean := false ) return varchar2,
   overriding member function compare_implementation(a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2, a_join_by_xpath varchar2, 
-                                                    a_unordered boolean, a_inclusion_compare boolean := false) return integer,
+                                                    a_unordered boolean, a_inclusion_compare boolean := false, a_is_negated boolean := false) return integer,
   overriding member function is_empty return boolean
-
 )
 /
diff --git a/source/expectations/matchers/ut_include.tpb b/source/expectations/matchers/ut_include.tpb
@@ -43,17 +43,17 @@ create or replace type body ut_include as
     return l_result;
   end;
 
+  member function get_negated return boolean is
+  begin
+    return ut_utils.int_to_boolean(nvl(is_negated,0));
+  end;
+
   overriding member function run_matcher(self in out nocopy ut_include, a_actual ut_data_value) return boolean is
     l_result boolean;
   begin
     if self.expected.data_type = a_actual.data_type then
-      if nvl(self.is_negated,0) = 0 then
-        l_result := 0 = treat(self.expected as ut_data_value_refcursor).compare_implementation(a_actual, self.get_exclude_xpath(), self.get_include_xpath(), self.get_join_by_xpath(),
-                              true,get_inclusion_compare());
-      else
         l_result := 0 = treat(self.expected as ut_data_value_refcursor).compare_implementation(a_actual, self.get_exclude_xpath(), self.get_include_xpath(), self.get_join_by_xpath(),
-                              true,get_inclusion_compare());
-      end if;
+                              true,self.get_inclusion_compare(), self.get_negated());
     else
       l_result := (self as ut_matcher).run_matcher(a_actual);
     end if;
@@ -73,5 +73,11 @@ create or replace type body ut_include as
     return l_result;
   end;
 
+  overriding member function failure_message_when_negated(a_actual ut_data_value) return varchar2 is
+    l_result varchar2(32767);
+  begin
+    return (self as ut_matcher).failure_message_when_negated(a_actual) || ':'|| expected.to_string_report();
+  end;
+
 end;
 /
diff --git a/source/expectations/matchers/ut_include.tps b/source/expectations/matchers/ut_include.tps
@@ -28,7 +28,9 @@ create or replace type ut_include under ut_equal(
   constructor function ut_include(self in out nocopy ut_include, a_expected sys_refcursor) return self as result,
   member function get_inclusion_compare return boolean,
   member function negated return ut_include,
+  member function get_negated return boolean,
   overriding member function run_matcher(self in out nocopy ut_include, a_actual ut_data_value) return boolean,
-  overriding member function failure_message(a_actual ut_data_value) return varchar2
+  overriding member function failure_message(a_actual ut_data_value) return varchar2,
+  overriding member function failure_message_when_negated(a_actual ut_data_value) return varchar2
 )
 /
diff --git a/source/expectations/ut_expectation.tpb b/source/expectations/ut_expectation.tpb
@@ -38,6 +38,17 @@ create or replace type body ut_expectation as
     ut_expectation_processor.add_expectation_result( ut_expectation_result( ut_utils.to_test_result( l_expectation_result ), self.description, l_message ) );
   end;
 
+  member procedure not_include(self in ut_expectation, a_matcher ut_matcher) is
+    l_expectation_result boolean;
+    l_matcher       ut_matcher := a_matcher;
+    l_message       varchar2(32767);
+  begin
+    l_expectation_result := l_matcher.run_matcher( self.actual_data );
+    l_expectation_result := coalesce(l_expectation_result,false);
+    l_message := coalesce( l_matcher.error_message( self.actual_data ), l_matcher.failure_message_when_negated( self.actual_data ) );
+    ut_expectation_processor.add_expectation_result( ut_expectation_result( ut_utils.to_test_result( l_expectation_result ), self.description, l_message ) );
+  end;
+
   member procedure to_be_null(self in ut_expectation) is
   begin
     self.to_( ut_be_null() );
@@ -690,12 +701,12 @@ create or replace type body ut_expectation as
 
   member procedure not_to_include(self in ut_expectation, a_expected sys_refcursor) is
   begin
-   self.not_to( ut_include(a_expected).negated );
+   self.not_include( ut_include(a_expected).negated );
   end;
 
   member procedure not_to_contain(self in ut_expectation, a_expected sys_refcursor) is
   begin
-    self.not_to( ut_include(a_expected).negated );
+    self.not_include( ut_include(a_expected).negated );
   end;
 
 end;

diff --git a/source/expectations/ut_expectation.tps b/source/expectations/ut_expectation.tps
@@ -21,6 +21,7 @@ create or replace type ut_expectation authid current_user as object(
   --base matcher executors
   member procedure to_(self in ut_expectation, a_matcher ut_matcher),
   member procedure not_to(self in ut_expectation, a_matcher ut_matcher),
+  member procedure not_include(self in ut_expectation, a_matcher ut_matcher),
 
   --shortcuts
   member procedure to_be_null(self in ut_expectation),

diff --git a/source/expectations/ut_expectation_compound.tpb b/source/expectations/ut_expectation_compound.tpb
@@ -123,22 +123,30 @@ create or replace type body ut_expectation_compound as
 
   member procedure include(self in ut_expectation_compound, a_items varchar2) is
   begin
-    if ut_utils.int_to_boolean(negated) then
-      self.not_to( treat(matcher as ut_equal).include(a_items) );
-    else
-      self.to_( treat(matcher as ut_equal).include(a_items) );
-    end if;
-  end;
+      if ut_utils.int_to_boolean(negated) then
+        if (matcher is of (ut_include)) then
+          self.not_include( treat(matcher as ut_equal).include(a_items) );
+        else
+          self.not_to( treat(matcher as ut_equal).include(a_items) );
+        end if;
+      else
+        self.to_( treat(matcher as ut_equal).include(a_items) );
+      end if;
+    end;
 
   member procedure include(self in ut_expectation_compound, a_items ut_varchar2_list) is
   begin
+      if ut_utils.int_to_boolean(negated) then
+        if (matcher is of (ut_include)) then
+          self.not_include( treat(matcher as ut_equal).include(a_items) );
+        else
+          self.not_to( treat(matcher as ut_equal).include(a_items) );
+        end if;
+      else
+        self.to_( treat(matcher as ut_equal).include(a_items) );
+      end if;
+    end;
 
-    if ut_utils.int_to_boolean(negated) then
-      self.not_to( treat(matcher as ut_equal).include(a_items) );
-    else
-      self.to_( treat(matcher as ut_equal).include(a_items) );
-    end if;
-  end;
 
 
   member function exclude(a_items varchar2) return ut_expectation_compound is
@@ -160,17 +168,24 @@ create or replace type body ut_expectation_compound as
   member procedure exclude(self in ut_expectation_compound, a_items varchar2) is
     begin
       if ut_utils.int_to_boolean(negated) then
-        self.not_to( treat(matcher as ut_equal).exclude(a_items) );
+        if (matcher is of (ut_include)) then
+          self.not_include( treat(matcher as ut_equal).exclude(a_items) );
+        else
+          self.not_to( treat(matcher as ut_equal).exclude(a_items) );
+        end if;
       else
         self.to_( treat(matcher as ut_equal).exclude(a_items) );
       end if;
     end;
 
   member procedure exclude(self in ut_expectation_compound, a_items ut_varchar2_list) is
     begin
-
       if ut_utils.int_to_boolean(negated) then
-        self.not_to( treat(matcher as ut_equal).exclude(a_items) );
+        if (matcher is of (ut_include)) then
+          self.not_include( treat(matcher as ut_equal).exclude(a_items) );
+        else
+          self.not_to( treat(matcher as ut_equal).exclude(a_items) );
+        end if;
       else
         self.to_( treat(matcher as ut_equal).exclude(a_items) );
       end if;
@@ -213,17 +228,24 @@ create or replace type body ut_expectation_compound as
   member procedure join_by(self in ut_expectation_compound, a_columns varchar2) is
   begin
     if ut_utils.int_to_boolean(negated) then
-      self.not_to( treat(matcher as ut_equal).join_by(a_columns) );
+      if (matcher is of (ut_include)) then
+        self.not_include( treat(matcher as ut_equal).join_by(a_columns) );
+      else 
+        self.not_to( treat(matcher as ut_equal).join_by(a_columns) );
+      end if;
     else
       self.to_( treat(matcher as ut_equal).join_by(a_columns) );
     end if;
   end;
 
   member procedure join_by(self in ut_expectation_compound, a_columns ut_varchar2_list) is
   begin
-
     if ut_utils.int_to_boolean(negated) then
-      self.not_to( treat(matcher as ut_equal).join_by(a_columns) );
+      if (matcher is of (ut_include)) then
+        self.not_include( treat(matcher as ut_equal).join_by(a_columns) );
+      else 
+        self.not_to( treat(matcher as ut_equal).join_by(a_columns) );
+      end if;
     else
       self.to_( treat(matcher as ut_equal).join_by(a_columns) );
     end if;

diff --git a/test/core/expectations/test_expectations_cursor.pkb b/test/core/expectations/test_expectations_cursor.pkb
@@ -2174,5 +2174,94 @@ Diff:%
     --Assert
     ut.expect(expectations.failed_expectations_data()).to_be_empty();
   end;  
+
+  procedure cursor_not_to_contain is
+    l_actual   SYS_REFCURSOR;
+    l_expected SYS_REFCURSOR;
+  begin
+    --Arrange
+    open l_expected for select 'TEST' username, -600 user_id from dual;
+
+    open l_actual for select username, user_id from all_users
+    union all
+    select 'TEST' username, -601 user_id from dual;
+
+    --Act
+    ut3.ut.expect(l_actual).not_to_contain(l_expected);
+    --Assert
+    ut.expect(expectations.failed_expectations_data()).to_be_empty();
+  end;
+
+  procedure cursor_not_to_include is
+    l_actual   SYS_REFCURSOR;
+    l_expected SYS_REFCURSOR;
+  begin
+    --Arrange
+    open l_expected for select 'TEST' username, -600 user_id from dual;
+
+    open l_actual for select username, user_id from all_users
+    union all
+    select 'TEST' username, -601 user_id from dual;
+
+    --Act
+    ut3.ut.expect(l_actual).not_to_include(l_expected);
+    --Assert
+    ut.expect(expectations.failed_expectations_data()).to_be_empty();
+  end;
+
+  procedure cursor_not_to_contain_joinby is
+    l_actual   SYS_REFCURSOR;
+    l_expected SYS_REFCURSOR;
+  begin
+    --Arrange
+    open l_actual for select username,user_id from all_users;
+    open l_expected for select username||'ACT' username ,user_id from all_users where rownum < 5;
+
+    --Act
+    ut3.ut.expect(l_actual).not_to_contain(l_expected).join_by('USER_ID');
+    --Assert
+    ut.expect(expectations.failed_expectations_data()).to_be_empty();
+  end;
+
+   procedure cursor_not_to_include_joinby is
+    l_actual   SYS_REFCURSOR;
+    l_expected SYS_REFCURSOR;
+  begin
+    --Arrange
+    open l_actual for select username,user_id from all_users;
+    open l_expected for select username||'ACT' username ,user_id from all_users where rownum < 5;
+
+    --Act
+    ut3.ut.expect(l_actual).not_to_include(l_expected).join_by('USER_ID');
+    --Assert
+    ut.expect(expectations.failed_expectations_data()).to_be_empty();
+  end;
+
+  procedure not_cont_join_incl_cols_as_lst is
+    l_actual   sys_refcursor;
+    l_expected sys_refcursor;
+  begin
+    --Arrange
+    open l_actual   for select rownum as rn, 'b' as "A_Column", 'c' as A_COLUMN, 'x' SOME_COL, 'd' "Some_Col"  from dual a connect by level < 10;
+    open l_expected for select rownum as rn, 'a' as "A_Column", 'd' as A_COLUMN, 'x' SOME_COL, 'c' "Some_Col"  from dual a connect by level < 4;
+    --Act
+    ut3.ut.expect(l_actual).to_include(l_expected).include(ut3.ut_varchar2_list('RN','//A_Column','SOME_COL')).join_by('RN');
+    --Assert
+    ut.expect(expectations.failed_expectations_data()).to_be_empty();
+  end;
+
+  procedure not_cont_join_excl_cols_as_lst is
+    l_actual   sys_refcursor;
+    l_expected sys_refcursor;
+  begin
+    --Arrange
+    open l_actual   for select rownum as rn, 'a' as "A_Column", 'c' as A_COLUMN, 'y' SOME_COL, 'd' "Some_Col"  from dual a connect by level < 10;
+    open l_expected for select rownum as rn, 'a' as "A_Column", 'd' as A_COLUMN, 'x' SOME_COL, 'c' "Some_Col"  from dual a connect by level < 4;
+    --Act
+    ut3.ut.expect(l_actual).to_include(l_expected).exclude(ut3.ut_varchar2_list('//Some_Col','A_COLUMN')).join_by('RN');
+    --Assert
+    ut.expect(expectations.failed_expectations_data()).to_be_empty();
+  end;
+
 end;
 /