예제 #1
0
    def testFileDir(self):
        tmp = TempDir({
            'env.xml':
            '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:set variable="mydirs">${.}</env:set>
<env:set variable="myparent">${.}/..</env:set>
</env:config>'''
        })

        control = Control.Environment()
        control.loadXML(tmp('env.xml'))
        self.assertEqual(str(control['mydirs']), tmp())
        self.assertEqual(str(control['myparent']), os.path.dirname(tmp()))

        olddir = os.getcwd()
        os.chdir(tmp())
        try:
            control = Control.Environment()
            control.loadXML('env.xml')
            self.assertTrue(os.path.samefile(str(control['mydirs']), tmp()))
            self.assertTrue(
                os.path.samefile(str(control['myparent']),
                                 os.path.dirname(tmp())))
        finally:
            os.chdir(olddir)
예제 #2
0
    def testValues(self):
        '''Test of value appending, prepending, setting, unsetting, removing'''
        control = Control.Environment()

        self.assertFalse('MY_PATH' in control.vars())
        control.append('MY_PATH', 'newValue')
        self.assertTrue('MY_PATH' in control.vars())
        var = control.var('MY_PATH')

        control.append('MY_PATH', 'newValue:secondVal:valval')
        self.assertTrue(var[len(var) - 1] == 'valval')

        self.assertTrue('newValue' in var)
        control.remove('MY_PATH', 'newValue')
        self.assertFalse('newValue' in var)

        control.prepend('MY_PATH', 'newValue')
        self.assertTrue('newValue' == var[0])

        control.set('MY_PATH', 'hi:hello')
        self.assertTrue(len(var) == 2)
        self.assertTrue('hi' == var[0])

        control.unset('MY_PATH')
        self.assertTrue('MY_PATH' not in control)
예제 #3
0
    def testDelete(self):
        control = Control.Environment()

        control.append('MY_PATH', 'myVal:anotherVal:lastVal')
        control.remove('MY_PATH', 'anotherVal')

        self.assertFalse('anotherVal' in control['MY_PATH'])
        self.assertTrue('myVal' in control['MY_PATH'])
        self.assertTrue('lastVal' in control['MY_PATH'])

        control.set('MY_PATH', 'myVal:anotherVal:lastVal:else')
        control.remove('MY_PATH', '^anotherVal$', False)
        self.assertTrue('anotherVal' in control['MY_PATH'])
        control.remove('MY_PATH', '^anotherVal$', True)
        self.assertFalse('anotherVal' in control['MY_PATH'])
        self.assertTrue('myVal' in control['MY_PATH'])
        self.assertTrue('lastVal' in control['MY_PATH'])
        self.assertTrue('lastVal' in control['MY_PATH'])
        control.remove('MY_PATH', 'Val', True)
        self.assertTrue('else' in control['MY_PATH'])
        self.assertTrue(len(control['MY_PATH']) == 1)

        control.declare('myLoc', 'scalar', False)
        control.append('myLoc', 'myVal:anotherVal:lastVal')
        control.remove('myLoc', 'Val:', True)
        self.assertTrue(str(control['myLoc']) == 'myanotherlastVal')
예제 #4
0
    def testSearch(self):
        '''Testing searching in variables'''
        control = Control.Environment()

        control.append('MY_PATH', 'newValue:mess:something new:aaaabbcc')

        def count(val, regExp=False):
            return len(control.search('MY_PATH', val, regExp))

        self.assertEqual(count('new'), 0)
        self.assertEqual(count('newValue'), 1)

        self.assertEqual(count('me', False), 0)
        self.assertEqual(count('me', True), 2)

        self.assertEqual(count('cc', False), 0)
        self.assertEqual(count('cc', True), 1)

        self.assertEqual(count('a{2}b{2}c{2}', True), 1)
        self.assertEqual(count('a{2}b{2}', True), 1)
        self.assertEqual(count('a{1}b{2}c{2}', True), 1)
        self.assertEqual(count('a{1}b{1}c{2}', True), 0)
        self.assertEqual(count('a{1,2}b{1,2}c{2}', True), 1)
        self.assertEqual(count('a{2,3}', True), 1)
        self.assertEqual(count('a{2,3}?', True), 1)
예제 #5
0
    def testHidingDotVar(self):
        control = Control.Environment()
        control.variables['.'].set('some/dir')

        self.assertTrue('.' in control.variables)
        self.assertTrue('.' not in control.vars())
        self.assertTrue('.' not in control.vars(strings=False))

        control.set('MY_DIR', '${.}')
        self.assertEqual(control.var('MY_DIR').value(True), 'some/dir')
        self.assertEqual(control.vars()['MY_DIR'], 'some/dir')
예제 #6
0
    def testWriteWithList(self):
        """XML file write and load test"""
        control = Control.Environment(useAsWriter=True)
        control.unset('MY_PATH')
        control.set('MY_PATH', ['set', 'toDelete'])
        control.append('MY_PATH', ['appended', 'toDelete'])
        control.prepend('MY_PATH', ['prepended', 'toDelete'])
        control.remove('MY_PATH', ['toDelete'])
        control.finishXMLinput('testOutputFile.xml')

        control = Control.Environment()
        self.assertFalse('MY_PATH' in control.vars())
        control.loadXML('testOutputFile.xml')

        self.assertTrue('MY_PATH' in control.vars())
        var = control.var('MY_PATH')
        self.assertTrue(var[0] == 'prepended')
        self.assertTrue(var[1] == 'set')
        self.assertTrue(var[2] == 'appended')
        self.assertFalse('toDelete' in var)

        os.remove('testOutputFile.xml')
예제 #7
0
    def testVariables(self):
        '''Tests variables creation and redeclaration.'''
        control = Control.Environment()

        control.append('MY_PATH', 'newValue')
        self.assertFalse(control.var('MY_PATH').local)
        self.assertTrue(isinstance(control.var('MY_PATH'), Variable.List))

        control.declare('loc', 'list', True)
        self.assertTrue(control.var('loc').local)
        self.assertTrue(isinstance(control.var('loc'), Variable.List))

        control.declare('myVar2', 'scalar', False)
        self.assertFalse(control.var('myVar2').local)
        self.assertTrue(isinstance(control.var('myVar2'), Variable.Scalar))

        control.declare('loc2', 'scalar', True)
        self.assertTrue(control.var('loc2').local)
        self.assertTrue(isinstance(control.var('loc2'), Variable.Scalar))

        control.declare('MY_PATH', 'list', False)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'MY_PATH',
                              'list', True)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'MY_PATH',
                              'scalar', True)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'MY_PATH',
                              'scalar', True)

        control.declare('loc', 'list', True)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'loc',
                              'list', False)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'loc',
                              'scalar', True)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'loc',
                              'scalar', True)

        control.declare('myVar2', 'scalar', False)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'myVar2',
                              'list', False)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'myVar2',
                              'list', True)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'myVar2',
                              'scalar', True)

        control.declare('loc2', 'scalar', True)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'loc2',
                              'list', False)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'loc2',
                              'list', True)
        self.failUnlessRaises(Variable.EnvError, control.declare, 'loc2',
                              'scalar', False)
예제 #8
0
    def testDefaults(self):
        tmp = TempDir({
            'env.xml':
            '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:default variable="var1">value1</env:default>
<env:declare variable="var2" local="true" />
<env:default variable="var2">test2</env:default>
</env:config>'''
        })

        if 'var1' in os.environ:
            del os.environ['var1']
        control = Control.Environment()
        control.loadXML(tmp('env.xml'))
        self.assertEqual(str(control['var1']), "value1")
        self.assertEqual(str(control['var2']), "test2")

        os.environ['var1'] = "some_value"
        control = Control.Environment()
        control.loadXML(tmp('env.xml'))
        self.assertEqual(str(control['var1']), "some_value")
        self.assertEqual(str(control['var2']), "test2")
