🎨 Fully integrate Poetry, fix tests

Author: thenamesweretakenalready

.circleci/config.yml

@@ -1,37 +1,100 @@
-# Python CircleCI 2.0 configuration file
+# https://gist.github.com/jonatasbaldin/b0eba2ac8ee887ca27ee811697d4d73b
 version: 2
-workflows:
-    version: 2
-    test:
-        jobs:
-        - test-3.8
-        - test-3.6
 
 jobs:
-  test-3.8: &tests
+
+  # Building and testing the project
+  # Useful when a PR is open, for example
+  build-and-test:
+    # Our environment, Python 3.6.8
     docker:
       - image: circleci/python:3.8
 
-    working_directory: ~/repo
-
+    # The steps for our build-and-test
     steps:
-      # Step 1: obtain repo from GitHub
+      # Get the code
       - checkout
-      # Step 2: create virtual env and install dependencies
+
+      # Cache can be tricky at first, but this means
+      # Please, restore my cache (what is actually on the cache will be defined later)
+      # if the text key `deps-{{ checksum "poetry.lock" }}` changes (and it WILL change everytime poetry.lock is updated since we rely on its checksum)
+      # and poetry.lock is updated every time we add a new dependency to our project
+      - restore_cache:
+          keys:
+            - deps-{{ checksum "poetry.lock" }}
+
+      # Let's install the dependencies
       - run:
-          name: install dependencies
+          name: Install Dependencies
           command: |
-            python -m venv venv
-            . venv/bin/activate
-            pip install -r requirements.txt
-      # Step 3: run linter and tests
+            poetry install
+
+      # Save's the specified path as a cache. This is the path Poetry uses to install the dependencies
+      # So if you don't install anything new, this folder won't change and the cache will be effective
+      - save_cache:
+          key: deps-{{ checksum "poetry.lock" }}
+          paths:
+            - /home/circleci/.cache/pypoetry/virtualenvs
+
+      # Another step, run flake8
+      - run:
+          name: Run flake8
+          command: |
+            poetry run flake8 .
+
+      # Last step, runs our tests ommiting the dependencies path (so we don't take their coverage into account)
+      # And send our coverage somewhere, in this case, coveralls
       - run:
-          name: run tests
+          name: Run Pytest, report coverage
           command: |
-            . venv/bin/activate
-            python tests/test_main.py
+            poetry run coverage run --omit="/home/circleci/.cache/pypoetry/virtualenvs" -m pytest
+            poetry run coveralls
 
-  test-3.6:
-    <<: *tests
+  # This is the definition of another job, the one we use to publish the package to PyPI
+  deployment:
+
+    # Same environment
     docker:
-      - image: circleci/python:3.6
+        - image: circleci/python:3.6.8
+      steps:
+
+        # Gets the code
+        - checkout
+
+        # Use `poetry publish` to Publish he package using username and password from CircleCI environment variables
+        # Which can be configured inside CircleCI's interface
+        - run:
+            name: Push to PyPI
+            command: |
+              poetry publish --build --username "${PYPI_USERNAME}" --password "${PYPI_PASSWORD}" --no-interaction
+
+# In the workflows section, we specify when we want to run the jobs defined
+workflows:
+  version: 2
+
+  # The build-and-test we will run EVERYTIME a piece of code changes
+  build-and-test-workflow:
+    jobs:
+      - build-and-test
+
+  # The deployment workflow publishes the package
+  deployment-workflow:
+    jobs:
+
+      # Runs build and test, but now just on Git tags (created from a GitHub release)
+      - build-and-test:
+          filters:
+            tags:
+              only: /v[0-9]+(\.[0-9]+)*/
+            branches:
+              ignore: /.*/
+
+      # Runs the deployment job, just with the tags as well
+      - deployment:
+          requires:
+            - build-and-test
+          filters:
+              tags:
+                only: /v[0-9]+(\.[0-9]+)*/
+              branches:
+                ignore: /.*/t

pyproject.toml

@@ -1,8 +1,8 @@
 [tool.poetry]
-name = "sv443s-jokeapi-python-wrapper"
-version = "0.1.0"
-description = ""
-authors = ["Leet Hakker <[email protected]>"]
+name = "jokeapi"
+version = "0.2.9"
+description = "An API wrapper for Sv443's JokeAPI"
+authors = ["leet hakker <[email protected]>"]
 
 [tool.poetry.dependencies]
 python = "^3.8"
@@ -17,5 +17,10 @@ mypy = "^0.790"
 
 
 [build-system]
-requires = ["poetry-core>=1.0.0"]
+requires = ["poetry-core>=1.0.0",
+    	    "setuptools>=30.3.0,<50",
+	    "wheel",
+	    "pytest-runner",
+	    "setuptools_scm>=3.3.1",
+	    ]
 build-backend = "poetry.core.masonry.api"

jokeapi/__init__.py renamed to src/jokeapi/__init__.py

@@ -1,6 +1,9 @@
 from os import getenv
-from jokeapi import Jokes
 from dotenv import load_dotenv
+import sys, os
+
+sys.path.append(os.path.join(os.path.dirname(__file__), os.pardir, "src"))
+from jokeapi import Jokes
 
 load_dotenv()
 
