import unittest

from robot.variables import Variables

from robot.errors import DataError, VariableError

from robot.utils.asserts import assert_equal, assert_raises

from robot.utils import JYTHON

SCALARS = ['${var}', '${ v A R }']

LISTS = ['@{var}', '@{ v A R }']

NOKS = ['var', '$var', '${var', '${va}r', '@{va}r', '@var', '%{var}', ' ${var}',

'@{var} ', '\\${var}', '\\\\${var}', 42, None, ['${var}'], DataError]

# Simple objects needed when testing assigning objects to variables.

# JavaObject lives in '../../acceptance/testdata/libraries'

class PythonObject(object):

def __init__(self, a, b):

self.a = a

self.b = b

def __getitem__(self, index):

return (self.a, self.b)[index]

def __str__(self):

return '(%s, %s)' % (self.a, self.b)

def __len__(self):

return 2

__repr__ = __str__

if JYTHON:

import JavaObject

class TestVariables(unittest.TestCase):

def setUp(self):

self.varz = Variables()

def test_set(self):

value = ['value']

for var in SCALARS + LISTS:

self.varz[var] = value

assert_equal(self.varz[var], value)

assert_equal(self.varz[var.lower().replace(' ', '')], value)

self.varz.clear()

def test_set_invalid(self):

for var in NOKS:

assert_raises(DataError, self.varz.__setitem__, var, 'value')

def test_set_scalar(self):

for var in SCALARS:

for value in ['string', '', 10, ['hi', 'u'], ['hi', 2],

{'a': 1, 'b': 2}, self, None, unittest.TestCase]:

self.varz[var] = value

assert_equal(self.varz[var], value)

def test_set_list(self):

for var in LISTS:

for value in [[], [''], ['str'], [10], ['hi', 'u'], ['hi', 2],

[{'a': 1, 'b': 2}, self, None]]:

self.varz[var] = value

assert_equal(self.varz[var], value)

self.varz.clear()

def test_replace_scalar(self):

self.varz['${foo}'] = 'bar'

self.varz['${a}'] = 'ari'

for inp, exp in [('${foo}', 'bar'),

('${a}', 'ari'),

(r'$\{a}', '${a}'),

('', ''),

('hii', 'hii'),

("Let's go to ${foo}!", "Let's go to bar!"),

('${foo}ba${a}-${a}', 'barbaari-ari')]:

assert_equal(self.varz.replace_scalar(inp), exp)

def test_replace_list(self):

self.varz['@{L}'] = ['v1', 'v2']

self.varz['@{E}'] = []

self.varz['@{S}'] = ['1', '2', '3']

for inp, exp in [(['@{L}'], ['v1', 'v2']),

(['@{L}', 'v3'], ['v1', 'v2', 'v3']),

(['v0', '@{L}', '@{E}', 'v${S}[2]'], ['v0', 'v1', 'v2', 'v3']),

([], []),

(['hi u', 'hi 2', 3], ['hi u','hi 2', 3])]:

assert_equal(self.varz.replace_list(inp), exp)

def test_replace_list_in_scalar_context(self):

self.varz['@{list}'] = ['v1', 'v2']

assert_equal(self.varz.replace_list(['@{list}']), ['v1', 'v2'])

assert_equal(self.varz.replace_list(['-@{list}-']), ["-['v1', 'v2']-"])

def test_replace_list_item(self):

self.varz['@{L}'] = ['v0', 'v1']

assert_equal(self.varz.replace_list(['${L}[0]']), ['v0'])

assert_equal(self.varz.replace_scalar('${L}[1]'), 'v1')

assert_equal(self.varz.replace_scalar('-${L}[0]${L}[1]${L}[0]-'), '-v0v1v0-')

self.varz['${L2}'] = ['v0', ['v11', 'v12']]

assert_equal(self.varz.replace_list(['${L2}[0]']), ['v0'])

assert_equal(self.varz.replace_list(['${L2}[1]']), [['v11', 'v12']])

assert_equal(self.varz.replace_scalar('${L2}[0]'), 'v0')

assert_equal(self.varz.replace_scalar('${L2}[1]'), ['v11', 'v12'])

