Support for N-depth in module structure, basic testing and a travis pipeline (#3)

With these changes, `cog-command` supports complex commands such as `widget-create` or `some-really-long-command`. See README.md for details. A basic test suite has been added, along with an accompanying travis config to run those tests. A *huge* thank you to @splashx for this great work!

Author: splashx

.gitignore

@@ -2,4 +2,5 @@
 **/*.pyo
 build
 dist
-*.egg-info
+*.egg-info
+.idea

.travis.yml

@@ -0,0 +1,25 @@
+# encrypt the travis password / token using:
+# travis encrypt --add deploy.password
+#deploy:
+#  provider: pypi
+#  user: "Your username"
+#  password:
+#    secure: "Your encrypted password"
+# on:
+#    tags: true
+
+language: python
+
+python:
+  - 3.5
+  - 3.6
+  - nightly
+
+env:
+  - PYTHONPATH=tests/testbundle
+
+install:
+  - pip3 install .
+
+script:
+  - python -m unittest discover -v tests/

README.md

@@ -1,3 +1,5 @@
+[![Build Status](https://travis-ci.org/operable/pycog3.svg?branch=master)](https://travis-ci.org/operable/pycog3)
+
 # pycog3
 
 Simple, opinionated library for building Cog commands in Python3.
@@ -13,7 +15,7 @@ imports, instantiates, and runs Python command code based on the
 values of `$COG_BUNDLE` and `$COG_COMMAND`.
 
 `cog-command`'s magic requires that Python projects follow a strict
-directory layout:
+directory layout (basic):
 
 ```
 <bundle_name>
@@ -27,16 +29,78 @@ directory layout:
            |-- <command2>.py
 
 ```
+
+pycog3 also supports more advanced, multi-level structure when using the `-` field separator in the command name. 
+For example, defining:
+ * `commands\commanda.py` - maps to `!commanda`
+ * `commands\level1\commandb.py` - maps to `!level1-commandb`
+ * `commands\level1\level2a\commandc.py` - maps to `!level1-level2a-commandb`
+ * `commands\level1\level2b\leveln\commandz.py` - maps to `!level1-level2b-leveln-commandz`
+ 
+
+```
+<bundle_directory>
+  |
+  |-- <bundle_name>
+       |-- __init__.py
+       |-- commands
+           |
+           |-- __init__.py
+           |-- <commanda>.py
+           |-- <commandb>.py
+           .
+           .
+           |-- <commandz>.py
+           |
+           |-- <level1>
+                |
+                |-- __init__.py
+                |-- <commanda>.py
+                |-- <commandb>.py
+                .
+                .
+                |-- <commandz>.py
+                |
+                |-- <level2a>
+                |    |
+                |    |-- <commanda>.py
+                |    |-- <commandb>.py
+                |    |-- <commandc>.py
+                |    .
+                |    .
+                |    |-- <commandz>.py
+                |
+                |-- <level2b>
+                     |
+                     |-- __init__.py
+                     |-- <...>
+                         |
+                         |-- __init__.py
+                         | -- <leveln>
+                              |
+                              |-- __init__.py
+                              |-- <commanda>.py
+                              |-- <commandb>.py
+                              .
+                              .
+                              |-- <commandz>.py
+
+```
+
+The only requirement is a class with the same name of the filename should exist (first letter capital).
+
 ## Examples
 
 See the [cog-bundles/statuspage](https://github.com/cog-bundles/statuspage) repository for an example of this library in action.
 
+If you're interested in the multi-level usage, check the cog-bundle [pi-bundle](https://github.com/pan-net-security/pi-bundle) or the test bundle in `test/`.
+
 ## Installation
 
 Add this line to your application's setup.py or requirements.txt:
 
 ```
-pycog3>=0.1.25
+pycog3>=0.1.28
 ```
 
 ## TODO

bin/cog-command

@@ -2,13 +2,36 @@
 
 import importlib
 import os
+import sys
+
+
+def fail(message):
+    print("%s" % (message), file=sys.stderr)
+    sys.stdout.flush()
+    sys.stderr.flush()
+    sys.exit(1)
 
 bundle_name = os.getenv("COG_BUNDLE")
+
 command_name = os.getenv("COG_COMMAND")
-class_name = command_name.capitalize()
-full_path = "%s.commands.%s" % (bundle_name, command_name)
 
-bundle_module = importlib.import_module(full_path)
+try:
+    path = command_name.replace("-", ".")
+except AttributeError as e:
+     fail("ERROR: COG_COMMAND env var is not set")
+
+full_path = "%s.commands.%s" % (bundle_name, path)
+class_name = command_name.split("-")[-1].capitalize()
+
+
+try:
+    bundle_module = importlib.import_module(full_path)
+except ImportError as e:
+    if len(command_name)==0:
+        fail("ERROR: COG_COMMAND env var is set but empty")
+    else:
+        fail('ERROR: Unable to import module "' + str(full_path) + '"')
+
 klass = getattr(bundle_module, class_name)
 cmd = klass()
-cmd.execute()
+cmd.execute()

cog/request.py

@@ -1,7 +1,6 @@
 import json
 import os
 import re
-import string
 import sys
 
 class Request(object):

requirements.txt

@@ -1,17 +1,15 @@
-# from setuptools import setup, find_packages
 from distutils.core import setup
 
 setup (
     name = "pycog3",
-    version = "0.1.27",
+    version = "0.1.28",
     scripts = ["bin/cog-command"],
     description = "Command library for the Cog ChatOps platform for Python3",
     author = "Kevin Smith",
     author_email = "[email protected]",
     url = "https://github.com/cog-bundles/pycog3",
-    download_url = "https://github.com/cog-bundles/pycog3/tarball/0.1.27",
+    download_url = "https://github.com/cog-bundles/pycog3/tarball/0.1.28",
     packages = ["cog"],
-    requires = ["requests (>=2.10)", "PyYAML (>=3.11)"],
     keywords = ["bot", "devops", "chatops", "automation"],
     classifiers = [
         "Programming Language :: Python :: 3",

setup.py

@@ -0,0 +1,67 @@
+import os
+import unittest
+import subprocess
+
+
+# test summary for command
+# !commanda
+# !level1 - commanda
+# !level1 - level2a - commandc
+# !level1 - level2b - leveln - commandz
+# !nonexistent
+# COG_COMMAND env var no set
+# COG_COMMAND env var set but empty
+
+class TestCommand(unittest.TestCase):
+
+    fixed_output_prefix = "COG_TEMPLATE: template\nJSON\n"
+    bundle_name = 'testbundle'
+
+    def setUp(self):
+        os.environ['dyn_config_var1'] = '1'
+        os.environ['COG_BUNDLE'] = self.bundle_name
+        self.maxDiff=None
+        pass
+
+    def test_level0_commanda(self):
+        os.environ['COG_COMMAND'] = 'commanda'
+        result = subprocess.check_output(["cog-command"])
+
+        self.assertEqual(result.decode("utf-8"), self.fixed_output_prefix + '"0a"\n')
+
+    def test_level1_commandb(self):
+        os.environ['COG_COMMAND'] = 'level1-commandb'
+        result = subprocess.check_output(["cog-command"])
+
+        self.assertEqual(result.decode("utf-8") , self.fixed_output_prefix+'"1b"\n')
+
+    def test_level1_level2a_commandc(self):
+        os.environ['COG_COMMAND'] = 'level1-level2a-commandc'
+        result = subprocess.check_output(["cog-command"])
+
+        self.assertEqual(result.decode("utf-8"), self.fixed_output_prefix + '"2ac"\n')
+
+    def test_level1_level2b_leveln_commandz(self):
+        os.environ['COG_COMMAND'] = 'level1-level2b-leveln-commandz'
+        result = subprocess.check_output(["cog-command"])
+
+        self.assertEqual(result.decode("utf-8"), self.fixed_output_prefix + '"nz"\n')
+
+    def test_missing_cog_command_env_var(self):
+        os.environ.pop("COG_COMMAND")
+        result=subprocess.run(["cog-command"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        self.assertEqual(result.stderr.decode("utf-8"), "ERROR: COG_COMMAND env var is not set\n")
+
+    def test_empty_cog_command_env_var(self):
+        os.environ['COG_COMMAND'] = ''
+        result=subprocess.run(["cog-command"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        self.assertEqual(result.stderr.decode("utf-8"), "ERROR: COG_COMMAND env var is set but empty\n")
+
+    def test_invalid_command(self):
+        os.environ['COG_COMMAND'] = 'nonexisting'
+        full_path = "%s.commands.%s" % (self.bundle_name, os.environ.get("COG_COMMAND"))
+        result=subprocess.run(["cog-command"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        self.assertEqual(result.stderr.decode("utf-8"), 'ERROR: Unable to import module "' + str(full_path) + '"\n')
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_command.py

@@ -0,0 +1,30 @@
+testbundle 
+=======================================
+
+# Overview
+
+This is a dummy cog bundle used to test pycog3 python module. 
+ 
+
+# Configuring
+
+There is one dynamic configuration variable `dyn_config_var1` which should be set in the environmental variables:
+
+# Executing
+
+Should be executed after `pycog3` is installed. 
+If running outside cog's environment, at the root of the project `/`, do:
+
+```bash
+$ export PYTHONPATH=tests/testbundle
+$ export COG_BUNDLE="testbundle"
+$ export COG_COMMAND="commanda"
+$ export dyn_config_var1="foo"
+$ cog-command
+COG_TEMPLATE: template
+JSON
+"0a"
+```
+
+
+

tests/testbundle/README.md

@@ -0,0 +1,18 @@
+from cog.command import Command
+
+
+class Testbundle(Command):
+    def run(self):
+        pass
+
+    def __init__(self):
+        super().__init__()
+        self.dyn_config_var1 = None
+
+    def prepare(self):
+        self.dyn_config_var1 = self.config("dyn_config_var1")
+        if self.dyn_config_var1 is None:
+            self.fail('Missing dyn_config_var1')
+
+    def level0_function(self):
+        return "0" #string 0 representing level 0

tests/testbundle/testbundle/__init__.py

@@ -0,0 +1,14 @@
+from testbundle.commands.base import Testbundle
+
+
+class Commanda(Testbundle):
+    def __init__(self):
+        super().__init__()
+
+    def run(self):
+        self.run_command()
+
+    def run_command(self):
+        level = self.level0_function()
+        level = level + "a"
+        self.response.content(level, template="template").send()

tests/testbundle/testbundle/commands/__init__.py

@@ -0,0 +1,11 @@
+from testbundle.commands.base import Testbundle
+
+class Level1(Testbundle):
+    def run(self):
+        pass
+
+    def __init__(self):
+        super().__init__()
+
+    def level1_function(self):
+        return "1"

tests/testbundle/testbundle/commands/base.py

@@ -0,0 +1,14 @@
+from testbundle.commands.level1.base import Level1
+
+class Commandb(Level1):
+    def __init__(self):
+        super().__init__()
+
+    def run(self):
+        self.level1_function()
+        self.run_command()
+
+    def run_command(self):
+        level = self.level1_function()
+        level = level + "b"
+        self.response.content(level, template="template").send()

tests/testbundle/testbundle/commands/commanda.py

@@ -0,0 +1,12 @@
+from testbundle.commands.level1.base import Level1
+
+
+class Level2a(Level1):
+    def run(self):
+        pass
+
+    def __init__(self):
+        super().__init__()
+
+    def level2a_function(self):
+        return "2a"

tests/testbundle/testbundle/commands/level1/base.py

@@ -0,0 +1,13 @@
+from testbundle.commands.level1.level2a.base import Level2a
+
+class Commandc(Level2a):
+    def __init__(self):
+        super().__init__()
+
+    def run(self):
+        self.run_command()
+
+    def run_command(self):
+        level = self.level2a_function()
+        level = level + "c"
+        self.response.content(level, template="template").send()