summaryrefslogtreecommitdiffstats
path: root/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py
blob: 154d6a8db06b93fcdfa3dfa1f7eb956989e943f1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import os
import sys
import lxml.etree
from mock import Mock, MagicMock, patch
from Bcfg2.Server.Plugins.Cfg.CfgGenshiGenerator import *
from Bcfg2.Server.Plugin import PluginExecutionError

# add all parent testsuite directories to sys.path to allow (most)
# relative imports in python 2.4
path = os.path.dirname(__file__)
while path != "/":
    if os.path.basename(path).lower().startswith("test"):
        sys.path.append(path)
    if os.path.basename(path) == "testsuite":
        break
    path = os.path.dirname(path)
from common import *
from TestServer.TestPlugins.TestCfg.Test_init import TestCfgGenerator


class TestCfgGenshiGenerator(TestCfgGenerator):
    test_obj = CfgGenshiGenerator

    def test__init(self):
        TestCfgGenerator.test__init(self)
        cgg = self.get_obj()
        self.assertIsInstance(cgg.loader, cgg.__loader_cls__)

    def test_get_data(self):
        cgg = self.get_obj()
        cgg._handle_genshi_exception = Mock()
        cgg.setup = MagicMock()
        cgg.template = Mock()
        fltr = Mock()
        cgg.template.generate.return_value = fltr
        stream = Mock()
        fltr.filter.return_value = stream
        entry = lxml.etree.Element("Path", name="/test.txt")
        metadata = Mock()


        def reset():
            cgg.template.reset_mock()
            cgg._handle_genshi_exception.reset_mock()
            cgg.setup.reset_mock()

        template_vars = dict(
            name=entry.get("name"),
            metadata=metadata,
            path=cgg.name,
            source_path=cgg.name,
            repo=cgg.setup.__getitem__.return_value)

        self.assertEqual(cgg.get_data(entry, metadata),
                         stream.render.return_value)
        cgg.template.generate.assert_called_with(**template_vars)
        cgg.setup.__getitem__.assert_called_with("repo")
        fltr.filter.assert_called_with(removecomment)
        stream.render.assert_called_with("text", encoding=cgg.encoding,
                                         strip_whitespace=False)

        reset()
        def render(fmt, **kwargs):
            stream.render.side_effect = None
            raise TypeError
        stream.render.side_effect = render
        self.assertEqual(cgg.get_data(entry, metadata),
                         stream.render.return_value)
        cgg.template.generate.assert_called_with(**template_vars)
        cgg.setup.__getitem__.assert_called_with("repo")
        fltr.filter.assert_called_with(removecomment)
        self.assertEqual(stream.render.call_args_list,
                         [call("text", encoding=cgg.encoding,
                              strip_whitespace=False),
                          call("text", encoding=cgg.encoding)])

        reset()
        stream.render.side_effect = UndefinedError("test")
        self.assertRaises(UndefinedError,
                          cgg.get_data, entry, metadata)
        cgg.template.generate.assert_called_with(**template_vars)
        cgg.setup.__getitem__.assert_called_with("repo")
        fltr.filter.assert_called_with(removecomment)
        stream.render.assert_called_with("text", encoding=cgg.encoding,
                                         strip_whitespace=False)

        reset()
        stream.render.side_effect = ValueError
        cgg._handle_genshi_exception.side_effect = ValueError
        self.assertRaises(ValueError,
                          cgg.get_data, entry, metadata)
        cgg.template.generate.assert_called_with(**template_vars)
        cgg.setup.__getitem__.assert_called_with("repo")
        fltr.filter.assert_called_with(removecomment)
        stream.render.assert_called_with("text", encoding=cgg.encoding,
                                         strip_whitespace=False)
        self.assertTrue(cgg._handle_genshi_exception.called)

    def test_handle_event(self):
        cgg = self.get_obj()
        cgg.loader = Mock()
        event = Mock()
        cgg.handle_event(event)
        cgg.loader.load.assert_called_with(cgg.name,
                                           cls=NewTextTemplate,
                                           encoding=cgg.encoding)

        cgg.loader.reset_mock()
        cgg.loader.load.side_effect = OSError
        self.assertRaises(PluginExecutionError,
                          cgg.handle_event, event)
        cgg.loader.load.assert_called_with(cgg.name,
                                           cls=NewTextTemplate,
                                           encoding=cgg.encoding)