assert_equal(self.varz.replace_list(['${L}[0]', '@{L2}[1]']), ['v0', 'v11', 'v12'])

def test_replace_dict_item(self):

self.varz['&{D}'] = {'a': 1, 2: 'b', 'nested': {'a': 1}}

assert_equal(self.varz.replace_scalar('${D}[a]'), 1)

assert_equal(self.varz.replace_scalar('${D}[${2}]'), 'b')

assert_equal(self.varz.replace_scalar('${D}[nested][a]'), 1)

assert_equal(self.varz.replace_scalar('${D}[nested]'), {'a': 1})

assert_equal(self.varz.replace_scalar('&{D}[nested]'), {'a': 1})

def test_replace_non_strings(self):

self.varz['${d}'] = {'a': 1, 'b': 2}

self.varz['${n}'] = None

assert_equal(self.varz.replace_scalar('${d}'), {'a': 1, 'b': 2})

assert_equal(self.varz.replace_scalar('${n}'), None)

def test_replace_non_strings_inside_string(self):

class Example:

def __str__(self):

return 'Hello'

self.varz['${h}'] = Example()

self.varz['${w}'] = 'world'

res = self.varz.replace_scalar('Another "${h} ${w}" example')

assert_equal(res, 'Another "Hello world" example')

def test_replace_list_item_invalid(self):

self.varz['@{L}'] = ['v0', 'v1', 'v3']

for inv in ['@{L}[3]', '@{NON}[0]', '@{L[2]}']:

assert_raises(VariableError, self.varz.replace_list, [inv])

def test_replace_non_existing_list(self):

assert_raises(VariableError, self.varz.replace_list, ['${nonexisting}'])

def test_replace_non_existing_scalar(self):

assert_raises(VariableError, self.varz.replace_scalar, '${nonexisting}')

def test_replace_non_existing_string(self):

assert_raises(VariableError, self.varz.replace_string, '${nonexisting}')

def test_non_string_input(self):

for item in [1, False, None, [], (), {}, object]:

assert_equal(self.varz.replace_list([item]), [item])

assert_equal(self.varz.replace_scalar(item), item)

assert_equal(self.varz.replace_string(item), str(item))

def test_replace_escaped(self):

self.varz['${foo}'] = 'bar'

for inp, exp in [(r'\${foo}', r'${foo}'),

(r'\\${foo}', r'\bar'),

(r'\\\${foo}', r'\${foo}'),

(r'\\\\${foo}', r'\\bar'),

(r'\\\\\${foo}', r'\\${foo}')]:

assert_equal(self.varz.replace_scalar(inp), exp)

def test_variables_in_value(self):

self.varz['${exists}'] = 'Variable exists but is still not replaced'

self.varz['${test}'] = '${exists} & ${does_not_exist}'

assert_equal(self.varz['${test}'], '${exists} & ${does_not_exist}')

self.varz['@{test}'] = ['${exists}', '&', '${does_not_exist}']

assert_equal(self.varz['@{test}'], '${exists} & ${does_not_exist}'.split())

def test_variable_as_object(self):

obj = PythonObject('a', 1)

self.varz['${obj}'] = obj

assert_equal(self.varz['${obj}'], obj)

expected = ['Some text here %s and %s there' % (obj, obj)]

actual = self.varz.replace_list(['Some text here ${obj} and ${obj} there'])

assert_equal(actual, expected)

def test_extended_variables(self):

# Extended variables are vars like ${obj.name} when we have var ${obj}

obj = PythonObject('a', [1, 2, 3])

dic = {'a': 1, 'o': obj}

self.varz['${obj}'] = obj

self.varz['${dic}'] = dic

assert_equal(self.varz.replace_scalar('${obj.a}'), 'a')

assert_equal(self.varz.replace_scalar('${obj.b}'), [1, 2, 3])

assert_equal(self.varz.replace_scalar('${obj.b[0]}-${obj.b[1]}'), '1-2')

assert_equal(self.varz.replace_scalar('${dic["a"]}'), 1)

assert_equal(self.varz.replace_scalar('${dic["o"]}'), obj)

