Merge pull request #44 from rsgalloway/issue43/stray_include

Version 0.8.1

Author: rsgalloway

.gitignore

@@ -15,4 +15,5 @@ tmp/
 venv*/
 .vscode/
 keys.env
-encrypted.env
+encrypted.env
+baketest.env

lib/envstack/__init__.py

@@ -34,6 +34,6 @@
 """
 
 __prog__ = "envstack"
-__version__ = "0.8.0"
+__version__ = "0.8.1"
 
 from envstack.env import clear, init, revert, save  # noqa: F401

lib/envstack/util.py

@@ -413,7 +413,7 @@ def get_stacks():
     return sorted(list(stacks))
 
 
-def findenv(var_name):
+def findenv(var_name: str):
     """
     Returns a list of paths where the given environment var is set.
 
@@ -552,7 +552,7 @@ def dump_yaml(file_path: str, data: dict, unquote: bool = True):
             pass
 
 
-def partition_platform_data(data):
+def partition_platform_data(data: dict):
     """
     Given a data dictionary with keys 'all', 'darwin', 'linux', 'windows',
     this function finds which key-value pairs are common across all platforms,
@@ -562,13 +562,11 @@ def partition_platform_data(data):
     :param data: dictionary to partition.
     :returns: platform partitioned dictionary.
     """
-
-    # move data under the "all" key if it's not already there
+    # ensure all is present
     if "all" not in data:
-        data["all"] = data.copy()
+        data["all"] = {}  # data.copy()
 
     # platforms of interest (darwin, linux, windows)
-    # platforms = [k for k in data.keys() if k not in ("all", "include")]
     platforms = ["darwin", "linux", "windows"]
 
     # get the union of keys from all platforms
@@ -581,10 +579,8 @@ def partition_platform_data(data):
     for key in all_platform_keys:
         if all(key in data[p] for p in platforms):
             # get first value for comparison later
-            # first_value = data[platforms[0]][key].value
             first_value = data[platforms[0]][key]
             # call it common if all platforms have the same value
-            # if all(data[p][key].value == first_value for p in platforms):
             if all(data[p][key] == first_value for p in platforms):
                 common_keys.append(key)
 
@@ -614,8 +610,10 @@ def partition_platform_data(data):
     for p in platforms:
         new_data[p] = new_platform_dicts[p]
 
-    # add include if it exists
+    # ensure include is present
     if data.get("include"):
         new_data["include"] = data["include"]
+    else:
+        new_data["include"] = []
 
     return new_data

setup.py

