Exemplo n.º 1
0
 class upstart_service(UpstartService):
     """
     Redis upstart service.
     """
     slug = Q('redis-%s') % Q.parent.slug
     chdir = '/'
     user = Q.parent.username
     command = Q('/usr/local/bin/redis-server %s') % Q.parent.config_file
    def test_literals(self):
        # Literals
        q = Q('string')
        self.assertEqual(get_query_result(q, None), 'string')

        q = Q(55)
        self.assertEqual(get_query_result(q, None), 55)

        q = Q(True)
        self.assertEqual(get_query_result(q, None), True)

        q = Q(False)
        self.assertEqual(get_query_result(q, None), False)
Exemplo n.º 3
0
class UnitTest(Service):
    def fail_with_error(self):
        """
        This is an action which failes with an error.
        A nice traceback should be shown in the shell.
        (If this was called from the shell.)
        """
        self._error_func()

    def _error_func(self):
        self._error_func2()

    def _error_func2(self):
        raise Exception('Something went wrong (dummy exception)')

    def eternal_recursion(self):
        self.eternal_recursion()

    def false_status_code_exception(self):
        self.hosts.run('/bin/false')

    #
    # Q-object tests
    #

    var1 = 'a'
    var2 = 'b'
    var3 = 55
    var4 = 22
    var5 = 2
    var_list = [1, 2, 3, 4]
    #q_addition = Q.var3 + Q.var4
    #q_substraction = Q.var3 - Q.var4
    q_modulo = Q('%s/%s') % (Q.var1, Q.var2)
    q_index = Q.var_list[Q.var5]
    q_invalid = Q.some.invalid.query

    def test_q_object(self):
        test('Q-object: variable retreival', 'a', lambda: self.var1)
        #test('Q-object: addition', 77, lambda: self.q_addition)
        #test('Q-object: substraction', 33, lambda: self.q_substraction)
        test('Q-object: module operator', 'a/b', lambda: self.q_modulo)
        test('Q-object: index operator (Q.var[Q.var2])', 3,
             lambda: self.q_index)
        test('Q-object exception',
             None,
             lambda: self.q_invalid,
             should_fail=True)
    def test_booleans(self):
        # And/or/not
        q = Q(True) & Q(True)
        self.assertEqual(get_query_result(q, None), True)

        q = Q(True) & Q(False)
        self.assertEqual(get_query_result(q, None), False)

        q = Q(True) | Q(False)
        self.assertEqual(get_query_result(q, None), True)

        q = Q(False) | Q(False)
        self.assertEqual(get_query_result(q, None), False)

        q = ~Q(False)
        self.assertEqual(get_query_result(q, None), True)

        q = ~Q(True)
        self.assertEqual(get_query_result(q, None), False)

        # Combinations
        q = Q(False) | ~Q(False)
        self.assertEqual(get_query_result(q, None), True)
 def test_string_interpolation(self):
     # String interpolation
     q = Q('before %s after') % 'value'
     self.assertEqual(get_query_result(q, None), 'before value after')
    def test_operator_overloads(self):
        # Simple operator overloads (Both Q objects)
        q = Q('a') + Q('b')
        self.assertEqual(get_query_result(q, None), 'ab')

        q = Q(1) + Q(2)
        self.assertEqual(get_query_result(q, None), 3)

        q = Q(2) - Q(1)
        self.assertEqual(get_query_result(q, None), 1)

        q = Q(3) * Q(4)
        self.assertEqual(get_query_result(q, None), 12)

        q = Q(12) / Q(4)
        self.assertEqual(get_query_result(q, None), 3)

        # Simple operator overloads (Q object on the left.)
        q = Q('a') + 'b'
        self.assertEqual(get_query_result(q, None), 'ab')

        q = Q(1) + 2
        self.assertEqual(get_query_result(q, None), 3)

        q = Q(2) - 1
        self.assertEqual(get_query_result(q, None), 1)

        q = Q(3) * 4
        self.assertEqual(get_query_result(q, None), 12)

        q = Q(12) / 4
        self.assertEqual(get_query_result(q, None), 3)

        # Simple operator overloads (Q object on the right.)
        q = 'a' + Q('b')
        self.assertEqual(get_query_result(q, None), 'ab')

        q = 1 + Q(2)
        self.assertEqual(get_query_result(q, None), 3)

        q = 2 - Q(1)
        self.assertEqual(get_query_result(q, None), 1)

        q = 3 * Q(4)
        self.assertEqual(get_query_result(q, None), 12)

        q = 12 / Q(4)
        self.assertEqual(get_query_result(q, None), 3)
    def test_reprs(self):
        # Operators
        self.assertEqual(repr(Q(4) + Q(5)), '4 + 5')
        self.assertEqual(repr(Q(4) - Q(5)), '4 - 5')
        self.assertEqual(repr(Q(4) * Q(5)), '4 * 5')
        self.assertEqual(repr(Q(4) / Q(5)), '4 / 5')

        # Booleans
        self.assertEqual(repr(Q(4) | ~Q(5)), '4 | ~ 5')
        self.assertEqual(repr(Q(4) & ~Q(5)), '4 & ~ 5')

        # Attributes and calls
        self.assertEqual(repr(Q.a), 'Q.a')
        self.assertEqual(repr(Q.b['lookup']), "Q.b['lookup']")
        self.assertEqual(repr(Q.a.call('param') + Q.b['lookup']),
                         "Q.a.call('param') + Q.b['lookup']")
        self.assertEqual(repr(Q.a.call('param', 'p2', key='value')),
                         "Q.a.call('param', 'p2', key='value')")
        self.assertEqual(repr(Q.a.call(Q.a)), "Q.a.call(Q.a)")
    def test_resolve_types(self):
        q = Q(Q('a'))
        self.assertEqual(get_query_result(q, None), 'a')

        q = Q([Q('%s') % 'a'])
        self.assertEqual(get_query_result(q, None), ['a'])

        q = Q('%s: %s') % ('a', 'b')
        self.assertEqual(get_query_result(q, None), 'a: b')

        q = Q('%s: %s') % (Q('a'), Q('b'))
        self.assertEqual(get_query_result(q, None), 'a: b')

        q = Q(['a', 'b']) + ['c', 'd']
        self.assertEqual(get_query_result(q, None), ['a', 'b', 'c', 'd'])

        q = Q(['a', 'b']) + [Q('c'), Q('d')]
        self.assertEqual(get_query_result(q, None), ['a', 'b', 'c', 'd'])

        q = Q('%(A)s: %(B)s') % {'A': 'a', 'B': 'b'}
        self.assertEqual(get_query_result(q, None), 'a: b')

        q = Q('%(A)s: %(B)s') % {Q('A'): Q('a'), Q('B'): Q('b')}
        self.assertEqual(get_query_result(q, None), 'a: b')