예제 #9
0
    def testSystemEnvironment(self):
        control = Control.Environment()

        os.environ['MY_PATH'] = '$myVal'
        os.environ['myScal'] = '$myVal'

        control.set('ABC', 'anyValue')
        control.declare('MY_PATH', 'list', False)
        control.append('MY_PATH', '$ABC')
        self.assertTrue(control['MY_PATH'].value(True) == '$myVal:anyValue')

        control.declare('myScal', 'scalar', False)
        control.append('myScal', '$ABC')
        self.assertTrue(control['myScal'].value(True) == '$myValanyValue')
예제 #10
0
    def testSaveToXML(self):
        """XML file write and load test"""
        control = Control.Environment()

        control.unset('MY_PATH')
        control.set('MY_PATH', 'set:toDelete')
        control.append('MY_PATH', 'appended:toDelete')
        control.prepend('MY_PATH', 'prepended:toDelete')
        control.remove('MY_PATH', 'toDelete')
        control.writeToXMLFile('testOutputFile.xml')

        control = Control.Environment()
        self.assertFalse('MY_PATH' in control.vars())
        control.loadXML('testOutputFile.xml')

        self.assertTrue('MY_PATH' in control.vars())
        var = control.var('MY_PATH')
        self.assertTrue(var[0] == 'prepended')
        self.assertTrue(var[1] == 'set')
        self.assertTrue(var[2] == 'appended')
        self.assertFalse('toDelete' in var)

        os.remove('testOutputFile.xml')
