omnata-plugin-devkit 0.3.30__tar.gz → 0.3.32__tar.gz

{omnata_plugin_devkit-0.3.30 → omnata_plugin_devkit-0.3.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omnata-plugin-devkit
-Version: 0.3.30
+Version: 0.3.32
 Summary: 
 Author: James Weakley
 Author-email: james.weakley@omnata.com

{omnata_plugin_devkit-0.3.30 → omnata_plugin_devkit-0.3.32}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "omnata-plugin-devkit"
-version = "0.3.30"
+version = "0.3.32"
 description = ""
 authors = ["James Weakley <james.weakley@omnata.com>"]
 readme = "README.md"

{omnata_plugin_devkit-0.3.30 → omnata_plugin_devkit-0.3.32}/src/omnata_plugin_devkit/development_session.py

@@ -464,6 +464,9 @@ class DevelopmentSession:
         self._stop_recording()
         if apply_results:
             self.current_scenario.sync_request.apply_results_queue()
+            if self.current_scenario.sync_request.__class__.__name__ == "InboundSyncRequest":
+                print(f'States at completion: {self.current_scenario.sync_request._latest_states}')
+                self.current_scenario.sync_request.apply_progress_updates(ignore_errors=False)
         session_run_response = self.session.sql(
             f"""
             call {self.omnata_app_name}.API.COMPLETE_DEVELOPMENT_SESSION_RUN({self.run_id},{apply_results})
@@ -843,7 +846,8 @@ class DevelopmentSession:
                     if recorded_scenario.results[stream_name] is None:
                         raise ValueError(f"Recorded results for scenario {recorded_scenario.scenario_name} were None")
                     results = pandas.concat(recorded_scenario.results[stream_name])
-                    results["RECORD_DATA"] = results["RECORD_DATA"].apply(json.dumps)
+                    # no need to do this anymore, as the results are already json
+                    #results["RECORD_DATA"] = results["RECORD_DATA"].apply(json.dumps)
                     results["RECORD_DATA"] = results["RECORD_DATA"].replace("|", "\\|")
                     results.loc[
                         results["RECORD_DATA"] == '"null"', "RECORD_DATA"

{omnata_plugin_devkit-0.3.30 → omnata_plugin_devkit-0.3.32}/src/omnata_plugin_devkit/plugin_uploader.py

@@ -649,6 +649,7 @@ $${}$$;
                                     remaining_udf_arg_types.extend([a.arg_data_type for a in udf_def.function_arguments[1:]])
                                 all_udf_args = initial_udf_arg + remaining_udf_args
                                 all_udf_arg_types = initial_udf_arg_type + remaining_udf_arg_types
+                                original_udf_arg_types = ["object"] + remaining_udf_arg_types
                                 wrapper_udf = f"create or replace function {udf_def.function_name}({','.join(all_udf_args)})\n"
                                 # The wrappers are structured differently depending on whether the UDF returns a table or not
                                 if udf_def.returns_table:
@@ -668,6 +669,8 @@ $$;
                                 setup_script.write(wrapper_udf + "\n")
                                 # we're granting visibility only to the wrapper function, not the original udf
                                 setup_script.write(f"grant usage on function {udf_def.function_name}({','.join(all_udf_arg_types)}) to application role CONSUMER_FUNCTION_CALLER;\n")
+                                # actually, temporarily we need to grant visibility to the original udf, due to a Snowflake bug
+                                setup_script.write(f"grant usage on function {udf_def.function_name}({','.join(original_udf_arg_types)}) to application role CONSUMER_FUNCTION_CALLER;\n")
                         
             # in rare cases, the plugin author might want to do something of their own in the setup script
             # so we allow them to create a file called setup_script.sql and we'll append it to the end of the script

{omnata_plugin_devkit-0.3.30 → omnata_plugin_devkit-0.3.32}/src/omnata_plugin_devkit/test_step_definitions.py

@@ -329,7 +329,7 @@ def step_impl_response_inbound(context, stream_name):
             f"Stream {stream_name} not found in sync_inbound_result. Keys: {list(context.sync_inbound_result.keys())}"
         )
     
-    sync_inbound_result_for_stream = (
+    sync_inbound_result_for_stream:pandas.DataFrame = (
         pandas.concat(context.sync_inbound_result[stream_name])
         .sort_values(by=["APP_IDENTIFIER"])
         .sort_index(axis=1)
@@ -343,9 +343,9 @@ def step_impl_response_inbound(context, stream_name):
     sync_inbound_result_for_stream = sync_inbound_result_for_stream.sort_values(by=["APP_IDENTIFIER"]).sort_index(axis=1).reset_index(drop=True)
     # because behave tables work best with a string representation of json, we'll convert the results objects to string
     # expected_result['RESULT'] = expected_result['RESULT'].apply(json.dumps)
-    sync_inbound_result_for_stream["RECORD_DATA"] = sync_inbound_result_for_stream[
-        "RECORD_DATA"
-    ].apply(json.dumps)
+    #sync_inbound_result_for_stream["RECORD_DATA"] = sync_inbound_result_for_stream[
+    #    "RECORD_DATA"
+    #].apply(json.dumps)
     
     # exclude RETRIEVE_DATE column from both dataframes, naturally they will differ
     expected_result = expected_result.drop(columns=["RETRIEVE_DATE"])
@@ -357,19 +357,45 @@ def step_impl_response_inbound(context, stream_name):
     # in order to not break existing tests, if the actual result contains the IS_DELETED column but the expected result doesn't, we'll remove it from the actual result
     if "IS_DELETED" in sync_inbound_result_for_stream.columns and "IS_DELETED" not in expected_result.columns:
         sync_inbound_result_for_stream = sync_inbound_result_for_stream.drop(columns=["IS_DELETED"])
+
+    #expected_result = expected_result.sort_index(axis=1)
+    #sync_inbound_result_for_stream = sync_inbound_result_for_stream.sort_index(axis=1)
+    logger.info("Setting index of expected_result to APP_IDENTIFIER")
+    expected_result.set_index("APP_IDENTIFIER", inplace=True, drop=False)
+    logger.info("Sorting index of expected result")
+    expected_result = expected_result.sort_index()
+    logger.info("Setting index of sync_inbound_result to APP_IDENTIFIER")
+    sync_inbound_result_for_stream.set_index("APP_IDENTIFIER", inplace=True, drop=False)
+    logger.info("Sorting index of sync_inbound_result")
+    sync_inbound_result_for_stream = sync_inbound_result_for_stream.sort_index()
+    logger.info(f"expected_result dtypes:\n{expected_result.dtypes}")
+    logger.info(f"sync_inbound_result dtypes:\n{sync_inbound_result_for_stream.dtypes}")    
+    #logger.info("Checking for duplicates in expected_result")
+    #duplicates = expected_result[expected_result.duplicated(['APP_IDENTIFIER'], keep="first")]['APP_IDENTIFIER'].unique().tolist()
+    #case.assertEqual(
+    #    len(duplicates),0, f"Duplicate APP_IDENTIFIER in expected_result:\n{duplicates.tolist()}"
+    #)
+    #logger.info("Checking for duplicates in sync_inbound_result")
+    #duplicates = sync_inbound_result_for_stream[sync_inbound_result_for_stream.duplicated(['APP_IDENTIFIER'], keep="first")]['APP_IDENTIFIER'].unique().tolist()
+    #case.assertFalse(
+    #    len(duplicates),0, f"Duplicate APP_IDENTIFIER in sync_inbound_result:\n{duplicates.tolist()}"
+    #)
+    # remove duplicates from expected_result and sync_inbound_result
+    expected_result.drop_duplicates(subset=['APP_IDENTIFIER'], keep="first", inplace=True)
+    sync_inbound_result_for_stream.drop_duplicates(subset=['APP_IDENTIFIER'], keep="first", inplace=True)
+    logger.info("Resetting index of expected_result to match sync_inbound_result")
+    expected_result = expected_result.reindex_like(sync_inbound_result_for_stream)
     assert list(expected_result.columns) == list(
         sync_inbound_result_for_stream.columns
     ), f"Column headings didn't match. Expected: {expected_result.columns}, actual: {sync_inbound_result_for_stream.columns}"
     pandas.set_option("display.max_columns", 10)
     pandas.set_option("display.width", 150)
-    logger.info(f"expected_result: {expected_result}")
-    logger.info(f"expected_result dtypes: {expected_result.dtypes}")
-    logger.info(f"sync_inbound_result: {sync_inbound_result_for_stream}")
-    logger.info(f"sync_inbound_result dtypes: {sync_inbound_result_for_stream.dtypes}")
-    logger.info(f"differences: {expected_result.compare(sync_inbound_result_for_stream)}")
+    logger.info(f"expected_result:\n{expected_result}")
+    logger.info(f"sync_inbound_result:\n{sync_inbound_result_for_stream}")
     case.assertCountEqual(
         expected_result.columns.to_list(), sync_inbound_result_for_stream.columns.to_list()
     )
+    logger.info(f"differences:\n{expected_result.compare(sync_inbound_result_for_stream)}")
     assert_frame_equal(expected_result, sync_inbound_result_for_stream)