Merge pull request #10 from dragonchain/master

cheeseandcereal · web-flow · commit c10dddf66c27 · 2019-10-25T09:52:31.000-07:00
Release 4.0.1
diff --git a/.travis.yml b/.travis.yml
@@ -24,13 +24,16 @@ matrix:
     - name: CPython 3.7
       python: 3.7
       dist: xenial
+    - name: CPython 3.8
+      python: 3.8
+      dist: bionic
 install:
-  - if [ $TRAVIS_PYTHON_VERSION = 3.7 ]; then ./run.sh install-req; else ./run.sh install-req skip-extras; fi
+  - if [ $TRAVIS_PYTHON_VERSION = 3.8 ]; then ./run.sh install-req; else ./run.sh install-req skip-extras; fi
 before_script:
   - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
   - chmod +x ./cc-test-reporter
   - ./cc-test-reporter before-build
 script:
-  - if [ $TRAVIS_PYTHON_VERSION = 3.7 ]; then ./run.sh full-build; elif [ $TRAVIS_PYTHON_VERSION = 3.4 ]; then ./run.sh full-build no-async; else ./run.sh full-build no-format; fi
+  - if [ $TRAVIS_PYTHON_VERSION = 3.8 ]; then ./run.sh full-build; elif [ $TRAVIS_PYTHON_VERSION = 3.4 ]; then ./run.sh full-build no-async; else ./run.sh full-build no-format; fi
 after_script:
-  - if [ $TRAVIS_PYTHON_VERSION = 3.7 ]; then ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT; fi
+  - if [ $TRAVIS_PYTHON_VERSION = 3.8 ]; then ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT; fi
diff --git a/build.Dockerfile b/build.Dockerfile
@@ -0,0 +1,9 @@
+FROM python:3.8
+
+WORKDIR /usr/src/sdk
+COPY requirements.txt /
+COPY dev_requirements.txt /
+RUN python3 -m pip install -r /requirements.txt && \
+    python3 -m pip install -r /dev_requirements.txt
+
+CMD [ "sh", "run.sh", "full-build" ]
diff --git a/docs/changelog.rst b/docs/changelog.rst
@@ -1,6 +1,15 @@
 Changelog
 =========
 
+4.0.1
+-----
+
+Packaging:
+  * Officially support python 3.8 in packaged release
+Development:
+  * Fix unit tests for proper async context mocking with python 3.8+
+  * Add integration tests for Dragonchain 4.1.0 features and changes
+
 4.0.0
 -----
 
diff --git a/dragonchain_sdk/__init__.py b/dragonchain_sdk/__init__.py
@@ -16,7 +16,7 @@
 from dragonchain_sdk import dragonchain_client
 
 __author__ = "Dragonchain, Inc."
-__version__ = "4.0.0"
+__version__ = "4.0.1"
 
 ASYNC_SUPPORT = False
 