예제 #11
0
    def testSaveToFile(self):
        '''Test addition of variable to system'''
        control = Control.Environment()

        control.append('sysVar', 'newValue:lala')
        control.writeToFile('setupFile.txt')

        with open('setupFile.txt', "r") as f:
            f.readline()
            stri = f.readline()
        f.close()

        self.assertEqual(stri, 'export sysVar=newValue:lala' + os.linesep)

        os.remove('setupFile.txt')
예제 #12
0
    def testDependencies(self):
        control = Control.Environment()

        control.declare('myVar', 'list', False)

        control.declare('loc', 'list', True)
        control.append('loc', 'locVal')
        control.append('loc', 'locVal2')

        control.declare('scal', 'scalar', False)
        control.append('scal', 'scalVal')
        control.append('scal', 'scalVal2')

        control.declare('scal2', 'scalar', True)
        control.append('scal2', 'locScal')
        control.append('scal2', 'locScal2')

        control.set('myVar', 'newValue:$loc:endValue')
        self.assertEqual(str(control['myVar']),
                         'newValue:locVal:locVal2:endValue')

        control.set('myVar', 'newValue:$scal:endValue')
        self.assertEqual(str(control['myVar']),
                         'newValue:scalValscalVal2:endValue')

        control.set('myVar', 'new${scal}Value:endValue')
        self.assertEqual(str(control['myVar']),
                         'newscalValscalVal2Value:endValue')

        control.set('myVar', 'bla:$myVar:Value')
        self.assertEqual(str(control['myVar']),
                         'bla:newscalValscalVal2Value:endValue:Value')

        control.set('scal', 'new${scal2}Value')
        self.assertEqual(str(control['scal']), 'newlocScallocScal2Value')

        control.set('scal', 'new${loc}Value')
        self.assertEqual(str(control['scal']), 'newlocVal:locVal2Value')

        control.set('scal2', 'new${scal2}Value')
        self.assertEqual(str(control['scal2']), 'newlocScallocScal2Value')
예제 #13
0
파일: __init__.py 프로젝트: ocordes/arctic
    def _makeEnv(self):
        '''
        Generate a dictionary of the environment variables after applying all
        the required actions.
        '''
        # prepare the environment control instance
        control = Control.Environment()
        if not self.opts.ignore_environment:
            control.presetFromSystem()

        # apply all the actions
        for action, args in self.opts.actions:
            print(getattr(control, action), args)
            #apply(getattr(control, action), args)
            f = getattr(control, action)
            f(*args)
            #function(*args, **keywords) instead of apply(function, args, keywords)

        # extract the result env dictionary
        env = control.vars()

        # set the library search path correctly for the non-Linux platforms
        if "LD_LIBRARY_PATH" in env:
            # replace LD_LIBRARY_PATH with the corresponding one on other
            # systems
            if sys.platform.startswith("win"):
                other = "PATH"
            elif sys.platform.startswith("darwin"):
                other = "DYLD_LIBRARY_PATH"
            else:
                other = None
            if other:
                if other in env:
                    env[other] = env[other] + \
                        os.pathsep + env["LD_LIBRARY_PATH"]
                else:
                    env[other] = env["LD_LIBRARY_PATH"]
                del env["LD_LIBRARY_PATH"]

        self.env = env
