cli.run() - Code Metrics - Inspection of "1a8628e4b9950a94c7da54f4c517fe219c181c4b" - shalomb/inji - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — develop (1a8628)

by Shalom

created 2020-08-16 22:33 UTC

cli.run() A

↳ Parent: cli

Complexity

Conditions

Size

Total Lines	8
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	7
nop	3
dl	0
loc	8
rs	10
c	0
b	0
f	0

#!/usr/bin/python3

# -*- coding: utf-8 -*-

import atexit
import json
import os
from   os.path import abspath, dirname, join
import pytest
import re
import shutil
import subprocess
import sys
import tempfile
import unittest

sys.path.insert(0, join(dirname(abspath(__file__)), '../..'))
sys.path.insert(0, join(dirname(abspath(__file__)), '../../inji'))

import inji
inji = abspath(join(sys.path[0], 'inji'))

def run(cmd, *args, **kwargs):
  os.environ['PYTHONUNBUFFERED'] = "1"
  proc = subprocess.Popen( [cmd, *args],
    stdout = subprocess.PIPE,
    stderr = subprocess.PIPE,
  )
  stdout, stderr = proc.communicate(**kwargs)
  return proc.returncode, stdout.decode('utf-8'), stderr.decode('utf-8')

def check_output(*args, **kwargs):
  return subprocess.check_output( [*args], **kwargs ).decode('utf-8')

def file_from_text(*args, **kwargs):
  """ Write args to a tempfile and return the filename """

  fqdir=kwargs.get('dir', tempfile.tempdir)

  if kwargs.get('name') is None:
    _, filename = tempfile.mkstemp( text=True, dir=fqdir)
  else:
    filename = join(fqdir, kwargs.get('name'))

  atexit.register(os.remove, filename)
  with open(filename, "a+") as f:
    f.write('\n'.join(args))

  return abspath(filename)

class TestFixtureHelloWorld(unittest.TestCase):

  def test_hello_world(self):
    code, out, err = run('/bin/echo', 'hello', 'world')
    assert 'hello' in out
    assert 'world' in out
    assert '' in err
    assert code == 0

  def test_check_output(self):
    out = check_output( 'sed', 's/foo/bar/', input=b'foo' )
    assert "bar" in out