diff --git a/dragonchain_sdk/request.py b/dragonchain_sdk/request.py
@@ -270,7 +270,7 @@ def _generate_request_data(
 
         logger.debug("{} {}".format(http_verb, full_url))
         logger.debug("Headers: {}".format(header_dict))
-        logger.debug("Data: {}".format(content))
+        logger.debug("Data: {!r}".format(content))
         return full_url, content, additional_headers
 
     def _make_request(
diff --git a/mypy.ini b/mypy.ini
@@ -9,6 +9,7 @@ warn_unused_configs=True
 # flake8-mypy expects the two following for sensible formatting
 show_column_numbers=True
 show_error_context=False
+no_error_summary=True
 
 # Check all imports
 follow_imports=normal
diff --git a/run.sh b/run.sh
@@ -19,6 +19,7 @@ install      : install the project from source (depends on running build first)
 install-req  : install the python dependencies to dev on the project
 build-dist   : build the distribution artifcats for the project from source
 clean        : remove compiled python/docs/other build or distrubition artifacts from the local project
+docker-test  : run all the checks in a docker container that a PR will test for
 full-build   : run all of the tests that the pull request/build would check, locally
 dist-release : upload and distribute the artifacts from build-dist to pypi"
 
@@ -73,6 +74,9 @@ elif [ "$1" = "build-dist" ]; then
 elif [ "$1" = "clean" ]; then
     find . -name __pycache__ -exec rm -rfv {} +
     rm -rfv .coverage coverage.xml build/ dist/ dragonchain_sdk.egg-info/ docs/.build/
+elif [ "$1" = "docker-test" ]; then
+    docker build . -f ./build.Dockerfile -t dragonchain_sdk_testing_container
+    docker run -v "$(pwd)":/usr/src/sdk dragonchain_sdk_testing_container
 elif [ "$1" = "full-build" ]; then
     set +e
     printf "\\nChecking for linting errors\\n\\n"
diff --git a/setup.py b/setup.py
@@ -67,6 +67,7 @@ def get_version():
         "Programming Language :: Python :: 3.5",
         "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3 :: Only",
         "Programming Language :: Python :: Implementation :: CPython",
         "Programming Language :: Python :: Implementation :: PyPy",
diff --git a/tests/integration/test_interchain.py b/tests/integration/test_interchain.py
@@ -60,6 +60,15 @@ def test_create_ethereum_interchain_with_defaults(self):
         self.assertEqual(response.get("status"), 201, response)
         jsonschema.validate(response.get("response"), schema.ethereum_interchain_at_rest_schema)
 
+    def test_create_ethereum_interchain_fails_with_existing_name(self):
+        response = self.client.create_ethereum_interchain(ETHEREUM_INTERCHAIN_NAME_2, chain_id=1)
+        expected_response = {
+            "status": 409,
+            "ok": False,
+            "response": {"error": {"type": "INTERCHAIN_CONFLICT", "details": "An interchain network with the name you provided already exists"}},
+        }
+        self.assertEqual(response, expected_response)
+
     def test_create_ethereum_interchain_fails_with_bad_rpc_address(self):
         response = self.client.create_ethereum_interchain("garbage", rpc_address="http://youcantGETthis.whatever")
         self.assertFalse(response.get("ok"), response)
@@ -126,6 +135,15 @@ def test_create_bitcoin_interchain_with_defaults(self):
         self.assertEqual(response.get("status"), 201, response)
         jsonschema.validate(response.get("response"), schema.bitcoin_interchain_at_rest_schema)
 
+    def test_create_bitcoin_interchain_fails_with_existing_name(self):
+        response = self.client.create_bitcoin_interchain(BITCOIN_INTERCHAIN_NAME_2, testnet=False)
+        expected_response = {
+            "status": 409,
+            "ok": False,
+            "response": {"error": {"type": "INTERCHAIN_CONFLICT", "details": "An interchain network with the name you provided already exists"}},
+        }
+        self.assertEqual(response, expected_response)
+
     def test_create_bitcoin_interchain_fails_with_bad_rpc_address(self):
         response = self.client.create_bitcoin_interchain("garbage", testnet=True, rpc_address="http://youcantGETthis.whatever")
         self.assertFalse(response.get("ok"), response)
@@ -406,12 +424,14 @@ def suite():
     suite = unittest.TestSuite()
     suite.addTest(TestInterchain("test_create_ethereum_interchain_with_values"))
     suite.addTest(TestInterchain("test_create_ethereum_interchain_with_defaults"))
+    suite.addTest(TestInterchain("test_create_ethereum_interchain_fails_with_existing_name"))
     suite.addTest(TestInterchain("test_create_ethereum_interchain_fails_with_bad_rpc_address"))
     suite.addTest(TestInterchain("test_create_ethereum_interchain_fails_with_mismatching_chain_id"))
     suite.addTest(TestInterchain("test_create_ethereum_interchain_fails_with_bad_private_key"))
     suite.addTest(TestInterchain("test_create_ethereum_interchain_fails_without_chain_id_or_rpc_address"))
     suite.addTest(TestInterchain("test_create_bitcoin_interchain_with_values"))
     suite.addTest(TestInterchain("test_create_bitcoin_interchain_with_defaults"))
+    suite.addTest(TestInterchain("test_create_bitcoin_interchain_fails_with_existing_name"))
     suite.addTest(TestInterchain("test_create_bitcoin_interchain_fails_with_bad_rpc_address"))
     suite.addTest(TestInterchain("test_create_bitcoin_interchain_fails_without_wif_private_key_or_testnet"))
     suite.addTest(TestInterchain("test_create_bitcoin_interchain_fails_with_bad_private_key"))
diff --git a/tests/integration/test_smart_contracts.py b/tests/integration/test_smart_contracts.py
@@ -34,6 +34,8 @@
 SMART_CONTRACT_CRON_ID = None
 ARGS_CONTRACT_BODY = None
 CREATION_TIMESTAMP = None
+CRON_INVOCATION_COUNT = None
+SCHEDULER_INVOCATION_COUNT = None
 
 SCHEDULER = 60
 CRON = "* * * * *"
@@ -202,19 +204,40 @@ def test_update_contract_execution_order(self):
 
     # INVOCATION #
 
-    def wait_for_scheduler_invocation(self):
+    def wait_for_scheduler_invocation_1(self):
         time.sleep(60)
 
+    def disable_schedule(self):
+        self.assertTrue(self.client.update_smart_contract(SMART_CONTRACT_SCHEDULER_ID, disable_schedule=True).get("ok"))
+        self.assertTrue(self.client.update_smart_contract(SMART_CONTRACT_CRON_ID, disable_schedule=True).get("ok"))
+
     def test_successful_invocation_of_scheduler(self):
         transaction_invocation = self.client.query_transactions(SMART_CONTRACT_SCHEDULER_NAME, "*")
-        self.assertGreater(transaction_invocation["response"]["total"], 0)
+        global SCHEDULER_INVOCATION_COUNT
+        SCHEDULER_INVOCATION_COUNT = transaction_invocation["response"]["total"]
+        self.assertGreater(SCHEDULER_INVOCATION_COUNT, 0)
         self.assertGreater(transaction_invocation["response"]["results"][0]["header"]["timestamp"], CREATION_TIMESTAMP)
 
     def test_successful_invocation_of_cron(self):
         transaction_invocation = self.client.query_transactions(SMART_CONTRACT_CRON_NAME, "*")
-        self.assertGreater(transaction_invocation["response"]["total"], 0)
+        global CRON_INVOCATION_COUNT
+        CRON_INVOCATION_COUNT = transaction_invocation["response"]["total"]
+        self.assertGreater(CRON_INVOCATION_COUNT, 0)
         self.assertGreater(transaction_invocation["response"]["results"][0]["header"]["timestamp"], CREATION_TIMESTAMP)
 
+    def wait_for_scheduler_invocation_2(self):
+        time.sleep(65)
+
+    def test_disable_schedule_works_on_scheduler(self):
+        transaction_invocation = self.client.query_transactions(SMART_CONTRACT_SCHEDULER_NAME, "*")
+        # Assert that the transaction count after waiting 60 seconds is the same as after we immediately disabled the schedule
+        self.assertEqual(SCHEDULER_INVOCATION_COUNT, transaction_invocation["response"]["total"])
+
+    def test_disable_schedule_works_on_cron(self):
+        transaction_invocation = self.client.query_transactions(SMART_CONTRACT_CRON_NAME, "*")
+        # Assert that the transaction count after waiting 60 seconds is the same as after we immediately disabled the schedule
+        self.assertEqual(CRON_INVOCATION_COUNT, transaction_invocation["response"]["total"])
+
     def test_successful_invocation_with_transactions(self):
         args_transaction = self.client.create_transaction(SMART_CONTRACT_ARGS_NAME, "banana", tag="banana")
         env_transaction = self.client.create_transaction(SMART_CONTRACT_ENV_NAME, "banana", tag="banana")
@@ -356,9 +379,13 @@ def suite():
     suite.addTest(TestSmartContracts("test_update_contract_with_env"))
     suite.addTest(TestSmartContracts("test_update_contract_with_secrets"))
     suite.addTest(TestSmartContracts("test_update_contract_execution_order"))
-    suite.addTest(TestSmartContracts("wait_for_scheduler_invocation"))
+    suite.addTest(TestSmartContracts("wait_for_scheduler_invocation_1"))
+    suite.addTest(TestSmartContracts("disable_schedule"))
     suite.addTest(TestSmartContracts("test_successful_invocation_of_scheduler"))
     suite.addTest(TestSmartContracts("test_successful_invocation_of_cron"))
+    suite.addTest(TestSmartContracts("wait_for_scheduler_invocation_2"))
+    suite.addTest(TestSmartContracts("test_disable_schedule_works_on_scheduler"))
+    suite.addTest(TestSmartContracts("test_disable_schedule_works_on_cron"))
     suite.addTest(TestSmartContracts("test_successful_invocation_with_transactions"))
     suite.addTest(TestSmartContracts("test_get_contract_logs_with_contract_id"))
     suite.addTest(TestSmartContracts("test_get_contract_logs_with_contract_id_tail_and_since"))
diff --git a/tests/integration/test_transactions.py b/tests/integration/test_transactions.py
@@ -18,6 +18,9 @@
 from tests.integration import schema
 import dragonchain_sdk
 
+SC_ID = None
+SC_TXN_TYPE = "contractType1"
+INVOKER_TXN_ID = None
 TEST_TXN_TYPE = "testingType1"
 QUERY_TXN_TYPE = "queryTesting"
 EMPTY_STRING_TXN_ID = None
@@ -40,6 +43,8 @@ def setUp(self):
 
     def set_up_transaction_types(self):
         try:
+            global SC_ID
+            SC_ID = self.client.create_smart_contract(SC_TXN_TYPE, "alpine:latest", "echo", ["hello"])["response"]["id"]
             self.client.create_transaction_type(TEST_TXN_TYPE)
             self.client.create_transaction_type(
                 QUERY_TXN_TYPE,
@@ -49,6 +54,7 @@ def set_up_transaction_types(self):
                     {"path": "test.num", "field_name": "query_num", "type": "number", "options": {"sortable": True}},
                 ],
             )
+            time.sleep(20)
         except Exception:
             pass
 
@@ -102,6 +108,14 @@ def test_create_transaction_with_callback(self):
         self.assertEqual(response.get("status"), 201, response)
         jsonschema.validate(response.get("response"), schema.create_transaction_schema)
 
+    def test_create_transaction_for_smart_contract(self):
+        response = self.client.create_transaction(transaction_type=SC_TXN_TYPE, payload="")
+        self.assertTrue(response.get("ok"), response)
+        self.assertEqual(response.get("status"), 201, response)
+        jsonschema.validate(response.get("response"), schema.create_transaction_schema)
+        global INVOKER_TXN_ID
+        INVOKER_TXN_ID = response["response"]["transaction_id"]
+
     def test_create_transaction_fails_without_transaction_type(self):
         response = self.client.create_transaction(transaction_type="doesnotexist", payload="")
         expected_response = {
@@ -375,6 +389,16 @@ def test_query_transactions_by_general_tag(self):
         self.assertEqual(response1["response"]["results"][0]["header"]["txn_id"], LOW_TXN_ID, "Wrong result for tag query 1")
         self.assertEqual(response2["response"]["results"][0]["header"]["txn_id"], HIGH_TXN_ID, "Wrong result for tag query 2")
 
+    def test_query_transactions_by_invoker(self):
+        response = self.client.query_transactions(SC_TXN_TYPE, "@invoker:{{{}}}".format(INVOKER_TXN_ID.replace("-", "\\-")))
+        self.assertEqual(response.get("status"), 200, response)
+        self.assertTrue(response.get("ok"), response)
+        jsonschema.validate(response.get("response"), schema.query_transaction_schema)
+        # Check we got the correct number of results
+        self.assertEqual(response["response"]["total"], 1)
+        # Double check that the transaction we got back has the invoker we expect
+        self.assertEqual(response["response"]["results"][0]["header"]["invoker"], INVOKER_TXN_ID, response)
+
     def test_query_transactions_verbatim(self):
         response1 = self.client.query_transactions(QUERY_TXN_TYPE, "contently", verbatim=False)  # Stems to match "content" from the tag
         response2 = self.client.query_transactions(QUERY_TXN_TYPE, "contently", verbatim=True)
@@ -499,6 +523,7 @@ def test_query_transactions_raises_400_with_bad_transaction_type(self):
     # CLEANUP #
 
     def clean_up_transaction_types(self):
+        self.client.delete_smart_contract(SC_ID)
         self.client.delete_transaction_type(TEST_TXN_TYPE)
         self.client.delete_transaction_type(QUERY_TXN_TYPE)
 
@@ -512,6 +537,7 @@ def suite():
     suite.addTest(TestTransactions("test_create_transaction_with_nonempty_object_payload"))
     suite.addTest(TestTransactions("test_create_transaction_with_tag"))
     suite.addTest(TestTransactions("test_create_transaction_with_callback"))
+    suite.addTest(TestTransactions("test_create_transaction_for_smart_contract"))
     suite.addTest(TestTransactions("test_create_transaction_fails_without_transaction_type"))
     suite.addTest(TestTransactions("test_create_bulk_transactions_with_all_valid_transactions"))
     suite.addTest(TestTransactions("test_create_bulk_transactions_with_some_nonexisting_transaction_types"))
@@ -533,6 +559,7 @@ def suite():
     suite.addTest(TestTransactions("test_query_transactions_by_timestamp"))
     suite.addTest(TestTransactions("test_query_transactions_by_block_id"))
     suite.addTest(TestTransactions("test_query_transactions_by_general_tag"))
+    suite.addTest(TestTransactions("test_query_transactions_by_invoker"))
     suite.addTest(TestTransactions("test_query_transactions_verbatim"))
     suite.addTest(TestTransactions("test_query_transactions_ids_only"))
     suite.addTest(TestTransactions("test_query_transactions_paging"))
diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py
@@ -12,4 +12,5 @@
 import sys
 
 PY36 = sys.version_info[:2] >= (3, 6)
-CI_COVERAGE_VERSION = sys.version_info[:2] == (3, 7)
+PY38 = sys.version_info[:2] >= (3, 8)
+CI_COVERAGE_VERSION = sys.version_info[:2] == (3, 8)
diff --git a/tests/unit/test_async.py b/tests/unit/test_async.py
