PYCBC-1698: Improve Jenkins Integration Tests

Changes
=======
* Update eventing mgmt tests to skip some failure tests that are no
  longer viable in server 8.0
* Update C++ core to include eventing mgmt logic changes from CXXCBC-716
* Update eventing mgmt to have a more robust clean-up after a test is
  complete
* Fix `test_upsert_index_from_json` to only compare portions of the
  index `store` object as more key/value pairs have been added in server
  8.0
* Remove `search_query_timeout` and `view_query_timeout` as the tests
  were not adding value and instead creating problems
* Update transactions logic to handle raw `document_unretrievable` which
  helps to handle updated C++ core logic from CXXCBC-704.

Change-Id: I7969a117584e59cc58300b5597d3422d1af94a12
Reviewed-on: https://review.couchbase.org/c/couchbase-python-client/+/232173
Tested-by: Build Bot <build@couchbase.com>
Reviewed-by: Dimitris Christodoulou <dimitris.christodoulou@couchbase.com>

Author: thejcfactor

acouchbase/tests/eventingmgmt_t.py

@@ -22,9 +22,7 @@
 import pytest_asyncio
 
 import couchbase.search as search
-from couchbase.exceptions import (AmbiguousTimeoutException,
-                                  InvalidArgumentException,
-                                  QueryIndexNotFoundException)
+from couchbase.exceptions import InvalidArgumentException, QueryIndexNotFoundException
 from couchbase.mutation_state import MutationState
 from couchbase.options import SearchOptions
 from couchbase.search import (HighlightStyle,
@@ -739,33 +737,6 @@ async def test_search_raw_query(self, cb_env):
         res = cb_env.cluster.search_query(cb_env.TEST_INDEX_NAME, q, limit=10)
         await cb_env.assert_rows(res, 1)
 
-    # creating a new connection, allow retries
-    @pytest.mark.flaky(reruns=5, reruns_delay=1)
-    @pytest.mark.asyncio
-    async def test_search_timeout(self, cb_env):
-        from acouchbase.cluster import Cluster
-        from couchbase.auth import PasswordAuthenticator
-        from couchbase.options import ClusterOptions, ClusterTimeoutOptions
-        conn_string = cb_env.config.get_connection_string()
-        username, pw = cb_env.config.get_username_and_pw()
-        auth = PasswordAuthenticator(username, pw)
-        # Prior to PYCBC-1521, this test would fail as each request would override the cluster level search_timeout.
-        # If a timeout was not provided in the request, the default 75s timeout would be used.  PYCBC-1521 corrects
-        # this behavior so this test will pass as we are essentially forcing an AmbiguousTimeoutException because
-        # we are setting the cluster level search_timeout such a small value.
-        timeout_opts = ClusterTimeoutOptions(search_timeout=timedelta(milliseconds=1))
-        cluster = await Cluster.connect(f'{conn_string}', ClusterOptions(auth, timeout_options=timeout_opts))
-        # don't need to do this except for older server versions
-        _ = cluster.bucket(f'{cb_env.bucket.name}')
-        q = search.TermQuery('auto')
-        with pytest.raises(AmbiguousTimeoutException):
-            res = cluster.search_query(cb_env.TEST_INDEX_NAME, q, SearchOptions(limit=10))
-            [r async for r in res.rows()]
-        # if we override the timeout w/in the request the query should succeed.
-        res = cluster.search_query(cb_env.TEST_INDEX_NAME, q, SearchOptions(limit=10, timeout=timedelta(seconds=10)))
-        rows = [r async for r in res.rows()]
-        assert len(rows) > 0
-
 
 class ClassicSearchCollectionTests(SearchCollectionTestSuite):
     @pytest.fixture(scope='class')

acouchbase/tests/search_t.py

@@ -14,14 +14,11 @@
 #  limitations under the License.
 
 import json
-from datetime import timedelta
 
 import pytest
 import pytest_asyncio
 
-from couchbase.exceptions import (AmbiguousTimeoutException,
-                                  DesignDocumentNotFoundException,
-                                  InvalidArgumentException)
+from couchbase.exceptions import DesignDocumentNotFoundException, InvalidArgumentException
 from couchbase.management.views import DesignDocumentNamespace
 from couchbase.options import ViewOptions
 from couchbase.views import (ViewMetaData,
@@ -267,39 +264,6 @@ async def test_view_query_startkey_docid(self, cb_env):
         assert isinstance(metadata, ViewMetaData)
         assert metadata.total_rows() >= expected_count
 
-    # creating a new connection, allow retries
-    @pytest.mark.flaky(reruns=5, reruns_delay=1)
-    @pytest.mark.asyncio
-    async def test_view_query_timeout(self, cb_env):
-        from acouchbase.cluster import Cluster
-        from couchbase.auth import PasswordAuthenticator
-        from couchbase.options import ClusterOptions, ClusterTimeoutOptions
-        conn_string = cb_env.config.get_connection_string()
-        username, pw = cb_env.config.get_username_and_pw()
-        auth = PasswordAuthenticator(username, pw)
-        # Prior to PYCBC-1521, this test would fail as each request would override the cluster level views_timeout.
-        # If a timeout was not provided in the request, the default 75s timeout would be used.  PYCBC-1521 corrects
-        # this behavior so this test will pass as we are essentially forcing an AmbiguousTimeoutException because
-        # we are setting the cluster level views_timeout such a small value.
-        timeout_opts = ClusterTimeoutOptions(views_timeout=timedelta(milliseconds=1))
-        cluster = await Cluster.connect(f'{conn_string}', ClusterOptions(auth, timeout_options=timeout_opts))
-        # don't need to do this except for older server versions
-        bucket = cluster.bucket(f'{cb_env.bucket.name}')
-        with pytest.raises(AmbiguousTimeoutException):
-            res = bucket.view_query(cb_env.DOCNAME,
-                                    cb_env.TEST_VIEW_NAME,
-                                    limit=10,
-                                    namespace=DesignDocumentNamespace.DEVELOPMENT)
-            [r async for r in res.rows()]
-        # if we override the timeout w/in the request the query should succeed.
-        res = bucket.view_query(cb_env.DOCNAME,
-                                cb_env.TEST_VIEW_NAME,
-                                limit=10,
-                                namespace=DesignDocumentNamespace.DEVELOPMENT,
-                                timeout=timedelta(seconds=10))
-        rows = [r async for r in res.rows()]
-        assert len(rows) > 0
-
 
 class ClassicViewsTests(ViewsTestSuite):
     @pytest.fixture(scope='class')

acouchbase/tests/views_t.py

@@ -23,7 +23,8 @@
                                   EventingFunctionNotBootstrappedException,
                                   EventingFunctionNotDeployedException,
                                   EventingFunctionNotFoundException,
-                                  EventingFunctionNotUnDeployedException)
+                                  EventingFunctionNotUnDeployedException,
+                                  InternalServerFailureException)
 from couchbase.management.collections import CollectionSpec
 from couchbase.management.eventing import (EventingFunction,
                                            EventingFunctionBucketAccess,
@@ -33,7 +34,6 @@
                                            EventingFunctionDeploymentStatus,
                                            EventingFunctionKeyspace,
                                            EventingFunctionLanguageCompatibility,
-                                           EventingFunctionProcessingStatus,
                                            EventingFunctionSettings,
                                            EventingFunctionsStatus,
                                            EventingFunctionState,
@@ -89,14 +89,16 @@ def create_eventing_function(self, cb_env):
         cb_env.efm.upsert_function(cb_env.BASIC_FUNC)
 
     @pytest.fixture()
-    def drop_eventing_function(self, cb_env):
+    def drop_eventing_functions(self, cb_env):
         yield
-        cb_env.efm.drop_function(cb_env.TEST_EVT_NAME)
-        TestEnvironment.try_n_times_till_exception(10,
-                                                   1,
-                                                   cb_env.efm.get_function,
-                                                   cb_env.BASIC_FUNC.name,
-                                                   EventingFunctionNotFoundException)
+        for fn_name in cb_env.function_names:
+            cb_env.efm.drop_function(fn_name)
+            TestEnvironment.try_n_times_till_exception(10,
+                                                       1,
+                                                       cb_env.efm.get_function,
+                                                       fn_name,
+                                                       EventingFunctionNotFoundException)
+        cb_env.function_names = []
 
     @pytest.fixture()
     def undeploy_and_drop_eventing_function(self, cb_env):
@@ -110,11 +112,12 @@ def undeploy_and_drop_eventing_function(self, cb_env):
                                                    cb_env.BASIC_FUNC.name,
                                                    EventingFunctionNotFoundException)
 