@@ -40,7 +40,7 @@
 
 setup(
     name="envstack",
-    version="0.8.0",
+    version="0.8.1",
     description="Stacked environment variable management system",
     long_description=long_description,
     long_description_content_type="text/markdown",

tests/test_cmds.py

@@ -350,6 +350,222 @@ def test_thing(self):
         self.assertEqual(output, expected_output)
 
 
+class TestBake(unittest.TestCase):
+    """Tests bake command."""
+
+    def setUp(self):
+        self.filename = "baketest.env"
+        if os.path.exists(self.filename):
+            os.remove(self.filename)
+        self.envstack_bin = os.path.join(
+            os.path.dirname(__file__), "..", "bin", "envstack"
+        )
+        envpath = os.path.join(os.path.dirname(__file__), "..", "env")
+        self.root = {
+            "linux": "/mnt/pipe",
+            "win32": "X:/pipe",
+            "darwin": "/Volumes/pipe",
+        }.get(sys.platform)
+        os.environ["ENVPATH"] = envpath
+        os.environ["INTERACTIVE"] = "0"
+        # remove so we use base64 encoding by default
+        if AESGCMEncryptor.KEY_VAR_NAME in os.environ:
+            del os.environ[AESGCMEncryptor.KEY_VAR_NAME]
+        if FernetEncryptor.KEY_VAR_NAME in os.environ:
+            del os.environ[FernetEncryptor.KEY_VAR_NAME]
+
+    def tearDown(self):
+        if os.path.exists(self.filename):
+            os.remove(self.filename)
+
+    def test_default(self):
+        """Tests baking the default stack."""
+        command = f"%s -o {self.filename}; cat {self.filename}" % self.envstack_bin
+        expected_output = """#!/usr/bin/env envstack
+include: []
+all: &all
+  <<: *all
+  DEPLOY_ROOT: ${ROOT}/${ENV}
+  ENV: prod
+  ENVPATH: ${DEPLOY_ROOT}/env:${ENVPATH}
+  HELLO: ${HELLO:=world}
+  LOG_LEVEL: ${LOG_LEVEL:=INFO}
+  PATH: ${DEPLOY_ROOT}/bin:${PATH}
+  PYTHONPATH: ${DEPLOY_ROOT}/lib/python:${PYTHONPATH}
+darwin:
+  <<: *all
+  ROOT: /Volumes/pipe
+linux:
+  <<: *all
+  ROOT: /mnt/pipe
+windows:
+  <<: *all
+  ROOT: X:/pipe
+"""
+        output = subprocess.check_output(
+            command,
+            shell=True,
+            universal_newlines=True,
+        )
+        self.assertEqual(output, expected_output)
+
+    def test_dev(self):
+        """Tests baking the dev stack."""
+        command = f"%s dev -o {self.filename}; cat {self.filename}" % self.envstack_bin
+        expected_output = """#!/usr/bin/env envstack
+include: []
+all: &all
+  <<: *all
+  DEPLOY_ROOT: ${ROOT}/dev
+  ENV: dev
+  ENVPATH: ${ROOT}/dev/env:${ROOT}/prod/env:${ENVPATH}
+  HELLO: ${HELLO:=world}
+  LOG_LEVEL: DEBUG
+  PATH: ${ROOT}/dev/bin:${ROOT}/prod/bin:${PATH}
+  PYTHONPATH: ${ROOT}/dev/lib/python:${ROOT}/prod/lib/python:${PYTHONPATH}
+darwin:
+  <<: *all
+  ROOT: /Volumes/pipe
+linux:
+  <<: *all
+  ROOT: /mnt/pipe
+windows:
+  <<: *all
+  ROOT: X:/pipe
+"""
+        output = subprocess.check_output(
+            command,
+            shell=True,
+            universal_newlines=True,
+        )
+        self.assertEqual(output, expected_output)
+
+    def test_thing(self):
+        """Tests baking the thing stack with depth of 1."""
+        command = (
+            f"%s thing -o {self.filename} --depth 1; cat {self.filename}"
+            % self.envstack_bin
+        )
+        expected_output = """#!/usr/bin/env envstack
+include: [default]
+all: &all
+  <<: *all
+  CHAR_LIST: [a, b, c, "${HELLO}"]
+  DICT: {a: 1, b: 2, c: "${INT}"}
+  FLOAT: 1.0
+  HELLO: goodbye
+  INT: 5
+  LOG_LEVEL: ${LOG_LEVEL:=INFO}
+  NUMBER_LIST: [1, 2, 3]
+darwin:
+  <<: *all
+  ROOT: ${HOME}/Library/Application Support/pipe
+linux:
+  <<: *all
+  ROOT: ${HOME}/.local/pipe
+windows:
+  <<: *all
+  ROOT: C:/ProgramData/pipe
+"""
+        output = subprocess.check_output(
+            command,
+            shell=True,
+            universal_newlines=True,
+        )
+        self.assertEqual(output, expected_output)
+
+    def test_default_encrypted(self):
+        """Tests baking the default stack encrypted with base64."""
+        command = (
+            f"%s --encrypt -o {self.filename}; cat {self.filename}" % self.envstack_bin
+        )
+        expected_output = """#!/usr/bin/env envstack
+include: []
+all: &all
+  <<: *all
+  DEPLOY_ROOT: !encrypt JHtST09UfS8ke0VOVn0=
+  ENV: !encrypt cHJvZA==
+  ENVPATH: !encrypt JHtERVBMT1lfUk9PVH0vZW52OiR7RU5WUEFUSH0=
+  HELLO: !encrypt JHtIRUxMTzo9d29ybGR9
+  LOG_LEVEL: !encrypt JHtMT0dfTEVWRUw6PUlORk99
+  PATH: !encrypt JHtERVBMT1lfUk9PVH0vYmluOiR7UEFUSH0=
+  PYTHONPATH: !encrypt JHtERVBMT1lfUk9PVH0vbGliL3B5dGhvbjoke1BZVEhPTlBBVEh9
+darwin:
+  <<: *all
+  ROOT: !encrypt L1ZvbHVtZXMvcGlwZQ==
+linux:
+  <<: *all
+  ROOT: !encrypt L21udC9waXBl
+windows:
+  <<: *all
+  ROOT: !encrypt WDovcGlwZQ==
+"""
+        output = subprocess.check_output(
+            command,
+            shell=True,
+            universal_newlines=True,
+        )
+        self.assertEqual(output, expected_output)
+
+    def test_thing_encrypted(self):
+        """Tests baking the thing stack with depth of 1 excrypted."""
+        command = (
+            f"%s thing --encrypt -o {self.filename} --depth 1; cat {self.filename}"
+            % self.envstack_bin
+        )
+        expected_output = """#!/usr/bin/env envstack
+include: [default]
+all: &all
+  <<: *all
+  CHAR_LIST: !encrypt WydhJywgJ2InLCAnYycsICcke0hFTExPfSdd
+  DICT: !encrypt eydhJzogMSwgJ2InOiAyLCAnYyc6ICcke0lOVH0nfQ==
+  FLOAT: !encrypt MS4w
+  HELLO: !encrypt Z29vZGJ5ZQ==
+  INT: !encrypt NQ==
+  LOG_LEVEL: !encrypt JHtMT0dfTEVWRUw6PUlORk99
+  NUMBER_LIST: !encrypt WzEsIDIsIDNd
+darwin:
+  <<: *all
+  ROOT: !encrypt JHtIT01FfS9MaWJyYXJ5L0FwcGxpY2F0aW9uIFN1cHBvcnQvcGlwZQ==
+linux:
+  <<: *all
+  ROOT: !encrypt JHtIT01FfS8ubG9jYWwvcGlwZQ==
+windows:
+  <<: *all
+  ROOT: !encrypt QzovUHJvZ3JhbURhdGEvcGlwZQ==
+"""
+        output = subprocess.check_output(
+            command,
+            shell=True,
+            universal_newlines=True,
+        )
+        self.assertEqual(output, expected_output)
+
+    def test_blank(self):
+        """Tests baking a blank stack."""
+        command = (
+            f"%s doesnotexist -o {self.filename}; cat {self.filename}"
+            % self.envstack_bin
+        )
+        expected_output = """#!/usr/bin/env envstack
+include: []
+all: &all
+  <<: *all
+darwin:
+  <<: *all
+linux:
+  <<: *all
+windows:
+  <<: *all
+"""
+        output = subprocess.check_output(
+            command,
+            shell=True,
+            universal_newlines=True,
+        )
+        self.assertEqual(output, expected_output)
+
+
 class TestCommands(unittest.TestCase):
     """Tests various envstack commands."""