class TestInjiCmd(unittest.TestCase):

  def test_help(self):
    """Test help message is emitted"""
    code, out, err = run(inji, '-h')
    assert code == 0
    assert 'usage:' in out
    assert '' == err

  def test_stdin(self):
    """Templates should be read in from STDIN (-) by default"""
    assert "Hola world!\n" == \
      check_output( inji,
                    input=b"{% set foo='world!' %}Hola {{ foo }}"
      )

  def test_stdin_empty_input(self):
    """Empty template string should return a newline"""
    assert '\n' == check_output( inji, input=b"" )

  def test_json_config_args(self):
    """Config passed as JSON string"""
    assert "Hola world!\n" == \
      check_output(
        inji, '-j', '{"foo": "world!"}',
          input=b"Hola {{ foo }}"
      )

  def test_invalid_json_config_args(self):
    """Empty json config args should cause an error"""
    class InvalidJSONConfigException(Exception): pass
    input_cases = [ '', '}{', '{@}', '{"foo": tru}' ] # invalid JSON inputs
    for cfg in input_cases:
      with pytest.raises(InvalidJSONConfigException) as e_info:
        try:
          check_output( inji, '-j', cfg,
                        stderr=subprocess.STDOUT,
          )
        except subprocess.CalledProcessError as exc:
          msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
          raise InvalidJSONConfigException(msg) from exc
      e = str(e_info)
      assert re.search("Error parsing JSON config:", e)
      assert "exit_code:2 " in e

  def test_kv_config_args(self):
    """ Config passed as KV strings """
    assert check_output(
        inji,
          '-k', 'foo=bar',
          '-k', 'foo=world!',  # valid, last declaration wins
          input=b"Hola {{ foo }}"
      ) == "Hola world!\n"
    assert check_output(
        inji, '-k', 'foo=',    # valid, sets foo to be empty
          input=b"Hola {{ foo }}"
      ) ==  "Hola \n"

  def test_invalid_kv_config_args(self):
    """Invalid KV config args should cause an error"""
    class InvalidKVConfigException(Exception): pass
    input_cases = [ '', '=', '=baz' ] # invalid KV inputs
    for cfg in input_cases:
      with pytest.raises(InvalidKVConfigException) as e_info:
        try:
          check_output( inji, '-d', cfg,
                        stderr=subprocess.STDOUT,
          )
        except subprocess.CalledProcessError as exc:
          msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
          raise InvalidKVConfigException(msg) from exc
      e = str(e_info)
      assert re.search("Invalid key found parsing", e)
      assert "exit_code:2 " in e

  def test_12factor_config_sourcing(self):
    """Test config sourcing precendence should adhere to 12-factor app expectations"""
    tmpdir = tempfile.mkdtemp(prefix='param-')
    atexit.register(shutil.rmtree, tmpdir)

    for item in ['dev', 'prod', 'stage']:
      cdir = os.path.join(tmpdir, item)
      os.mkdir(cdir)
      for file in 'a.yml', 'b.yaml', 'c.yaml':
        fqn = os.path.join(cdir, file)
        file_from_text(f"zoo: {file}\nitem: {item}", dir=cdir, name=fqn)

    cfg_file = file_from_text(
        f"zar: bella\nzoo: cfg",
        dir=tmpdir, name='inji.yml' )

    param_file = file_from_text(
        f"zar: zella\nzoo: zorg",
        dir=tmpdir, name='vars.yaml' )

    # needed to source lowest precedence config from ./inji.y?ml
    OLDPWD=os.getcwd()
    os.chdir(tmpdir)

    # test we are able to recursively source params
    # but also source from the p5 config file relative to PWD
    assert re.search('Hola \w+ from bella',
      check_output(
        inji,
          '-o', f"{tmpdir}/dev",
          input=b"Hola {{ item }} from {{ zar }}"
      )
    )

    # dev/c.yaml should be last file sourced
    assert "Hola c.yaml\n" == \
      check_output(
        inji, '-o', f"{tmpdir}/dev",
          input=b"Hola {{ zoo }}"
      )

    # prod/ should be the last overlay sourced
    assert "Hola prod\n" == \
      check_output(
        inji,
          '-o', f"{tmpdir}/stage",
          '-o', f"{tmpdir}/dev",
          '-o', f"{tmpdir}/prod",
          input=b"Hola {{ item }}"
      )

    # precedence 4
    # named config file trumps overlays, arg position is irrelevant
    assert "Hola zella from zorg\n" == \
      check_output(
        inji,
          '-o', f"{tmpdir}/stage",
          '-o', f"{tmpdir}/prod",
          '-v', param_file,
          '-o', f"{tmpdir}/dev",
          input=b"Hola {{ zar }} from {{ zoo }}"
      )

    # precedence 3
    # env vars trump named config files
    os.environ['zoo']='env'
    assert "Hola zella from env\n" == \
      check_output(
        inji,
          '-o', f"{tmpdir}/stage",
          '-o', f"{tmpdir}/prod",
          '-v', param_file,
          '-o', f"{tmpdir}/dev",
          input=b"Hola {{ zar }} from {{ zoo }}"
      )

    # precedence 2
    # cli params passed in as JSON take ultimate precendence
    assert "Hola zella from world!\n" == \
      check_output(
        inji,
          '-o', f"{tmpdir}/stage",
          '-c', '{"zoo": "world!"}',
          '-o', f"{tmpdir}/prod",
          '-v', param_file,
          '-o', f"{tmpdir}/dev",
          input=b"Hola {{ zar }} from {{ zoo }}"
      )

    # precedence 1
    # except when params are defined in the templates themselves, off course!
    assert "Hola quux from mars\n" == \
      check_output(
        inji,
          '-o', f"{tmpdir}/stage",
          '-c', '{"zoo": "mars"}',
          '-o', f"{tmpdir}/prod",
          '-v', param_file,
          '-o', f"{tmpdir}/dev",
          input=b"{% set zar='quux' %}Hola {{ zar }} from {{ zoo }}"
      )

    os.environ.pop('zoo')
    os.chdir(OLDPWD)

  def test_strict_undefined_var(self):
    """Undefined variables should cause a failure"""
    class BarUndefinedException(Exception): pass
    with pytest.raises(BarUndefinedException) as e_info:
      try:
        check_output( inji,
                      input=b"{% set foo='world!' %}Hola {{ bar }}",
                      stderr=subprocess.STDOUT,
        )
      except subprocess.CalledProcessError as exc:
        msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
        raise BarUndefinedException(msg) from exc
    e = str(e_info)
    assert "exit_code:1 " in e
    assert re.search('jinja2.exceptions.UndefinedError.+bar.+is undefined', e)

  def test_keep_undefined_var(self):
    """Undefined variables in keep mode should be kept"""
    assert '[Hola {{ foo }}]\n' == \
      check_output( inji, '-s', 'keep',
                      input=b"[Hola {{ foo }}]"
      )

  def test_empty_undefined_var(self):
    """Undefined variables in empty mode should leave spaces behind placeholders"""
    assert '[Hola ]\n' == \
      check_output( inji, '-s', 'empty',
                      input=b"[Hola {{ foo }}]"
      )

  def test_template_render_with_envvars(self):
    """Environment variables should be referenceable as parameters"""
    template = file_from_text("Hola {{ foo }}")
    os.environ['foo'] = 'world!'
    assert 'Hola world!\n' == \
      check_output( inji, '-t', template )
    os.environ.pop('foo')

  def test_template_render_with_internal_vars(self):
    """
    Jinja template should render correctly
    referencing those variables set in the templates themselves
    """
    template = file_from_text("{% set foo='world!' %}Hola {{ foo }}")
    assert 'Hola world!\n' == \
      check_output( inji, '-t', template )

  def test_template_missing(self):
    """ Missing template files should cause an error"""
    class TemplateFileMissingException(Exception): pass
    with pytest.raises(TemplateFileMissingException) as e_info:
      try:
        check_output( inji, '-t', 'nonexistent-template.j2',
                      stderr=subprocess.STDOUT,
        )
      except subprocess.CalledProcessError as exc:
        msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
        raise TemplateFileMissingException(msg) from exc
    e = str(e_info)
    assert "exit_code:2 " in e
    assert re.search('nonexistent-template.j2.. does not exist', e)

  def test_template_directory(self):
    """ Using a directory as a template source should cause an error"""
    class TemplateAsDirectoryException(Exception): pass
    with pytest.raises(TemplateAsDirectoryException) as e_info:
      try:
        check_output( inji, '-t', '/',
                      stderr=subprocess.STDOUT,
        )
      except subprocess.CalledProcessError as exc:
        msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
        raise TemplateAsDirectoryException(msg) from exc
    e = str(e_info)
    assert "exit_code:2 " in e
    assert re.search('/.. is not a file', e)

  def test_template_render_with_varsfile(self):
    """Params from params files should be rendered on the template output"""
    template = file_from_text("Hola {{ foo }}")
    varsfile = file_from_text("foo: world!")
    assert 'Hola world!\n' == \
      check_output( inji, '-t', template, '-v', varsfile )

  def test_template_render_with_multiple_varsfiles(self):
    """Params from multiple files should be merged before rendering"""
    template = file_from_text("Hola {{ foo }}, Hello {{ bar }}, t{{ t }}")
    varsfile1 = file_from_text("foo: world!\nt: quux")
    varsfile2 = file_from_text("bar: metaverse\nt: moocow")
    assert 'Hola world!, Hello metaverse, tmoocow\n' == \
      check_output(
          inji, '-t', template,
                '-v', varsfile1,
                '-v', varsfile2
      )

  def test_error_with_empty_varsfile(self):
    """ An empty vars file is an error, we ought to fail early """
    """
    There may be a case for allowing this to just be a warning and so
    we may change this behaviour in the future. For now, it definitely
    is something we should fail-early on.
    """
    class EmptyVarsFileException(Exception): pass
    with pytest.raises(EmptyVarsFileException) as e_info:
      try:
        template = file_from_text("Hola {{ foo }}, Hello {{ bar }}")
        varsfile = file_from_text('')
        check_output( inji, '-t', template, '-v', varsfile,
                      stderr=subprocess.STDOUT,
        )
      except subprocess.CalledProcessError as exc:
        msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
        raise EmptyVarsFileException(msg) from exc
    e = str(e_info)
    assert re.search('TypeError: .* contains no data', e)
    assert "exit_code:1 " in e

  def test_error_with_malformed_varsfile(self):
    """ An invalid varsfile is a fail-early error """
    class MalformedVarsFileException(Exception): pass
    with pytest.raises(MalformedVarsFileException) as e_info:
      try:
        varsfile = file_from_text('@')
        check_output( inji, '-v', varsfile,
                      input=b"Hola {{ foo }}, Hello {{ bar }}",
                      stderr=subprocess.STDOUT
        )
      except subprocess.CalledProcessError as exc:
        msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
        raise MalformedVarsFileException(msg) from exc
    e = str(e_info)
    assert re.search('cannot start any token', e)
    assert "exit_code:1 " in e

