Fix: Tests on Windows

pyhocon/converter.py

@@ -125,7 +125,7 @@ def to_hocon(cls, config, compact=False, indent=2, level=0):
             if '\n' in config and len(config) > 1:
                 lines = '"""{value}"""'.format(value=config)  # multilines
             else:
-                lines = '"{value}"'.format(value=cls.__escape_string(config))
+                lines = '"{value}"'.format(value=cls._escape_string(config))
         elif isinstance(config, ConfigValues):
             lines = ''.join(cls.to_hocon(o, compact, indent, level) for o in config.tokens)
         elif isinstance(config, ConfigSubstitution):
@@ -137,7 +137,7 @@ def to_hocon(cls, config, compact=False, indent=2, level=0):
             if '\n' in config.value and len(config.value) > 1:
                 lines = '"""{value}"""'.format(value=config.value)  # multilines
             else:
-                lines = '"{value}"'.format(value=cls.__escape_string(config.value))
+                lines = '"{value}"'.format(value=cls._escape_string(config.value))
         elif cls._is_timedelta_like(config):
             lines += cls._timedelta_to_hocon(config)
         elif config is None or isinstance(config, NoneValue):
@@ -276,7 +276,7 @@ def convert_from_file(cls, input_file=None, output_file=None, output_format='jso
                 fd.write(res)
 
     @classmethod
-    def __escape_match(cls, match):
+    def _escape_match(cls, match):
         char = match.group(0)
         return {
             '\b': r'\b',
@@ -289,8 +289,8 @@ def __escape_match(cls, match):
         }.get(char) or (r'\u%04x' % ord(char))
 
     @classmethod
-    def __escape_string(cls, string):
-        return re.sub(r'[\x00-\x1F"\\]', cls.__escape_match, string)
+    def _escape_string(cls, string):
+        return re.sub(r'[\x00-\x1F"\\]', cls._escape_match, string)
 
     @classmethod
     def _is_timedelta_like(cls, config):

tests/test_config_parser.py

@@ -7,10 +7,17 @@
 from collections import OrderedDict
 from datetime import timedelta
 
+try:
+    # Python 3
+    from urllib.request import pathname2url
+except ImportError:
+    # Python 2
+    from urllib import pathname2url
+
 from pyparsing import ParseBaseException, ParseException, ParseSyntaxException
 import mock
 import pytest
-from pyhocon import (ConfigFactory, ConfigParser, ConfigSubstitutionException, ConfigTree)
+from pyhocon import (ConfigFactory, ConfigParser, ConfigSubstitutionException, ConfigTree, HOCONConverter)
 from pyhocon.exceptions import (ConfigException, ConfigMissingException,
                                 ConfigWrongTypeException)
 
@@ -1193,16 +1200,18 @@ def test_invalid_dict(self):
             ConfigFactory.parse_string('a = {g}')
 
     def test_include_file(self):
-        with tempfile.NamedTemporaryFile('w') as fdin:
+        with tempfile.NamedTemporaryFile('w', delete=False) as fdin:
             fdin.write('[1, 2]')
             fdin.flush()
+            incl_name = HOCONConverter._escape_string(fdin.name)
 
+        try:
             config1 = ConfigFactory.parse_string(
                 """
                 a: [
                     include "{tmp_file}"
                 ]
-                """.format(tmp_file=fdin.name)
+                """.format(tmp_file=incl_name)
             )
             assert config1['a'] == [1, 2]
 
@@ -1211,19 +1220,22 @@ def test_include_file(self):
                 a: [
                     include file("{tmp_file}")
                 ]
-                """.format(tmp_file=fdin.name)
+                """.format(tmp_file=incl_name)
             )
             assert config2['a'] == [1, 2]
 
             config3 = ConfigFactory.parse_string(
                 """
                 a: [
-                    include url("file://{tmp_file}")
+                    include url("file:{tmp_file}")
                 ]
-                """.format(tmp_file=fdin.name)
+                """.format(tmp_file=pathname2url(incl_name))
             )
             assert config3['a'] == [1, 2]
 
+        finally:
+            os.remove(incl_name)
+
     def test_include_missing_file(self):
         config1 = ConfigFactory.parse_string(
             """
@@ -1321,18 +1333,20 @@ def test_include_dict(self):
             'c': 3,
             'd': 4
         }
-        with tempfile.NamedTemporaryFile('w') as fdin:
+        with tempfile.NamedTemporaryFile('w', delete=False) as fdin:
             fdin.write('{a: 1, b: 2}')
             fdin.flush()
+            incl_name = HOCONConverter._escape_string(fdin.name)
 
+        try:
             config1 = ConfigFactory.parse_string(
                 """
                 a: {{
                     include "{tmp_file}"
                     c: 3
                     d: 4
                 }}
-                """.format(tmp_file=fdin.name)
+                """.format(tmp_file=incl_name)
             )
             assert config1['a'] == expected_res
 
@@ -1343,7 +1357,7 @@ def test_include_dict(self):
                     d: 4
                     include "{tmp_file}"
                 }}