예제 #14
0
    def testsVariablesInSearchPath(self):
        with TemporaryDir(chdir=True) as tmp:
            with open('EntryPoint.xenv', 'w') as f:
                f.write('''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">'
<env:default variable="INCLUDED_FILE_PATH">${.}/subdir</env:default>
<env:search_path>${INCLUDED_FILE_PATH}</env:search_path>
<env:include>Included.xenv</env:include>
</env:config>''')
            os.makedirs('subdir')
            with open('subdir/Included.xenv', 'w') as f:
                f.write('''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:set variable="INCLUDED_FILE">OK</env:set>
</env:config>''')

            control = Control.Environment(searchPath=[])
            control.loadXML('EntryPoint.xenv')

            self.assertEqual(str(control['INCLUDED_FILE_PATH']),
                             os.path.join(tmp, 'subdir'))
            self.assertEqual(str(control['INCLUDED_FILE']), 'OK')
예제 #15
0
    def testFileLoad(self):
        '''Test loading of previously written file.'''
        self.control = Control.Environment(useAsWriter = True)
        self.control.unset('varToUnset')

        self.control.declare('myVar', 'list', True)
        self.control.set('myVar', 'setVal:$local')
        self.control.append('myVar', 'appVal:appVal2')
        self.control.prepend('myVar', 'prepVal:prepVal2')

        self.control.declare('myScalar', 'scalar', False)
        self.control.set('myScalar', 'setValscal')
        self.control.append('myScalar', 'appValscal')
        self.control.prepend('myScalar', 'prepValscal')

        self.control.declare('myScalar2', 'scalar', True)

        self.control.finishXMLinput('testOutputFile.xml')

        loader = xmlModule.XMLFile()
        variables = loader.variable('testOutputFile.xml')

        expected = [('declare', ('varToUnset', 'list', 'false')),
                    ('unset', ('varToUnset', '', None)),
                    ('declare', ('myVar', 'list', 'true')),
                    ('set', ('myVar', 'setVal:$local', None)),
                    ('append', ('myVar', 'appVal:appVal2', None)),
                    ('prepend', ('myVar', 'prepVal:prepVal2', None)),
                    ('declare', ('myScalar', 'scalar', 'false')),
                    ('set', ('myScalar', 'setValscal', None)),
                    ('append', ('myScalar', 'appValscal', None)),
                    ('prepend', ('myScalar', 'prepValscal', None)),
                    ('declare', ('myScalar2', 'scalar', 'true'))]

        self.assertEqual(variables, expected)

        os.remove('testOutputFile.xml')