assert_equal(self.varz.replace_scalar('-${dic["o"].b[2]}-'), '-3-')

def test_space_is_not_ignored_after_newline_in_extend_variable_syntax(self):

self.varz['${x}'] = 'test string'

self.varz['${lf}'] = '\\n'

self.varz['${lfs}'] = '\\n '

for inp, exp in [('${x.replace(" ", """\\n""")}', 'test\nstring'),

('${x.replace(" ", """\\n """)}', 'test\n string'),

('${x.replace(" ", """${lf}""")}', 'test\nstring'),

('${x.replace(" ", """${lfs}""")}', 'test\n string')]:

assert_equal(self.varz.replace_scalar(inp), exp)

def test_escaping_with_extended_variable_syntax(self):

self.varz['${p}'] = 'c:\\temp'

assert self.varz['${p}'] == 'c:\\temp'

assert_equal(self.varz.replace_scalar('${p + "\\\\foo.txt"}'),

'c:\\temp\\foo.txt')

def test_internal_variables(self):

# Internal variables are variables like ${my${name}}

self.varz['${name}'] = 'name'

self.varz['${my name}'] = 'value'

assert_equal(self.varz.replace_scalar('${my${name}}'), 'value')

self.varz['${whos name}'] = 'my'

assert_equal(self.varz.replace_scalar('${${whos name} ${name}}'), 'value')

assert_equal(self.varz.replace_scalar('${${whos${name}}${name}}'), 'value')

self.varz['${my name}'] = [1, 2, 3]

assert_equal(self.varz.replace_scalar('${${whos${name}}${name}}'), [1, 2, 3])

assert_equal(self.varz.replace_scalar('- ${${whos${name}}${name}} -'), '- [1, 2, 3] -')

def test_math_with_internal_vars(self):

assert_equal(self.varz.replace_scalar('${${1}+${2}}'), 3)

assert_equal(self.varz.replace_scalar('${${1}-${2}}'), -1)

assert_equal(self.varz.replace_scalar('${${1}*${2}}'), 2)

assert_equal(self.varz.replace_scalar('${${1}//${2}}'), 0)

def test_math_with_internal_vars_with_spaces(self):

assert_equal(self.varz.replace_scalar('${${1} + ${2.5}}'), 3.5)

assert_equal(self.varz.replace_scalar('${${1} - ${2} + 1}'), 0)

assert_equal(self.varz.replace_scalar('${${1} * ${2} - 1}'), 1)

assert_equal(self.varz.replace_scalar('${${1} / ${2.0}}'), 0.5)

def test_math_with_internal_vars_does_not_work_if_first_var_is_float(self):

assert_raises(VariableError, self.varz.replace_scalar, '${${1.1}+${2}}')

assert_raises(VariableError, self.varz.replace_scalar, '${${1.1} - ${2}}')

assert_raises(VariableError, self.varz.replace_scalar, '${${1.1} * ${2}}')

assert_raises(VariableError, self.varz.replace_scalar, '${${1.1}/${2}}')

def test_list_variable_as_scalar(self):

self.varz['@{name}'] = exp = ['spam', 'eggs']

assert_equal(self.varz.replace_scalar('${name}'), exp)

assert_equal(self.varz.replace_list(['${name}', 42]), [exp, 42])

assert_equal(self.varz.replace_string('${name}'), str(exp))

def test_copy(self):

varz = Variables()

varz['${foo}'] = 'bar'

copy = varz.copy()

assert_equal(copy['${foo}'], 'bar')

if JYTHON:

def test_variable_as_object_in_java(self):

obj = JavaObject('hello')

self.varz['${obj}'] = obj

assert_equal(self.varz['${obj}'], obj)

assert_equal(self.varz.replace_scalar('${obj} world'), 'hello world')

def test_extended_variables_in_java(self):

obj = JavaObject('my name')

self.varz['${obj}'] = obj

assert_equal(self.varz.replace_list(['${obj.name}']), ['my name'])

def test_ignore_error(self):

v = Variables()

v['${X}'] = 'x'

v['@{Y}'] = [1, 2, 3]