@@ -9,103 +12,99 @@
 token = getenv("token")
 
 
-try:
-    j.get_joke()
-except Exception as e:
-    errors.append({"Error in": "blank joke get", "Error": e})
-
-"""Testing auth tokens"""
-try:
-    j.get_joke(auth_token=token)
-except Exception as e:
-    auth_token = None
-    errors.append({"Error in": "auth usage", "Error": e})
-
-"""Testing for errors in categories"""
-try:
-    j.get_joke(category=["programming"], auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "category programming", "Error": e})
-try:
-    j.get_joke(category=["misc"], auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "category miscellaneous", "Error": e})
-try:
-    j.get_joke(category=["dark"], auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "category dark", "Error": e})
-
-"""Testing for errors in blacklist"""
-try:
-    j.get_joke(blacklist=["nsfw"], auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "blacklist nsfw", "Error": e})
-
-try:
-    j.get_joke(blacklist=["religious"], auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "blacklist religious", "Error": e})
-
-try:
-    j.get_joke(blacklist=["political"], auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "blacklist political", "Error": e})
-
-try:
-    j.get_joke(blacklist=["racist"], auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "blacklist political", "Error": e})
-
-try:
-    j.get_joke(blacklist=["sexist"], auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "blacklist sexist", "Error": e})
-
-
-"""Testing for errors in response_format"""
-try:
-    j.get_joke(response_format="xml", auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "response_format xml", "Error": e})
-
-try:
-    j.get_joke(response_format="yaml", auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "response_format yaml", "Error": e})
-
-
-"""Testing for errors in type"""
-try:
-    j.get_joke(joke_type="single", auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "type single", "Error": e})
-
-try:
-    j.get_joke(joke_type="twopart", auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "type double", "Error": e})
-
-
-"""Testing for errors in search_string"""
-try:
-    j.get_joke(search_string="search", auth_token=token)
-    # as long as this gets a response, the api wrapper is fine;
-    # it probably doesn't exist in a joke.
-except Exception as e:
-    errors.append({"Error in": "search_string", "Error": e})
-
-
-"""Testing for errors in id_range"""
-try:
-    j.get_joke(id_range=[30, 151], auth_token=token)
-except Exception as e:
-    errors.append({"Error in": "id_range", "Error": e})
-
-
-if len(errors):
-    for e in errors:
-        print(f"Error in:  {e['Error in']}\nError: {e['Error']}")
-    if len(errors) == 1:
-        raise Exception("1 error occured")
-
-    raise Exception(f"{len(errors)} errors occurred")
+def test_main():
+    try:
+        j.get_joke()
+    except Exception as e:
+        errors.append({"Error in": "blank joke get", "Error": e})
+
+    """Testing auth tokens"""
+    try:
+        j.get_joke(auth_token=token)
+    except Exception as e:
+        auth_token = None
+        errors.append({"Error in": "auth usage", "Error": e})
+
+    """Testing for errors in categories"""
+    try:
+        j.get_joke(category=["programming"], auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "category programming", "Error": e})
+    try:
+        j.get_joke(category=["misc"], auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "category miscellaneous", "Error": e})
+    try:
+        j.get_joke(category=["dark"], auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "category dark", "Error": e})
+
+    """Testing for errors in blacklist"""
+    try:
+        j.get_joke(blacklist=["nsfw"], auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "blacklist nsfw", "Error": e})
+
+    try:
+        j.get_joke(blacklist=["religious"], auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "blacklist religious", "Error": e})
+
+    try:
+        j.get_joke(blacklist=["political"], auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "blacklist political", "Error": e})
+
+    try:
+        j.get_joke(blacklist=["racist"], auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "blacklist political", "Error": e})
+
+    try:
+        j.get_joke(blacklist=["sexist"], auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "blacklist sexist", "Error": e})
+
+    """Testing for errors in response_format"""
+    try:
+        j.get_joke(response_format="xml", auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "response_format xml", "Error": e})
+
+    try:
+        j.get_joke(response_format="yaml", auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "response_format yaml", "Error": e})
+
+    """Testing for errors in type"""
+    try:
+        j.get_joke(joke_type="single", auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "type single", "Error": e})
+
+    try:
+        j.get_joke(joke_type="twopart", auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "type double", "Error": e})
+
+    """Testing for errors in search_string"""
+    try:
+        j.get_joke(search_string="search", auth_token=token)
+        # as long as this gets a response, the api wrapper is fine;
+        # it probably doesn't exist in a joke.
+    except Exception as e:
+        errors.append({"Error in": "search_string", "Error": e})
+
+    """Testing for errors in id_range"""
+    try:
+        j.get_joke(id_range=[30, 151], auth_token=token)
+    except Exception as e:
+        errors.append({"Error in": "id_range", "Error": e})
+
+    if len(errors):
+        for e in errors:
+            print(f"Error in:  {e['Error in']}\nError: {e['Error']}")
+        if len(errors) == 1:
+            raise Exception("1 error occured")
+
+        raise Exception(f"{len(errors)} errors occurred")