view test/test_cmdexpand.py @ 310:26c15a0f0e52

When stopping because of an error, do not raise the exception again as it leads to confusing double tracebacks in the log. Instead, simply log the reason for the stopping and stop in the same way a stop instruction is handled.
author Bernhard Herzog <bh@intevation.de>
date Wed, 02 Dec 2009 14:46:37 +0000
parents a2ce575ce82b
children
line wrap: on
line source
# Copyright (C) 2007 by Intevation GmbH
# Authors:
# Bernhard Herzog <bh@intevation.de>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Tests for the cmdexpand function"""

import unittest

from treepkg.cmdexpand import cmdexpand


class TestCMDExpand(unittest.TestCase):

    def test_words(self):
        """Test cmdexpand with simple whitespace separated words"""
        self.assertEquals(cmdexpand("abc defg xyz zy"),
                          ['abc', 'defg', 'xyz', 'zy'])

    def test_single_quoted(self):
        """Test cmdexpand with some single quoted words"""
        self.assertEquals(cmdexpand("abc 'defg xyz' zy"),
                          ['abc', 'defg xyz', 'zy'])

    def test_double_quoted(self):
        """Test cmdexpand with some double quoted words"""
        self.assertEquals(cmdexpand('abc "defg  xyz" zy'),
                          ['abc', 'defg  xyz', 'zy'])

    def test_word_expansion(self):
        """Test cmdexpand with simple word expansion"""
        self.assertEquals(cmdexpand('abc $foo ghi', foo="def"),
                          ['abc', 'def', 'ghi'])
        self.assertEquals(cmdexpand('abc $foo ghi $bar', foo="def", bar="X"),
                          ['abc', 'def', 'ghi', 'X'])

    def test_word_expansion_braced_name(self):
        """Test cmdexpand with word expansion using braced names"""
        self.assertEquals(cmdexpand('abc ${foo} x${foo}y ghi', foo="def"),
                          ['abc', 'def', 'xdefy', 'ghi'])

    def test_word_expansion_non_byte_string(self):
        """Test cmdexpand quoting of dollar signs"""
        self.assertEquals(cmdexpand('abc $foo $bar ghi', foo=123, bar=u"1 2 3"),
                          ['abc', '123', '1 2 3', 'ghi'])

    def test_word_expansion_non_identifier(self):
        """Test cmdexpand word expansion if dollar not followed by identifier"""
        # $ immediately followed by a non-identifier character
        self.assertRaises(ValueError, cmdexpand, 'abc $#foo bar', foo="def")

    def test_word_expansion_inside_words(self):
        """Test cmdexpand word expansions in parts of words"""
        self.assertEquals(cmdexpand("$foo x$bar y$baz.",
                                    foo="abc", bar="yz", baz="zx"),
                          ["abc", "xyz", "yzx."])
        self.assertEquals(cmdexpand("$foo x$bar-$baz.",
                                    foo="abc", bar="yz", baz="zx"),
                          ["abc", "xyz-zx."])

    def test_case_sensitivity(self):
        """Test case sensitivity of expansion keys"""
        self.assertEquals(cmdexpand('abc $foo $Foo $FOO',
                                    foo="def", Foo="DEF", FOO="Def"),
                          ['abc', 'def', 'DEF', 'Def'])

    def test_list_expansion(self):
        """Test cmdexpand with list expansion"""
        self.assertEquals(cmdexpand('abc @foo ghi', foo=["d", "e", "f"]),
                          ['abc', 'd', 'e', 'f', 'ghi'])

    def test_list_expansion_non_string(self):
        """Test cmdexpand with list expansion"""
        self.assertEquals(cmdexpand('abc @foo ghi', foo=[1, 1.0, None]),
                          ['abc', '1', '1.0', 'None', 'ghi'])

    def test_list_expansion_with_iterators(self):
        """Test cmdexpand with list expansion using an iterator"""
        self.assertEquals(cmdexpand('abc @foo ghi',
                                    foo=(i**2 for i in range(3))),
                          ['abc', '0', '1', '4', 'ghi'])

    def test_list_expansion_non_identifier(self):
        """Test cmdexpand with at-sign not followed by identifier"""
        # @+identifier do not cover entire word
        self.assertRaises(ValueError, cmdexpand, 'abc @foo, ghi',
                          foo=["d", "e", "f"])

        # @ immediately followed by a non-identifier character
        self.assertRaises(ValueError, cmdexpand, 'abc @. z')

    def test_list_expansion_inside_word(self):
        """Test whether cmdexpand raises ValueError for at-signs inside words"""
        self.assertRaises(ValueError, cmdexpand, 'abc x@foo ghi',
                          foo=["d", "e", "f"])


    def test_dollar_quoting(self):
        """Test cmdexpand quoting of dollar signs"""
        self.assertEquals(cmdexpand('abc $$foo $foo g$$hi', foo="def"),
                          ['abc', '$foo', 'def', 'g$hi'])

    def test_atsign_quoting(self):
        """Test cmdexpand quoting of at-signs"""
        self.assertEquals(cmdexpand('abc @foo $@foo g$@i', foo=["d", "e", "f"]),
                          ['abc', 'd', 'e', 'f', '@foo', 'g@i'])

    def test_interaction_with_shlex_quoting(self):
        """Test cmdexpand's interaction with shlex's quoting"""
        # Unlike unix-shells the expansion isn't influenced much by
        # shell quoting as supported by shlex.
        self.assertEquals(cmdexpand('abc "@foo" \'@foo\' ghi',
                                    foo=["d", "e", "f"]),
                          ['abc', 'd', 'e', 'f', 'd', 'e', 'f', 'ghi'])
        self.assertEquals(cmdexpand('abc "$foo" \'$foo\' ghi', foo="def"),
                          ['abc', 'def', 'def', 'ghi'])
        self.assertEquals(cmdexpand('abc " $foo" \'a $foo\' ghi', foo="def"),
                          ['abc', ' def', 'a def', 'ghi'])


if __name__ == "__main__":
    unittest.main()
This site is hosted by Intevation GmbH (Datenschutzerklärung und Impressum | Privacy Policy and Imprint)