for item in ['${foo}', 'foo${bar}', '${foo}', '@{zap}', '${Y}[7]',

'${inv', '${{inv}', '${var}[inv', '${var}[key][inv']:

x_at_end = 'x' if (item.count('{') == item.count('}') and

item.count('[') == item.count(']')) else '${x}'

assert_equal(v.replace_string(item, ignore_errors=True), item)

assert_equal(v.replace_string('${x}'+item+'${x}', ignore_errors=True),

'x' + item + x_at_end)

assert_equal(v.replace_scalar(item, ignore_errors=True), item)

assert_equal(v.replace_scalar('${x}'+item+'${x}', ignore_errors=True),

'x' + item + x_at_end)

assert_equal(v.replace_list([item], ignore_errors=True), [item])

assert_equal(v.replace_list(['${X}', item, '@{Y}'], ignore_errors=True),

['x', item, 1, 2, 3])

assert_equal(v.replace_list(['${x}'+item+'${x}', '@{NON}'], ignore_errors=True),

['x' + item + x_at_end, '@{NON}'])

def test_sequence_subscript(self):

sequences = (

[42, 'my', 'name'],

(42, ['foo', 'bar'], 'name'),

'abcDEF123#@$',

b'abcDEF123#@$',

bytearray(b'abcDEF123#@$'),

)

for var in sequences:

self.varz['${var}'] = var

assert_equal(self.varz.replace_scalar('${var}[0]'), var[0])

assert_equal(self.varz.replace_scalar('${var}[-2]'), var[-2])

assert_equal(self.varz.replace_scalar('${var}[::2]'), var[::2])

assert_equal(self.varz.replace_scalar('${var}[1::2]'), var[1::2])

assert_equal(self.varz.replace_scalar('${var}[1:-3:2]'), var[1:-3:2])

assert_raises(VariableError, self.varz.replace_scalar, '${var}[0][1]')

def test_dict_subscript(self):

a_key = (42, b'key')

var = {'foo': 'bar', 42: [4, 2], 'name': b'my-name', a_key: {4: 2}}

self.varz['${a_key}'] = a_key

self.varz['${var}'] = var

assert_equal(self.varz.replace_scalar('${var}[foo][-1]'), var['foo'][-1])

assert_equal(self.varz.replace_scalar('${var}[${42}][-1]'), var[42][-1])

assert_equal(self.varz.replace_scalar('${var}[name][:3]'), var['name'][:3])

assert_equal(self.varz.replace_scalar('${var}[${a_key}][${4}]'), var[a_key][4])

assert_raises(VariableError, self.varz.replace_scalar, '${var}[1]')

assert_raises(VariableError, self.varz.replace_scalar, '${var}[42:]')

assert_raises(VariableError, self.varz.replace_scalar, '${var}[nonex]')

def test_custom_class_subscriptable_like_sequence(self):

# the two class attributes are accessible via indices 0 and 1

# slicing should be supported here as well

bytes_key = b'my'

var = PythonObject([1, 2, 3, 4, 5], {bytes_key: 'myname'})

self.varz['${bytes_key}'] = bytes_key

self.varz['${var}'] = var

assert_equal(self.varz.replace_scalar('${var}[${0}][2::2]'), [3, 5])

assert_equal(self.varz.replace_scalar('${var}[0][2::2]'), [3, 5])

assert_equal(self.varz.replace_scalar('${var}[1][${bytes_key}][2:]'), 'name')

assert_equal(self.varz.replace_scalar('${var}\\[1]'), str(var) + '[1]')

assert_equal(self.varz.replace_scalar('${var}[:][0][4]'), var[:][0][4])

assert_equal(self.varz.replace_scalar('${var}[:-2]'), var[:-2])

assert_equal(self.varz.replace_scalar('${var}[:7:-2]'), var[:7:-2])

assert_equal(self.varz.replace_scalar('${var}[2::]'), ())

assert_raises(VariableError, self.varz.replace_scalar, '${var}[${2}]')

assert_raises(VariableError, self.varz.replace_scalar, '${var}[${bytes_key}]')

def test_non_subscriptable(self):

assert_raises(VariableError, self.varz.replace_scalar, '${1}[1]')

if __name__ == '__main__':

unittest.main()