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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
""" Tests for ParserNode interface """
import unittest
from acme.magic_typing import Optional, Tuple # pylint: disable=unused-import, no-name-in-module
from certbot_apache import interfaces
class DummyParserNode(interfaces.ParserNode):
""" A dummy class implementing ParserNode interface """
ancestor = None
dirty = False
filepath = None
def __init__(self, ancestor=None, filepath=str(), dirty=False):
"""
Initializes the ParserNode instance.
"""
super(DummyParserNode, self).__init__(ancestor, filepath, dirty)
self.ancestor = ancestor
self.dirty = dirty
self.filepath = filepath
def save(self, msg): # pragma: no cover
"""Save"""
pass
class DummyCommentNode(DummyParserNode):
""" A dummy class implementing CommentNode interface """
def __init__(self, comment, ancestor, filepath, dirty=False):
"""
Initializes the CommentNode instance and sets its instance variables.
"""
super(DummyCommentNode, self).__init__(ancestor, filepath, dirty)
self.comment = comment
class DummyDirectiveNode(DummyParserNode):
""" A dummy class implementing DirectiveNode interface """
parameters = tuple() # type: Tuple[str, ...]
enabled = True
name = ""
# pylint: disable=too-many-arguments
def __init__(self, name, parameters=(), ancestor=None, filepath="",
dirty=False, enabled=True):
"""
Initializes the DirectiveNode instance and sets its instance variables.
"""
super(DummyDirectiveNode, self).__init__(ancestor, filepath, dirty)
self.name = name
self.parameters = parameters
self.enabled = enabled
def set_parameters(self, parameters): # pragma: no cover
"""Set parameters"""
pass
class DummyBlockNode(DummyParserNode):
""" A dummy class implementing BlockNode interface """
parameters = tuple() # type: Tuple[str, ...]
children = tuple() # type: Tuple[interfaces.ParserNode, ...]
enabled = True
name = ""
# pylint: disable=too-many-arguments
def __init__(self, name="", parameters=(), children=(), ancestor=None,
filepath="", dirty=False, enabled=True):
"""
Initializes the BlockNode instance and sets its instance variables.
"""
super(DummyBlockNode, self).__init__(ancestor, filepath, dirty)
self.name = name
self.parameters = parameters
self.children = children
self.enabled = enabled
def add_child_block(self, name, parameters=None, position=None): # pragma: no cover
"""Add child block"""
pass
def add_child_directive(self, name, parameters=None, position=None): # pragma: no cover
"""Add child directive"""
pass
def add_child_comment(self, comment="", position=None): # pragma: no cover
"""Add child comment"""
pass
def find_blocks(self, name, exclude=True): # pragma: no cover
"""Find blocks"""
pass
def find_directives(self, name, exclude=True): # pragma: no cover
"""Find directives"""
pass
def find_comments(self, comment, exact=False): # pragma: no cover
"""Find comments"""
pass
def delete_child(self, child): # pragma: no cover
"""Delete child"""
pass
def set_parameters(self, parameters): # pragma: no cover
"""Set parameters"""
pass
def unsaved_files(self): # pragma: no cover
"""Unsaved files"""
pass
interfaces.CommentNode.register(DummyCommentNode)
interfaces.DirectiveNode.register(DummyDirectiveNode)
interfaces.BlockNode.register(DummyBlockNode)
class ParserNodeTest(unittest.TestCase):
"""Dummy placeholder test case for ParserNode interfaces"""
def test_dummy(self):
dummyblock = DummyBlockNode()
dummydirective = DummyDirectiveNode("Name")
dummycomment = DummyCommentNode("Comment", dummyblock, "/some/file")
if __name__ == "__main__":
unittest.main() # pragma: no cover
|