+    @pytest.mark.usefixtures('drop_eventing_functions')
     def test_constant_bindings(self, cb_env):
-        # TODO:  look into why timeout occurs when providing > 1 constant
-        # binding
+        # TODO:  look into why timeout occurs when providing > 1 constant binding
+        cb_env.function_names = ['test-evt-const-func']
         local_func = EventingFunction(
-            'test-evt-const-func',
+            cb_env.function_names[0],
             cb_env.SIMPLE_EVT_CODE,
             cb_env.evt_version,
             metadata_keyspace=EventingFunctionKeyspace('default'),
@@ -165,8 +168,13 @@ def test_deploy_function_fail(self, cb_env):
         cb_env.wait_until_status(10, 1, EventingFunctionState.Undeployed, cb_env.BASIC_FUNC.name)
         cb_env.efm.deploy_function(cb_env.BASIC_FUNC.name)
         cb_env.wait_until_status(20, 3, EventingFunctionState.Deployed, cb_env.BASIC_FUNC.name)
-        with pytest.raises(EventingFunctionAlreadyDeployedException):
+        if cb_env.server_version_short >= 8.0:
+            # no longer a failure in 8.0+
             cb_env.efm.deploy_function(cb_env.BASIC_FUNC.name)
+            cb_env.wait_until_status(20, 3, EventingFunctionState.Deployed, cb_env.BASIC_FUNC.name)
+        else:
+            with pytest.raises(EventingFunctionAlreadyDeployedException):
+                cb_env.efm.deploy_function(cb_env.BASIC_FUNC.name)
 
     @pytest.mark.usefixtures('create_eventing_function')
     def test_drop_function(self, cb_env):
@@ -195,10 +203,15 @@ def test_drop_function_fail(self, cb_env):
         with pytest.raises(EventingFunctionNotUnDeployedException):
             cb_env.efm.drop_function(cb_env.BASIC_FUNC.name)
 
+    @pytest.mark.usefixtures('drop_eventing_functions')
     def test_functions_status(self, cb_env):
+        cb_env.function_names = [
+            'test-evt-func-1',
+            'test-evt-func-2',
+        ]
         new_funcs = [
             EventingFunction(
-                'test-evt-func-1',
+                cb_env.function_names[0],
                 cb_env.SIMPLE_EVT_CODE,
                 cb_env.evt_version,
                 metadata_keyspace=EventingFunctionKeyspace('default'),
@@ -215,7 +228,7 @@ def test_functions_status(self, cb_env):
                 ]
             ),
             EventingFunction(
-                'test-evt-func-2',
+                cb_env.function_names[1],
                 cb_env.SIMPLE_EVT_CODE,
                 cb_env.evt_version,
                 metadata_keyspace=EventingFunctionKeyspace('default'),
@@ -241,10 +254,15 @@ def test_functions_status(self, cb_env):
         for func in funcs.functions:
             assert isinstance(func, EventingFunctionStatus)
 
+    @pytest.mark.usefixtures('drop_eventing_functions')
     def test_get_all_functions(self, cb_env):
+        cb_env.function_names = [
+            'test-evt-func-1',
+            'test-evt-func-2',
+        ]
         new_funcs = [
             EventingFunction(
-                'test-evt-func-1',
+                cb_env.function_names[0],
                 cb_env.SIMPLE_EVT_CODE,
                 cb_env.evt_version,
                 metadata_keyspace=EventingFunctionKeyspace('default'),
@@ -261,7 +279,7 @@ def test_get_all_functions(self, cb_env):
                 ]
             ),
             EventingFunction(
-                'test-evt-func-2',
+                cb_env.function_names[1],
                 cb_env.SIMPLE_EVT_CODE,
                 cb_env.evt_version,
                 metadata_keyspace=EventingFunctionKeyspace('default'),
@@ -295,9 +313,11 @@ def test_get_function_fail(self, cb_env):
         with pytest.raises(EventingFunctionNotFoundException):
             cb_env.efm.get_function('not-a-function')
 
+    @pytest.mark.usefixtures('drop_eventing_functions')
     def test_options_simple(self, cb_env):
+        cb_env.function_names = ['test-evt-func-1']
         local_func = EventingFunction(
-            'test-evt-func-1',
+            cb_env.function_names[0],
             cb_env.SIMPLE_EVT_CODE,
             cb_env.evt_version,
             metadata_keyspace=EventingFunctionKeyspace('default'),
@@ -328,8 +348,12 @@ def test_pause_function_fail(self, cb_env):
         with pytest.raises(EventingFunctionNotFoundException):
             cb_env.efm.pause_function('not-a-function')
 
-        with pytest.raises(EventingFunctionNotBootstrappedException):
-            cb_env.efm.pause_function(cb_env.BASIC_FUNC.name)
+        if cb_env.server_version_short >= 8.0:
+            with pytest.raises(InternalServerFailureException):
+                cb_env.efm.pause_function(cb_env.BASIC_FUNC.name)
+        else:
+            with pytest.raises(EventingFunctionNotBootstrappedException):
+                cb_env.efm.pause_function(cb_env.BASIC_FUNC.name)
 
     @pytest.mark.usefixtures('create_eventing_function')
     @pytest.mark.usefixtures('undeploy_and_drop_eventing_function')
@@ -342,15 +366,11 @@ def test_pause_and_resume_function(self, cb_env):
         cb_env.efm.pause_function(cb_env.BASIC_FUNC.name)
         func = TestEnvironment.try_n_times(5, 1, cb_env.efm.get_function, cb_env.BASIC_FUNC.name)
         cb_env.validate_eventing_function(func, shallow=True)
-        # verify function processing status
-        assert func.settings.processing_status == EventingFunctionProcessingStatus.Paused
         cb_env.wait_until_status(15, 2, EventingFunctionState.Paused, cb_env.BASIC_FUNC.name)
         # resume function
         cb_env.efm.resume_function(cb_env.BASIC_FUNC.name)
         func = TestEnvironment.try_n_times(5, 1, cb_env.efm.get_function, cb_env.BASIC_FUNC.name)
         cb_env.validate_eventing_function(func, shallow=True)
-        # verify function processing status
-        assert func.settings.processing_status == EventingFunctionProcessingStatus.Running
         # verify function state
         cb_env.wait_until_status(20, 3, EventingFunctionState.Deployed, cb_env.BASIC_FUNC.name)
 
@@ -361,8 +381,12 @@ def test_resume_function_fail(self, cb_env):
         with pytest.raises(EventingFunctionNotFoundException):
             cb_env.efm.pause_function('not-a-function')
 
-        with pytest.raises(EventingFunctionNotBootstrappedException):
-            cb_env.efm.pause_function(cb_env.BASIC_FUNC.name)
+        if cb_env.server_version_short >= 8.0:
+            with pytest.raises(InternalServerFailureException):
+                cb_env.efm.pause_function(cb_env.BASIC_FUNC.name)
+        else:
+            with pytest.raises(EventingFunctionNotBootstrappedException):
+                cb_env.efm.pause_function(cb_env.BASIC_FUNC.name)
 
     @pytest.mark.usefixtures('create_and_drop_eventing_function')
     def test_undeploy_function(self, cb_env):
@@ -389,9 +413,11 @@ def test_undeploy_function_fail(self, cb_env):
         ):
             cb_env.efm.undeploy_function('not-a-function')
 
+    @pytest.mark.usefixtures('drop_eventing_functions')
     def test_upsert_function(self, cb_env):
+        cb_env.function_names = ['test-evt-func-1']
         local_func = EventingFunction(
-            'test-evt-func-1',
+            cb_env.function_names[0],
             cb_env.SIMPLE_EVT_CODE,
             cb_env.evt_version,
             metadata_keyspace=EventingFunctionKeyspace('default'),
@@ -431,20 +457,22 @@ def test_upsert_function_fail(self, cb_env):
             ]
         )
 
-        # @TODO:  couchbase++ seg faults on this...
-        # with pytest.raises(EventingFunctionCompilationFailureException):
-        #     cb_env.efm.upsert_function(local_func)
-
         local_func.code = cb_env.SIMPLE_EVT_CODE
         local_func.source_keyspace = EventingFunctionKeyspace(
             'beer-sample', "test-scope", "test-collection"
         )
-        with pytest.raises(EventingFunctionCollectionNotFoundException):
-            cb_env.efm.upsert_function(local_func)
-
+        if cb_env.server_version_short >= 8.0:
+            with pytest.raises(InternalServerFailureException):
+                cb_env.efm.upsert_function(local_func)
+        else:
+            with pytest.raises(EventingFunctionCollectionNotFoundException):
+                cb_env.efm.upsert_function(local_func)
+
+    @pytest.mark.usefixtures('drop_eventing_functions')
     def test_url_bindings(self, cb_env):
+        cb_env.function_names = ['test-evt-url-func']
         local_func = EventingFunction(
-            "test-evt-url-func",
+            cb_env.function_names[0],
             cb_env.SIMPLE_EVT_CODE,
             cb_env.evt_version,
             metadata_keyspace=EventingFunctionKeyspace('default'),
@@ -499,6 +527,7 @@ def test_url_bindings(self, cb_env):
         func = TestEnvironment.try_n_times(5, 3, cb_env.efm.get_function, local_func.name)
         cb_env.validate_eventing_function(func)
 
+    @pytest.mark.usefixtures('drop_eventing_functions')
     def test_with_scope_and_collection(self, cb_env):
         EnvironmentFeatures.check_if_feature_supported('collections',
                                                        cb_env.server_version_short,
@@ -514,8 +543,9 @@ def test_with_scope_and_collection(self, cb_env):
                                                    collection_spec,
                                                    expected_exceptions=(CollectionAlreadyExistsException,))
 
+        cb_env.function_names = ['test-evt-func-coll']
         local_func = EventingFunction(
-            'test-evt-func-coll',
+            cb_env.function_names[0],
             cb_env.SIMPLE_EVT_CODE,
             cb_env.evt_version,
             metadata_keyspace=EventingFunctionKeyspace(
@@ -545,8 +575,6 @@ def test_with_scope_and_collection(self, cb_env):
         func = TestEnvironment.try_n_times(5, 3, cb_env.efm.get_function, local_func.name)
         cb_env.validate_eventing_function(func)
 
-        cb_env.efm.drop_function(local_func.name)
-
 
 @pytest.mark.flaky(reruns=5, reruns_delay=1)
 class ClassicEventingManagementTests(EventingManagementTestSuite):
@@ -571,7 +599,7 @@ def couchbase_test_environment(self, cb_base_env, test_manifest_validated):
         cb_env.teardown()
 
 
-@pytest.mark.flaky(reruns=5, reruns_delay=1)
+@pytest.mark.flaky(reruns=2, reruns_delay=1)
 class ClassicScopeEventingManagementTests(EventingManagementTestSuite):
 
     @pytest.fixture(scope='class')