예제 #16
0
    def testInclude(self):
        tmp = TempDir({
            'first.xml': '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:set variable="main">first</env:set>
<env:append variable="test_path">data1</env:append>
<env:include>first_inc.xml</env:include>
</env:config>''',
            'second.xml': '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:set variable="main">second</env:set>
<env:include>second_inc.xml</env:include>
<env:append variable="test_path">data1</env:append>
</env:config>''',
            'third.xml': '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:set variable="main">third</env:set>
<env:append variable="test_path">data1</env:append>
<env:include>subdir/first_inc.xml</env:include>
</env:config>''',
            'fourth.xml': '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:set variable="main">fourth</env:set>
<env:include hints="subdir2">fourth_inc.xml</env:include>
</env:config>''',
            'recursion.xml': '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:set variable="main">recursion</env:set>
<env:include>recursion.xml</env:include>
</env:config>''',
            'first_inc.xml': '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:append variable="test_path">data2</env:append>
<env:append variable="derived">another_${main}</env:append>
</env:config>''',
            'subdir': {
                'second_inc.xml':
                '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:append variable="test_path">data0</env:append>
<env:set variable="map">this_is_second_inc</env:set>
</env:config>''',
                'first_inc.xml':
                '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:append variable="derived">second_${main}</env:append>
</env:config>''',
                'fourth_inc.xml':
                '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:append variable="included">from subdir</env:append>
</env:config>''',
            },
            'subdir2': {
                'fourth_inc.xml':
                '''<?xml version="1.0" ?>
<env:config xmlns:env="EnvSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="EnvSchema ./EnvSchema.xsd ">
<env:append variable="included">from subdir2</env:append>
</env:config>''',
            }
        })

        # set the basic search path to the minimal default
        if 'ENVXMLPATH' in os.environ:
            del os.environ['ENVXMLPATH']
        import EnvConfig  # @UnresolvedImport
        saved_path = list(EnvConfig.path)
        EnvConfig.path[:] = ['.']

        control = Control.Environment(searchPath=[])

        #self.assertRaises(OSError, control.loadXML, tmp('first.xml'))
        control.loadXML(tmp('first.xml'))
        self.assertEqual(str(control['main']), 'first')
        self.assertEqual(str(control['test_path']), 'data1:data2')
        self.assertEqual(str(control['derived']), 'another_first')

        control = Control.Environment(searchPath=[tmp()])
        control.loadXML(tmp('first.xml'))
        self.assertEqual(str(control['main']), 'first')
        self.assertEqual(str(control['test_path']), 'data1:data2')
        self.assertEqual(str(control['derived']), 'another_first')

        control = Control.Environment(searchPath=[tmp()])
        control.loadXML('first.xml')
        self.assertEqual(str(control['main']), 'first')
        self.assertEqual(str(control['test_path']), 'data1:data2')
        self.assertEqual(str(control['derived']), 'another_first')

        control = Control.Environment(searchPath=[tmp()])
        self.assertRaises(OSError, control.loadXML, tmp('second.xml'))

        control = Control.Environment(searchPath=[tmp(), tmp('subdir')])
        control.loadXML(tmp('second.xml'))
        self.assertEqual(str(control['main']), 'second')
        self.assertEqual(str(control['test_path']), 'data0:data1')
        self.assertEqual(str(control['map']), 'this_is_second_inc')

        control = Control.Environment(searchPath=[tmp(), tmp('subdir')])
        control.loadXML(tmp('first.xml'))
        self.assertEqual(str(control['main']), 'first')
        self.assertEqual(str(control['test_path']), 'data1:data2')
        self.assertEqual(str(control['derived']), 'another_first')

        control = Control.Environment(searchPath=[tmp('subdir'), tmp()])
        control.loadXML(tmp('first.xml'))
        self.assertEqual(str(control['main']), 'first')
        self.assertEqual(str(control['test_path']), 'data1:data2')
        self.assertEqual(str(control['derived']), 'another_first')

        control = Control.Environment(searchPath=[tmp('subdir'), tmp()])
        control.loadXML('first.xml')
        self.assertEqual(str(control['main']), 'first')
        self.assertEqual(str(control['test_path']), 'data1:data2')
        self.assertEqual(str(control['derived']), 'another_first')

        #os.environ['ENVXMLPATH'] = os.pathsep.join([tmp(), tmp('subdir')])
        EnvConfig.path[:] = ['.', tmp(), tmp('subdir')]
        control = Control.Environment(searchPath=[])
        control.loadXML(tmp('second.xml'))
        self.assertEqual(str(control['main']), 'second')
        self.assertEqual(str(control['test_path']), 'data0:data1')
        self.assertEqual(str(control['map']), 'this_is_second_inc')
        #del os.environ['ENVXMLPATH']
        EnvConfig.path[:] = ['.']

        control = Control.Environment(searchPath=[])
        control.loadXML(tmp('third.xml'))
        self.assertEqual(str(control['main']), 'third')
        self.assertEqual(str(control['test_path']), 'data1')
        self.assertEqual(str(control['derived']), 'second_third')

        control = Control.Environment(searchPath=[tmp('subdir')])
        control.loadXML(tmp('fourth.xml'))
        self.assertEqual(str(control['main']), 'fourth')
        self.assertEqual(str(control['included']), 'from subdir')

        control = Control.Environment(searchPath=[])
        control.loadXML(tmp('fourth.xml'))
        self.assertEqual(str(control['main']), 'fourth')
        self.assertEqual(str(control['included']), 'from subdir2')

        control = Control.Environment(searchPath=[])
        #self.assertRaises(OSError, control.loadXML, tmp('first.xml'))
        control.loadXML(tmp('recursion.xml'))

        # restore search path
        EnvConfig.path = saved_path