-                """.format(tmp_file=fdin.name)
+                """.format(tmp_file=incl_name)
             )
             assert config2['a'] == expected_res
 
@@ -1354,41 +1368,54 @@ def test_include_dict(self):
                     include "{tmp_file}"
                     d: 4
                 }}
-                """.format(tmp_file=fdin.name)
+                """.format(tmp_file=incl_name)
             )
             assert config3['a'] == expected_res
+
+        finally:
+            os.remove(incl_name)
 
     def test_include_substitution(self):
-        with tempfile.NamedTemporaryFile('w') as fdin:
+        with tempfile.NamedTemporaryFile('w', delete=False) as fdin:
             fdin.write('y = ${x}')
             fdin.flush()
+            incl_name = HOCONConverter._escape_string(fdin.name)
 
+        try:
             config = ConfigFactory.parse_string(
                 """
                 include "{tmp_file}"
                 x = 42
-                """.format(tmp_file=fdin.name)
+                """.format(tmp_file=incl_name)
             )
             assert config['x'] == 42
             assert config['y'] == 42
 
+        finally:
+            os.remove(incl_name)
+
     @pytest.mark.xfail
     def test_include_substitution2(self):
-        with tempfile.NamedTemporaryFile('w') as fdin:
+        with tempfile.NamedTemporaryFile('w', delete=False) as fdin:
             fdin.write('{ x : 10, y : ${x} }')
             fdin.flush()
+            incl_name = HOCONConverter._escape_string(fdin.name)
 
+        try:
             config = ConfigFactory.parse_string(
                 """
                 {
-                    a : { include """ + '"' + fdin.name + """" }
+                    a : { include """ + '"' + incl_name + """" }
                     a : { x : 42 }
                 }
                 """
             )
             assert config['a']['x'] == 42
             assert config['a']['y'] == 42
 
+        finally:
+            os.remove(incl_name)
+
     def test_var_with_include_keyword(self):
         config = ConfigFactory.parse_string(
             """

tests/test_tool.py

@@ -1,3 +1,4 @@
+import os
 import tempfile
 import pytest
 from pyhocon import ConfigFactory
@@ -151,16 +152,26 @@ def test_to_compact_hocon(self):
             == [line.strip() for line in converted.split('\n') if line.strip()]
 
     def _test_convert_from_file(self, input, expected_output, format):
-        with tempfile.NamedTemporaryFile('w') as fdin:
-            fdin.write(input)
+        with tempfile.NamedTemporaryFile('wb', delete=False) as fdin:
+            fdin.write(input.encode())
             fdin.flush()
-            with tempfile.NamedTemporaryFile('r') as fdout:
+
+        try:
+            with tempfile.NamedTemporaryFile('w', delete=False) as fdout:
+                pass
+
+            try:
                 HOCONConverter.convert_from_file(fdin.name, fdout.name, format)
                 with open(fdout.name) as fdi:
                     converted = fdi.read()
                     assert [line.strip() for line in expected_output.split('\n') if line.strip()]\
                         == [line.strip() for line in converted.split('\n') if line.strip()]
 
+            finally:
+                os.remove(fdout.name)
+        finally:
+            os.remove(fdin.name)
+
     def test_convert_from_file(self):
         self._test_convert_from_file(TestHOCONConverter.CONFIG_STRING, TestHOCONConverter.EXPECTED_JSON, 'json')
         self._test_convert_from_file(TestHOCONConverter.CONFIG_STRING, TestHOCONConverter.EXPECTED_YAML, 'yaml')