1import unittest 

2 

3from webapp.markdown import parse_markdown_description 

4 

5 

6class TestMarkdownParser(unittest.TestCase): 

7 """This class tests the custom parser for the snap description. This 

8 parser allows only a limited amount of tags. We want a lot of tests for 

9 it to make sure on upgrades we don't lose the custom tags that we want 

10 to keep. 

11 """ 

12 

13 def test_parse_title(self): 

14 """Title conversion shouldn't work""" 

15 markdown = "# title" 

16 result = parse_markdown_description(markdown) 

17 expected_result = "<p># title</p>\n" 

18 

19 self.assertEqual(result, expected_result) 

20 

21 def test_parse_urls(self): 

22 """Literal URLs auto-link https://foo.bar""" 

23 markdown = "https://toto.space" 

24 result = parse_markdown_description(markdown) 

25 expected_result = ( 

26 '<p><a href="https://toto.space">https://toto.space</a></p>\n' 

27 ) 

28 

29 self.assertEqual(result, expected_result) 

30 

31 def test_parse_urls_title(self): 

32 """URLs with title [title for the link](https://foo.bar)""" 

33 markdown = "[toto](https://toto.space)" 

34 result = parse_markdown_description(markdown) 

35 expected_result = ( 

36 "<p>" 

37 '[toto](<a href="https://toto.space">https://toto.space</a>)' 

38 "</p>\n" 

39 ) 

40 

41 self.assertEqual(result, expected_result) 

42 

43 def test_parse_italics(self): 

44 """Italics (_foo_)""" 

45 markdown = "_text_" 

46 result = parse_markdown_description(markdown) 

47 expected_result = "<p><em>text</em></p>\n" 

48 

49 self.assertEqual(result, expected_result) 

50 

51 def test_parse_bold(self): 

52 """Bold (**foo**)""" 

53 markdown = "**text**" 

54 result = parse_markdown_description(markdown) 

55 expected_result = "<p><strong>text</strong></p>\n" 

56 

57 self.assertEqual(result, expected_result) 

58 

59 def test_parse_paragraph_merging(self): 

60 """Paragraph merging (consecutive lines are joined)""" 

61 markdown = "this is\n a paragraph" 

62 result = parse_markdown_description(markdown) 

63 expected_result = "<p>this is\n a paragraph</p>\n" 

64 

65 self.assertEqual(result, expected_result) 

66 

67 def test_parse_paragraph(self): 

68 """Paragraphs""" 

69 markdown = "paragraph 1\n\n paragraph 2" 

70 result = parse_markdown_description(markdown) 

71 expected_result = "<p>paragraph 1</p>\n<p>paragraph 2</p>\n" 

72 

73 self.assertEqual(result, expected_result) 

74 

75 def test_parse_text(self): 

76 """Text conversion works""" 

77 markdown = "text" 

78 result = parse_markdown_description(markdown) 

79 expected_result = "<p>text</p>\n" 

80 

81 self.assertEqual(result, expected_result) 

82 

83 def test_parse_triple_fences(self): 

84 """Code (text blocks inside ``` pairs)""" 

85 markdown = "```code block```" 

86 result = parse_markdown_description(markdown) 

87 expected_result = "<p>```code block```</p>\n" 

88 

89 self.assertEqual(result, expected_result) 

90 

91 def test_parse_single_fences(self): 

92 """Code (text blocks inside ` pairs)""" 

93 markdown = "`code block`" 

94 result = parse_markdown_description(markdown) 

95 expected_result = "<p><code>code block</code></p>\n" 

96 

97 self.assertEqual(result, expected_result) 

98 

99 def test_parse_code_block_single_line(self): 

100 """Code with three space indentation""" 

101 markdown = " code" 

102 result = parse_markdown_description(markdown) 

103 expected_result = "<pre><code>code\n</code></pre>\n" 

104 

105 self.assertEqual(result, expected_result) 

106 

107 def test_parse_code_block_multiple_line(self): 

108 """Code with four space indentation""" 

109 markdown = " code\n code line 2" 

110 result = parse_markdown_description(markdown) 

111 expected_result = "<pre><code> code\n code line 2\n</code></pre>\n" 

112 

113 self.assertEqual(result, expected_result) 

114 

115 def test_parse_code_block_multiple_line_tree_spaces(self): 

116 """Code with three space indentation""" 

117 markdown = " code\n code line 2" 

118 result = parse_markdown_description(markdown) 

119 expected_result = "<pre><code>code\ncode line 2\n</code></pre>\n" 

120 

121 self.assertEqual(result, expected_result) 

122 

123 def test_parse_code_line(self): 

124 """Code (text blocks inside `)""" 

125 markdown = "`code line`" 

126 result = parse_markdown_description(markdown) 

127 expected_result = "<p><code>code line</code></p>\n" 

128 

129 self.assertEqual(result, expected_result) 

130 

131 def test_parse_multiple_code_line(self): 

132 """Code (text blocks inside `)""" 

133 markdown = "`code line` and `code line`" 

134 result = parse_markdown_description(markdown) 

135 expected_result = ( 

136 "<p><code>code line</code> and <code>code line</code></p>\n" 

137 ) 

138 

139 self.assertEqual(result, expected_result) 

140 

141 def test_parse_list(self): 

142 """Lists (* Foo)""" 

143 markdown = "* item \n* item \n* item \n" 

144 result = parse_markdown_description(markdown) 

145 expected_result = ( 

146 "<ul>\n<li>item</li>\n<li>item</li>\n<li>item</li>\n</ul>\n" 

147 ) 

148 

149 self.assertEqual(result, expected_result) 

150 

151 def test_parse_list_special_char(self): 

152 """Lists (+ Foo)""" 

153 markdown = "+ item \n+ item \n+ item \n" 

154 result = parse_markdown_description(markdown) 

155 expected_result = ( 

156 "<ul>\n<li>item</li>\n<li>item</li>\n<li>item</li>\n</ul>\n" 

157 ) 

158 

159 self.assertEqual(result, expected_result) 

160 

161 def test_parse_list_ordered(self): 

162 """Lists (* Foo)""" 

163 markdown = "1. item \n2. item \n3. item \n" 

164 result = parse_markdown_description(markdown) 

165 expected_result = ( 

166 "<ol>\n<li>item</li>\n<li>item</li>\n<li>item</li>\n</ol>\n" 

167 ) 

168 

169 self.assertEqual(result, expected_result) 

170 

171 def test_parse_image_link(self): 

172 """Image link is converted into a simple link""" 

173 markdown = "" 

174 result = parse_markdown_description(markdown) 

175 expected_result = "<p>" + markdown + "</p>\n" 

176 

177 self.assertEqual(result, expected_result)