if __name__ == '__main__':
  TestInjiCmd().test_empty_json_config_args()



1		#!/usr/bin/python3
2
3		# -- coding: utf-8 --
4
5		import atexit
6		import json
7		import os
8		from os.path import abspath, dirname, join
9		import pytest
10		import re
11		import shutil
12		import subprocess
13		import sys
14		import tempfile
15		import unittest
16
17		sys.path.insert(0, join(dirname(abspath(__file__)), '../..'))
18		sys.path.insert(0, join(dirname(abspath(__file__)), '../../inji'))
19
20		import inji
21		inji = abspath(join(sys.path[0], 'inji'))
22
23		def run(cmd, args, *kwargs):
24		os.environ['PYTHONUNBUFFERED'] = "1"
25		proc = subprocess.Popen( [cmd, *args],
26		stdout = subprocess.PIPE,
27		stderr = subprocess.PIPE,
28		)
29		stdout, stderr = proc.communicate(**kwargs)
30		return proc.returncode, stdout.decode('utf-8'), stderr.decode('utf-8')
31
32		def check_output(args, *kwargs):
33		return subprocess.check_output( [args], *kwargs ).decode('utf-8')
34
35		def file_from_text(args, *kwargs):
36		""" Write args to a tempfile and return the filename """
37
38		fqdir=kwargs.get('dir', tempfile.tempdir)
39
40		if kwargs.get('name') is None:
41		_, filename = tempfile.mkstemp( text=True, dir=fqdir)
42		else:
43		filename = join(fqdir, kwargs.get('name'))
44
45		atexit.register(os.remove, filename)
46		with open(filename, "a+") as f:
47		f.write('\n'.join(args))
48
49		return abspath(filename)
50
51		class TestFixtureHelloWorld(unittest.TestCase):
52
53		def test_hello_world(self):
54		code, out, err = run('/bin/echo', 'hello', 'world')
55		assert 'hello' in out
56		assert 'world' in out
57		assert '' in err
58		assert code == 0
59
60		def test_check_output(self):
61		out = check_output( 'sed', 's/foo/bar/', input=b'foo' )
62		assert "bar" in out
63
64		class TestInjiCmd(unittest.TestCase):
65
66		def test_help(self):
67		"""Test help message is emitted"""
68		code, out, err = run(inji, '-h')
69		assert code == 0
70		assert 'usage:' in out
71		assert '' == err
72
73		def test_stdin(self):
74		"""Templates should be read in from STDIN (-) by default"""
75		assert "Hola world!\n" == \
76		check_output( inji,
77		input=b"{% set foo='world!' %}Hola {{ foo }}"
78		)
79
80		def test_stdin_empty_input(self):
81		"""Empty template string should return a newline"""
82		assert '\n' == check_output( inji, input=b"" )
83
84		def test_json_config_args(self):
85		"""Config passed as JSON string"""
86		assert "Hola world!\n" == \
87		check_output(
88		inji, '-j', '{"foo": "world!"}',
89		input=b"Hola {{ foo }}"
90		)
91
92	View Code Duplication	def test_invalid_json_config_args(self):
93		"""Empty json config args should cause an error"""
94		class InvalidJSONConfigException(Exception): pass
95		input_cases = [ '', '}{', '{@}', '{"foo": tru}' ] # invalid JSON inputs
96		for cfg in input_cases:
97		with pytest.raises(InvalidJSONConfigException) as e_info:
98		try:
99		check_output( inji, '-j', cfg,
100		stderr=subprocess.STDOUT,
101		)
102		except subprocess.CalledProcessError as exc:
103		msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
104		raise InvalidJSONConfigException(msg) from exc
105		e = str(e_info)
106		assert re.search("Error parsing JSON config:", e)
107		assert "exit_code:2 " in e
108
109		def test_kv_config_args(self):
110		""" Config passed as KV strings """
111		assert check_output(
112		inji,
113		'-k', 'foo=bar',
114		'-k', 'foo=world!', # valid, last declaration wins
115		input=b"Hola {{ foo }}"
116		) == "Hola world!\n"
117		assert check_output(
118		inji, '-k', 'foo=', # valid, sets foo to be empty
119		input=b"Hola {{ foo }}"
120		) == "Hola \n"
121
122	View Code Duplication	def test_invalid_kv_config_args(self):
123		"""Invalid KV config args should cause an error"""
124		class InvalidKVConfigException(Exception): pass
125		input_cases = [ '', '=', '=baz' ] # invalid KV inputs
126		for cfg in input_cases:
127		with pytest.raises(InvalidKVConfigException) as e_info:
128		try:
129		check_output( inji, '-d', cfg,
130		stderr=subprocess.STDOUT,
131		)
132		except subprocess.CalledProcessError as exc:
133		msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
134		raise InvalidKVConfigException(msg) from exc
135		e = str(e_info)
136		assert re.search("Invalid key found parsing", e)
137		assert "exit_code:2 " in e
138
139		def test_12factor_config_sourcing(self):
140		"""Test config sourcing precendence should adhere to 12-factor app expectations"""
141		tmpdir = tempfile.mkdtemp(prefix='param-')
142		atexit.register(shutil.rmtree, tmpdir)
143
144		for item in ['dev', 'prod', 'stage']:
145		cdir = os.path.join(tmpdir, item)
146		os.mkdir(cdir)
147		for file in 'a.yml', 'b.yaml', 'c.yaml':
148		fqn = os.path.join(cdir, file)
149		file_from_text(f"zoo: {file}\nitem: {item}", dir=cdir, name=fqn)
150
151		cfg_file = file_from_text(
152		f"zar: bella\nzoo: cfg",
153		dir=tmpdir, name='inji.yml' )
154
155		param_file = file_from_text(
156		f"zar: zella\nzoo: zorg",
157		dir=tmpdir, name='vars.yaml' )
158
159		# needed to source lowest precedence config from ./inji.y?ml
160		OLDPWD=os.getcwd()
161		os.chdir(tmpdir)
162
163		# test we are able to recursively source params
164		# but also source from the p5 config file relative to PWD
165		assert re.search('Hola \w+ from bella',
166		check_output(
167		inji,
168		'-o', f"{tmpdir}/dev",
169		input=b"Hola {{ item }} from {{ zar }}"
170		)
171		)
172
173		# dev/c.yaml should be last file sourced
174		assert "Hola c.yaml\n" == \
175		check_output(
176		inji, '-o', f"{tmpdir}/dev",
177		input=b"Hola {{ zoo }}"
178		)
179
180		# prod/ should be the last overlay sourced
181		assert "Hola prod\n" == \
182		check_output(
183		inji,
184		'-o', f"{tmpdir}/stage",
185		'-o', f"{tmpdir}/dev",
186		'-o', f"{tmpdir}/prod",
187		input=b"Hola {{ item }}"
188		)
189
190		# precedence 4
191		# named config file trumps overlays, arg position is irrelevant
192		assert "Hola zella from zorg\n" == \
193		check_output(
194		inji,
195		'-o', f"{tmpdir}/stage",
196		'-o', f"{tmpdir}/prod",
197		'-v', param_file,
198		'-o', f"{tmpdir}/dev",
199		input=b"Hola {{ zar }} from {{ zoo }}"
200		)
201
202		# precedence 3
203		# env vars trump named config files
204		os.environ['zoo']='env'
205		assert "Hola zella from env\n" == \
206		check_output(
207		inji,
208		'-o', f"{tmpdir}/stage",
209		'-o', f"{tmpdir}/prod",
210		'-v', param_file,
211		'-o', f"{tmpdir}/dev",
212		input=b"Hola {{ zar }} from {{ zoo }}"
213		)
214
215		# precedence 2
216		# cli params passed in as JSON take ultimate precendence
217		assert "Hola zella from world!\n" == \
218		check_output(
219		inji,
220		'-o', f"{tmpdir}/stage",
221		'-c', '{"zoo": "world!"}',
222		'-o', f"{tmpdir}/prod",
223		'-v', param_file,
224		'-o', f"{tmpdir}/dev",
225		input=b"Hola {{ zar }} from {{ zoo }}"
226		)
227
228		# precedence 1
229		# except when params are defined in the templates themselves, off course!
230		assert "Hola quux from mars\n" == \
231		check_output(
232		inji,
233		'-o', f"{tmpdir}/stage",
234		'-c', '{"zoo": "mars"}',
235		'-o', f"{tmpdir}/prod",
236		'-v', param_file,
237		'-o', f"{tmpdir}/dev",
238		input=b"{% set zar='quux' %}Hola {{ zar }} from {{ zoo }}"
239		)
240
241		os.environ.pop('zoo')
242		os.chdir(OLDPWD)
243
244		def test_strict_undefined_var(self):
245		"""Undefined variables should cause a failure"""
246		class BarUndefinedException(Exception): pass
247		with pytest.raises(BarUndefinedException) as e_info:
248		try:
249		check_output( inji,
250		input=b"{% set foo='world!' %}Hola {{ bar }}",
251		stderr=subprocess.STDOUT,
252		)
253		except subprocess.CalledProcessError as exc:
254		msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
255		raise BarUndefinedException(msg) from exc
256		e = str(e_info)
257		assert "exit_code:1 " in e
258		assert re.search('jinja2.exceptions.UndefinedError.+bar.+is undefined', e)
259
260		def test_keep_undefined_var(self):
261		"""Undefined variables in keep mode should be kept"""
262		assert '[Hola {{ foo }}]\n' == \
263		check_output( inji, '-s', 'keep',
264		input=b"[Hola {{ foo }}]"
265		)
266
267		def test_empty_undefined_var(self):
268		"""Undefined variables in empty mode should leave spaces behind placeholders"""
269		assert '[Hola ]\n' == \
270		check_output( inji, '-s', 'empty',
271		input=b"[Hola {{ foo }}]"
272		)
273
274		def test_template_render_with_envvars(self):
275		"""Environment variables should be referenceable as parameters"""
276		template = file_from_text("Hola {{ foo }}")
277		os.environ['foo'] = 'world!'
278		assert 'Hola world!\n' == \
279		check_output( inji, '-t', template )
280		os.environ.pop('foo')
281
282		def test_template_render_with_internal_vars(self):
283		"""
284		Jinja template should render correctly
285		referencing those variables set in the templates themselves
286		"""
287		template = file_from_text("{% set foo='world!' %}Hola {{ foo }}")
288		assert 'Hola world!\n' == \
289		check_output( inji, '-t', template )
290
291		def test_template_missing(self):
292		""" Missing template files should cause an error"""
293		class TemplateFileMissingException(Exception): pass
294		with pytest.raises(TemplateFileMissingException) as e_info:
295		try:
296		check_output( inji, '-t', 'nonexistent-template.j2',
297		stderr=subprocess.STDOUT,
298		)
299		except subprocess.CalledProcessError as exc:
300		msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
301		raise TemplateFileMissingException(msg) from exc
302		e = str(e_info)
303		assert "exit_code:2 " in e
304		assert re.search('nonexistent-template.j2.. does not exist', e)
305
306		def test_template_directory(self):
307		""" Using a directory as a template source should cause an error"""
308		class TemplateAsDirectoryException(Exception): pass
309		with pytest.raises(TemplateAsDirectoryException) as e_info:
310		try:
311		check_output( inji, '-t', '/',
312		stderr=subprocess.STDOUT,
313		)
314		except subprocess.CalledProcessError as exc:
315		msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
316		raise TemplateAsDirectoryException(msg) from exc
317		e = str(e_info)
318		assert "exit_code:2 " in e
319		assert re.search('/.. is not a file', e)
320
321		def test_template_render_with_varsfile(self):
322		"""Params from params files should be rendered on the template output"""
323		template = file_from_text("Hola {{ foo }}")
324		varsfile = file_from_text("foo: world!")
325		assert 'Hola world!\n' == \
326		check_output( inji, '-t', template, '-v', varsfile )
327
328		def test_template_render_with_multiple_varsfiles(self):
329		"""Params from multiple files should be merged before rendering"""
330		template = file_from_text("Hola {{ foo }}, Hello {{ bar }}, t{{ t }}")
331		varsfile1 = file_from_text("foo: world!\nt: quux")
332		varsfile2 = file_from_text("bar: metaverse\nt: moocow")
333		assert 'Hola world!, Hello metaverse, tmoocow\n' == \
334		check_output(
335		inji, '-t', template,
336		'-v', varsfile1,
337		'-v', varsfile2
338		)
339
340		def test_error_with_empty_varsfile(self):
341		""" An empty vars file is an error, we ought to fail early """
342		"""
343		There may be a case for allowing this to just be a warning and so
344		we may change this behaviour in the future. For now, it definitely
345		is something we should fail-early on.
346		"""
347		class EmptyVarsFileException(Exception): pass
348		with pytest.raises(EmptyVarsFileException) as e_info:
349		try:
350		template = file_from_text("Hola {{ foo }}, Hello {{ bar }}")
351		varsfile = file_from_text('')
352		check_output( inji, '-t', template, '-v', varsfile,
353		stderr=subprocess.STDOUT,
354		)
355		except subprocess.CalledProcessError as exc:
356		msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
357		raise EmptyVarsFileException(msg) from exc
358		e = str(e_info)
359		assert re.search('TypeError: .* contains no data', e)
360		assert "exit_code:1 " in e
361
362		def test_error_with_malformed_varsfile(self):
363		""" An invalid varsfile is a fail-early error """
364		class MalformedVarsFileException(Exception): pass
365		with pytest.raises(MalformedVarsFileException) as e_info:
366		try:
367		varsfile = file_from_text('@')
368		check_output( inji, '-v', varsfile,
369		input=b"Hola {{ foo }}, Hello {{ bar }}",
370		stderr=subprocess.STDOUT
371		)
372		except subprocess.CalledProcessError as exc:
373		msg = 'exit_code:{} output:{}'.format(exc.returncode, exc.output)
374		raise MalformedVarsFileException(msg) from exc
375		e = str(e_info)
376		assert re.search('cannot start any token', e)
377		assert "exit_code:1 " in e
378
379		if __name__ == '__main__':
380		TestInjiCmd().test_empty_json_config_args()
381
382

shalomb / inji

Branch — develop (1a8628)

cli.run() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like