7 | 
8 | 
9 |
6 |
7 |
8 |
9 |
228 |
229 | ### Code Blocks
230 |
231 | Pre-formatted code blocks are used for writing about programming or
232 | markup source code. Rather than forming normal paragraphs, the lines
233 | of a code block are interpreted literally. Markdown wraps a code block
234 | in both `` and `` tags.
235 |
236 | To produce a code block in Markdown, simply indent every line of the
237 | block by at least 4 spaces or 1 tab.
238 |
239 | This is a normal paragraph:
240 |
241 | This is a code block.
242 |
243 | Here is an example of AppleScript:
244 |
245 | tell application "Foo"
246 | beep
247 | end tell
248 |
249 | A code block continues until it reaches a line that is not indented
250 | (or the end of the article).
251 |
252 | Within a code block, ampersands (`&`) and angle brackets (`<` and `>`)
253 | are automatically converted into HTML entities. This makes it very
254 | easy to include example HTML source code using Markdown -- just paste
255 | it and indent it, and Markdown will handle the hassle of encoding the
256 | ampersands and angle brackets. For example, this:
257 |
258 |
261 |
262 | Regular Markdown syntax is not processed within code blocks. E.g.,
263 | asterisks are just literal asterisks within a code block. This means
264 | it's also easy to use Markdown to write about Markdown's own syntax.
265 |
266 | ```
267 | tell application "Foo"
268 | beep
269 | end tell
270 | ```
271 |
272 | There's also code fences with the language specified
273 |
274 | ```python
275 | def test():
276 | pass
277 | ```
278 |
279 | ## Span Elements
280 |
281 | ### Links
282 |
283 | Markdown supports two style of links: *inline* and *reference*.
284 |
285 | In both styles, the link text is delimited by [square brackets].
286 |
287 | To create an inline link, use a set of regular parentheses immediately
288 | after the link text's closing square bracket. Inside the parentheses,
289 | put the URL where you want the link to point, along with an *optional*
290 | title for the link, surrounded in quotes. For example:
291 |
292 | This is [an example](http://example.com/) inline link.
293 |
294 | [This link](http://example.net/) has no title attribute.
295 |
296 | ### Emphasis
297 |
298 | Markdown treats asterisks (`*`) and underscores (`_`) as indicators of
299 | emphasis. Text wrapped with one `*` or `_` will be wrapped with an
300 | HTML `` tag; double `*`'s or `_`'s will be wrapped with an HTML
301 | `` tag. E.g., this input:
302 |
303 | *single asterisks*
304 |
305 | _single underscores_
306 |
307 | **double asterisks**
308 |
309 | __double underscores__
310 |
311 | ### Code
312 |
313 | To indicate a span of code, wrap it with backtick quotes (`` ` ``).
314 | Unlike a pre-formatted code block, a code span indicates code within a
315 | normal paragraph. For example:
316 |
317 | Use the `printf()` function.
318 |
319 | ### Images
320 |
321 | Images use the image syntax with an ` ! `
322 |
323 | 
324 |
325 | We can also use images from externally
326 |
327 | 
328 |
329 | ## Other stuff
330 |
331 | ### Tables
332 |
333 | We can do tables too
334 |
335 | | tic | tac | toe |
336 | |-----|-----|-----|
337 | | x | o | o |
338 | | o | x | x |
339 | | o | x | o |
340 |
341 | ### TODOs
342 |
343 | * This is a normal list item
344 | * [] Still a normal list item
345 | * [ ] Empty todo
346 | * [x] Todo that's checked
347 | * [ x] Still a normal list item
348 |
349 | ### Math stuff
350 |
351 | This is inline $y = ax + b$
352 |
353 | This is a block of _math_
354 |
355 | $$y = ax + b$$
--------------------------------------------------------------------------------
/tests/TEST IMAGE HAS SPACES.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Cobertos/md2notion/18ae9f1cc4511777329e9c6585db64b80ce65b1f/tests/TEST IMAGE HAS SPACES.png
--------------------------------------------------------------------------------
/tests/TEST.md:
--------------------------------------------------------------------------------
1 | # TEST
2 |
3 | | Awoo | Awooo | Awoooo |
4 | |---------|---------|---------|
5 | | Test100 | Test200 | Test300 |
6 | | | Test400 | |
7 |
--------------------------------------------------------------------------------
/tests/TEST_IMAGE.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Cobertos/md2notion/18ae9f1cc4511777329e9c6585db64b80ce65b1f/tests/TEST_IMAGE.png
--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Cobertos/md2notion/18ae9f1cc4511777329e9c6585db64b80ce65b1f/tests/__init__.py
--------------------------------------------------------------------------------
/tests/conftest.py:
--------------------------------------------------------------------------------
1 | def pytest_generate_tests(metafunc):
2 | if "headerLevel" in metafunc.fixturenames:
3 | metafunc.parametrize("headerLevel", map(lambda n: n+1, range(6)))
--------------------------------------------------------------------------------
/tests/test_NotionPyRenderer.py:
--------------------------------------------------------------------------------
1 | '''
2 | Tests NotionPyRenderer parsing
3 | '''
4 | import re
5 | import mistletoe
6 | import notion
7 | from md2notion.NotionPyRenderer import NotionPyRenderer, addHtmlImgTagExtension, addLatexExtension
8 |
9 | def test_header(capsys, headerLevel):
10 | '''it renders a range of headers, warns if it cant render properly'''
11 | #arrange/act
12 | output = mistletoe.markdown(f"{'#'*headerLevel} Owo what's this?", NotionPyRenderer)
13 | captured = capsys.readouterr()
14 |
15 | #assert
16 | assert len(output) == 1
17 | output = output[0]
18 | assert isinstance(output, dict)
19 | if headerLevel > 3: #Should print error
20 | assert re.search(r"not support", captured.out, re.I) #Should print out warning
21 | if headerLevel == 1:
22 | assert output['type'] == notion.block.HeaderBlock
23 | elif headerLevel == 2:
24 | assert output['type'] == notion.block.SubheaderBlock
25 | else:
26 | assert output['type'] == notion.block.SubsubheaderBlock
27 | assert output['title'] == "Owo what's this?"
28 |
29 | def test_list():
30 | '''it should render a normal list'''
31 | #arrange/act
32 | output = mistletoe.markdown("* asdf", NotionPyRenderer)
33 |
34 | #assert
35 | assert len(output) == 1
36 | output = output[0]
37 | assert isinstance(output, dict)
38 | assert output['type'] == notion.block.BulletedListBlock
39 | assert output['title'] == 'asdf'
40 |
41 | def test_list_numbered():
42 | '''it should render a numbered list if given one'''
43 | #arrange/act
44 | output = mistletoe.markdown("1. asdf", NotionPyRenderer)
45 |
46 | #assert
47 | assert len(output) == 1
48 | output = output[0]
49 | assert isinstance(output, dict)
50 | assert output['type'] == notion.block.NumberedListBlock
51 | assert output['title'] == 'asdf'
52 |
53 | def test_list2():
54 | '''it should render a GFM list item'''
55 | #arrange/act
56 | output = mistletoe.markdown(\
57 | """
58 | * [] Really
59 | * [ ] big
60 | * [x] uwu
61 | """, NotionPyRenderer)
62 |
63 | #assert
64 | assert len(output) == 3
65 | assert isinstance(output[0], dict)
66 | assert output[0]['type'] == notion.block.BulletedListBlock
67 | assert output[0]['title'] == '[] Really'
68 | assert isinstance(output[1], dict)
69 | assert output[1]['type'] == notion.block.TodoBlock
70 | assert output[1]['title'] == 'big'
71 | assert output[1]['checked'] == False
72 | assert isinstance(output[2], dict)
73 | assert output[2]['type'] == notion.block.TodoBlock
74 | assert output[2]['title'] == 'uwu'
75 | assert output[2]['checked'] == True
76 |
77 | def test_quote():
78 | '''it should render a numbered list if given one'''
79 | #arrange/act
80 | output = mistletoe.markdown("> Quoth thee 'Mr. Obama... Hewwo? MR OBAMA??'", NotionPyRenderer)
81 |
82 | #assert
83 | assert len(output) == 1
84 | output = output[0]
85 | assert isinstance(output, dict)
86 | assert output['type'] == notion.block.QuoteBlock
87 | assert output['title'] == "Quoth thee 'Mr. Obama... Hewwo? MR OBAMA??'"
88 |
89 | def test_image():
90 | '''it should render an image'''
91 | #arrange/act
92 | output = mistletoe.markdown("", NotionPyRenderer)
93 |
94 | #assert
95 | assert len(output) == 1
96 | output = output[0]
97 | assert isinstance(output, dict)
98 | assert output['type'] == notion.block.ImageBlock
99 |
100 | def test_imageInLink():
101 | '''it should render an image in a link, but separately because notion doesnt support that'''
102 | #arrange/act
103 | output = mistletoe.markdown("[](https://cobertos.com)", NotionPyRenderer)
104 |
105 | #assert
106 | assert len(output) == 2
107 | assert isinstance(output[0], dict)
108 | assert output[0]['type'] == notion.block.TextBlock
109 | assert output[0]['title'] == "[](https://cobertos.com)" #Should extract the image
110 | assert isinstance(output[1], dict) #The ImageBlock can't be in a link in Notion, so we get it outside
111 | assert output[1]['type'] == notion.block.ImageBlock
112 |
113 | def test_imageBlockText():
114 | '''it should render an image in bold text'''
115 | #arrange/act
116 | output = mistletoe.markdown("**texttexttexttext**", NotionPyRenderer)
117 |
118 | #assert
119 | assert len(output) == 2
120 | assert isinstance(output[0], dict)
121 | assert output[0]['type'] == notion.block.TextBlock
122 | assert output[0]['title'] == "**texttexttexttext**" #Should extract the image
123 | assert isinstance(output[1], dict) #The ImageBlock can't be inline with anything else so it comes out
124 | assert output[1]['type'] == notion.block.ImageBlock
125 |
126 | def test_imageInHtml():
127 | '''it should render an image that is mentioned in the html ![]()
tag'''
128 | #arrange/act
129 | output = mistletoe.markdown("head![](\"https://via.placeholder.com/500\")
tail",
130 | addHtmlImgTagExtension(NotionPyRenderer))
131 |
132 | #assert
133 | assert len(output) == 2
134 | assert isinstance(output[0], dict)
135 | assert output[0]['type'] == notion.block.TextBlock
136 | assert output[0]['title'] == "headtail" #Should extract the image
137 | assert isinstance(output[1], dict) #The ImageBlock can't be inline with anything else so it comes out
138 | assert output[1]['type'] == notion.block.ImageBlock
139 | assert output[1]['caption'] is None
140 |
141 | def test_imageInHtmlBlock():
142 | '''it should render an image that is mentioned in the html block'''
143 | output = mistletoe.markdown(\
144 | """
145 | 
text in div
146 |
147 | tail
148 | """, addHtmlImgTagExtension(NotionPyRenderer))
149 |
150 | #assert
151 | assert len(output) == 3
152 | assert isinstance(output[0], dict)
153 | assert output[0]['type'] == notion.block.TextBlock
154 | assert output[0]['title'] == "text in div" #Should extract the image
155 | assert isinstance(output[1], dict)
156 | assert output[1]['type'] == notion.block.ImageBlock
157 | assert output[1]['caption'] == "ImCaption"
158 | assert isinstance(output[2], dict)
159 | assert output[2]['type'] == notion.block.TextBlock
160 | assert output[2]['title'] == "tail"
161 |
162 | def test_latex_inline():
163 | output = mistletoe.markdown(r"""
164 | # Test for latex blocks
165 | Text before $f(x) = \sigma(w \cdot x + b)$ Text after
166 | """, addLatexExtension(NotionPyRenderer))
167 |
168 | assert output[1] is not None
169 | assert output[1]['type'] == notion.block.TextBlock
170 | assert output[1]['title'] == r'Text before $$f(x) = \sigma(w \cdot x + b)$$ Text after'
171 |
172 | def test_latex_inline_with_underscores():
173 | '''it should render a latex block with underscores in it properly'''
174 | output = mistletoe.markdown(r'Text before $X^T=(X_1, X_2, \ldots, X_p)$ Text after', addLatexExtension(NotionPyRenderer))
175 |
176 | assert len(output) == 1
177 | output = output[0]
178 | assert output is not None
179 | assert output['type'] == notion.block.TextBlock
180 | assert output['title'] == r'Text before $$X^T=(X_1, X_2, \ldots, X_p)$$ Text after'
181 |
182 | def test_latex_block():
183 | output = mistletoe.markdown(r"""
184 | # Test for latex blocks
185 | Text before
186 |
187 | $$
188 | f(x) = \sigma(w \cdot x + b)
189 | $$
190 |
191 | Text after
192 | """, addLatexExtension(NotionPyRenderer))
193 |
194 | assert output[2] is not None
195 | assert output[2]['type'] == notion.block.EquationBlock
196 | assert output[2]['title_plaintext'] == 'f(x) = \\\\sigma(w \\\\cdot x + b)\n'
197 |
198 | def test_latex_block_with_underscores():
199 | '''it should render a latex block with underscores in it properly'''
200 | output = mistletoe.markdown(r"""
201 | $$
202 | \hat{Y} = \hat{\beta}_0 + \sum_{j=1}^p X_j \hat{\beta}_j
203 | $$""", addLatexExtension(NotionPyRenderer))
204 |
205 | assert len(output) == 1
206 | output = output[0]
207 | assert output is not None
208 | assert output['type'] == notion.block.EquationBlock
209 | assert output['title_plaintext'] == '\\\\hat{Y} = \\\\hat{\\\\beta}_0 + \\\\sum_{j=1}^p X_j \\\\hat{\\\\beta}_j\n'
210 |
211 | def test_escapeSequence():
212 | '''it should render out an escape sequence'''
213 | #arrange/act
214 | output = mistletoe.markdown("\\066", NotionPyRenderer)
215 |
216 | #assert
217 | assert len(output) == 1
218 | output = output[0]
219 | assert output['type'] == notion.block.TextBlock
220 | assert output['title'] == "\\066"
221 |
222 | def test_table():
223 | '''it should render a table'''
224 | #arrange/act
225 | output = mistletoe.markdown(\
226 | """
227 | | Awoo | Awooo | Awoooo |
228 | |---------|---------|---------|
229 | | Test100 | Test200 | Test300 |
230 | | | Test400 | |
231 | """, NotionPyRenderer)
232 |
233 | #assert
234 | assert len(output) == 1
235 | output = output[0]
236 | assert isinstance(output, dict)
237 | assert output['type'] == notion.block.CollectionViewBlock
238 |
239 | assert isinstance(output['schema'], dict)
240 | assert len(output['schema']) == 3 #3 properties
241 | assert list(output['schema'].keys())[2] == 'title' #Last one is 'title'
242 | assert list(output['schema'].values())[0] == {
243 | 'type': 'text',
244 | 'name': 'Awoo'
245 | }
246 | assert list(output['schema'].values())[1] == {
247 | 'type': 'text',
248 | 'name': 'Awooo'
249 | }
250 | assert list(output['schema'].values())[2] == {
251 | 'type': 'title',
252 | 'name': 'Awoooo'
253 | }
254 |
255 | assert isinstance(output['rows'], list)
256 | assert len(output['rows']) == 2 #2 rows
257 | assert output['rows'][0] == ['Test100', 'Test200', 'Test300']
258 | assert output['rows'][1] == ['', 'Test400', '']
259 |
260 | def test_nested_list():
261 | '''it should render nested lists'''
262 | #arrange/act
263 | output = mistletoe.markdown(\
264 | """
265 | * Awoo
266 | * Hewwo
267 | """, NotionPyRenderer)
268 |
269 | #assert
270 | assert len(output) == 1
271 | output = output[0]
272 | assert isinstance(output, dict)
273 | assert output['type'] == notion.block.BulletedListBlock
274 | assert output['title'] == 'Awoo'
275 |
276 | assert len(output['children']) == 1
277 | outputChild = output['children'][0]
278 | assert isinstance(outputChild, dict)
279 | assert outputChild['type'] == notion.block.BulletedListBlock
280 | assert outputChild['title'] == 'Hewwo'
281 |
282 | def test_code_block_with_language():
283 | '''it should render a fenced code block with explicit language'''
284 | #arrange/act
285 | raw =\
286 | """\
287 | ```python
288 | def get_favorite_fruit():
289 | return Watermelon
290 | ```"""
291 | expected = "def get_favorite_fruit():\n return Watermelon\n"
292 | output = mistletoe.markdown(raw, NotionPyRenderer)
293 |
294 | #assert
295 | assert len(output) == 1
296 | output = output[0]
297 | assert isinstance(output, dict)
298 | assert output['type'] == notion.block.CodeBlock
299 | assert output['title_plaintext'] == expected
300 | assert output['language'] == 'Python'
301 |
302 | def test_code_block_without_language():
303 | '''it should render a fenced code block with no language specified'''
304 | #arrange/act
305 | raw =\
306 | """\
307 | ```
308 | (f_ my_made_up_language a b)!
309 | ```"""
310 | expected = "(f_ my_made_up_language a b)!\n"
311 | output = mistletoe.markdown(raw, NotionPyRenderer)
312 |
313 | #assert
314 | assert len(output) == 1
315 | output = output[0]
316 | assert isinstance(output, dict)
317 | assert output['type'] == notion.block.CodeBlock
318 | assert output['title_plaintext'] == expected
319 | assert output['language'] == "Plain Text"
320 |
321 | def test_big_file():
322 | '''it should be able to render a full Markdown file'''
323 | #arrange/act
324 | #TODO: For now we just test that this doesn't file, not that it's correct
325 | mistletoe.markdown(open("tests/COMPREHENSIVE_TEST.md", "r", encoding="utf-8").read(), NotionPyRenderer)
326 |
--------------------------------------------------------------------------------
/tests/test_upload.py:
--------------------------------------------------------------------------------
1 | '''
2 | Tests NotionPyRenderer parsing
3 | '''
4 | import pytest
5 | from pathlib import Path
6 | import re
7 | import notion
8 | import sys
9 | from io import IOBase
10 | from md2notion.upload import filesFromPathsUrls, uploadBlock, cli, relativePathForMarkdownUrl
11 | from notion.block import TextBlock, ImageBlock, CollectionViewBlock, PageBlock
12 | from unittest.mock import Mock, patch, call
13 |
14 | def test_filesFromPathUrl_with_file():
15 | '''it can get a file name, path, and file object from a file'''
16 | #arrange/act
17 | filePath, fileName, file = next(filesFromPathsUrls(['tests/TEST.md']))
18 |
19 | #assert
20 | assert fileName == 'TEST.md'
21 | assert filePath == 'tests/TEST.md'
22 | assert isinstance(file, IOBase)
23 |
24 | def test_filesFromPathUrl_with_glob():
25 | '''it can get a file name, path, and file object from a file'''
26 | #arrange/act
27 | tuples = list(filesFromPathsUrls(['tests/TES*.md']))
28 |
29 | #assert
30 | assert len(tuples) == 1
31 |
32 | def test_filesFromPathUrl_with_url():
33 | '''it can get a file name, path, and file object from a file'''
34 | #arrange/act
35 | filePath, fileName, file = next(filesFromPathsUrls(['https://raw.githubusercontent.com/Cobertos/md2notion/master/README.md']))
36 |
37 | #assert
38 | assert fileName == 'README.md'
39 | assert filePath == 'https://raw.githubusercontent.com/Cobertos/md2notion/master/README.md'
40 | assert isinstance(file, IOBase)
41 |
42 | def test_relativePathForMarkdownUrl():
43 | '''gets relative path for simple file'''
44 | #arrange/act
45 | relPath = relativePathForMarkdownUrl('TEST_IMAGE.png', 'tests/TEST.md')
46 |
47 | #assert
48 | assert relPath == Path('tests/TEST_IMAGE.png')
49 |
50 | def test_relativePathForMarkdownUrl_http_url():
51 | '''gets relative path for simple file'''
52 | #arrange/act
53 | relPath = relativePathForMarkdownUrl('http://cobertos.com/non_exist.png', 'tests/TEST.md')
54 |
55 | #assert
56 | assert relPath == None
57 |
58 | def test_relativePathForMarkdownUrl_file_url():
59 | '''gets relative path for a url beginning with file://'''
60 | #arrange/act
61 | relPath = relativePathForMarkdownUrl('file://TEST%20IMAGE%20HAS%20SPACES.png', 'tests/TEST.md')
62 |
63 | #assert
64 | assert relPath == Path('tests/TEST IMAGE HAS SPACES.png')
65 |
66 | def test_relativePathForMarkdownUrl_encoded():
67 | '''gets relative path for a path that has encoding (which is kind of wonky by we'll support it)'''
68 | #arrange/act
69 | relPath = relativePathForMarkdownUrl('TEST%20IMAGE%20HAS%20SPACES.png', 'tests/TEST.md')
70 |
71 | #assert
72 | assert relPath == Path('tests/TEST IMAGE HAS SPACES.png')
73 |
74 | def test_relativePathForMarkdownUrl_non_exist():
75 | '''gets relative path for a file that doesn't exist should return None'''
76 | #arrange/act
77 | relPath = relativePathForMarkdownUrl('NON_EXIST.png', 'tests/TEST.md')
78 |
79 | #assert
80 | assert relPath == None
81 |
82 | def test_uploadBlock():
83 | '''uploads a simple block to Notion using add_new'''
84 | #arrange
85 | blockDescriptor = {
86 | 'type': TextBlock,
87 | 'title': 'This is a test of the test system'
88 | }
89 | notionBlock = Mock()
90 | notionBlock.children.add_new = Mock()
91 |
92 | #act
93 | uploadBlock(blockDescriptor, notionBlock, '')
94 |
95 | #assert
96 | notionBlock.children.add_new.assert_called_with(TextBlock, title='This is a test of the test system')
97 |
98 | def test_uploadBlock_image():
99 | '''uploads an external image block to Notion without uploading'''
100 | #arrange
101 | blockDescriptor = {
102 | 'type': ImageBlock,
103 | 'title': 'test',
104 | 'source': 'https://example.com'
105 | }
106 | notionBlock = Mock()
107 | newBlock = Mock(spec=blockDescriptor['type'])
108 | notionBlock.children.add_new = Mock(return_value=newBlock)
109 |
110 | #act
111 | uploadBlock(blockDescriptor, notionBlock, '')
112 |
113 | #assert
114 | notionBlock.children.add_new.assert_called_with(ImageBlock, title='test', source='https://example.com')
115 | newBlock.upload_file.assert_not_called()
116 |
117 | def test_uploadBlock_image_local():
118 | '''uploads an Image block with local image to Notion'''
119 | #arrange
120 | blockDescriptor = {
121 | 'type': ImageBlock,
122 | 'title': 'test',
123 | 'source': 'TEST_IMAGE.png'
124 | }
125 | notionBlock = Mock()
126 | notionBlock.children.add_new.return_value = newBlock = Mock(spec=blockDescriptor['type'])
127 |
128 | #act
129 | uploadBlock(blockDescriptor, notionBlock, 'tests/DUMMY.md')
130 |
131 | #assert
132 | notionBlock.children.add_new.assert_called_with(ImageBlock, title='test', source='TEST_IMAGE.png')
133 | newBlock.upload_file.assert_called_with(str(Path('tests/TEST_IMAGE.png')))
134 |
135 | def test_uploadBlock_image_local_file_scheme_url_encoded():
136 | '''uploads an Image block with local image to Notion if it has a file:// scheme'''
137 | #arrange
138 | blockDescriptor = {
139 | 'type': ImageBlock,
140 | 'title': 'test',
141 | 'source': 'file://TEST%20IMAGE%20HAS%20SPACES.png'
142 | }
143 | notionBlock = Mock()
144 | notionBlock.children.add_new.return_value = newBlock = Mock(spec=blockDescriptor['type'])
145 |
146 | #act
147 | uploadBlock(blockDescriptor, notionBlock, 'tests/DUMMY.md')
148 |
149 | #assert
150 | notionBlock.children.add_new.assert_called_with(ImageBlock, title='test', source='file://TEST%20IMAGE%20HAS%20SPACES.png')
151 | newBlock.upload_file.assert_called_with(str(Path('tests/TEST IMAGE HAS SPACES.png')))
152 |
153 | def test_uploadBlock_image_local_img_func():
154 | '''uploads an Image block with local image to Notion with a special transform'''
155 | #arrange
156 | blockDescriptor = {
157 | 'type': ImageBlock,
158 | 'title': 'test',
159 | 'source': 'NONEXIST_IMAGE.png'
160 | }
161 | notionBlock = Mock()
162 | notionBlock.children.add_new.return_value = newBlock = Mock(spec=blockDescriptor['type'])
163 | imagePathFunc = Mock(return_value=Path('tests/TEST_IMAGE.png'))
164 |
165 | #act
166 | uploadBlock(blockDescriptor, notionBlock, 'tests/DUMMY.md', imagePathFunc=imagePathFunc)
167 |
168 | #assert
169 | imagePathFunc.assert_called_with('NONEXIST_IMAGE.png', 'tests/DUMMY.md')
170 | notionBlock.children.add_new.assert_called_with(ImageBlock, title='test', source='NONEXIST_IMAGE.png')
171 | newBlock.upload_file.assert_called_with(str(Path('tests/TEST_IMAGE.png')))
172 |
173 | def test_uploadBlock_collection():
174 | #arrange
175 | blockDescriptor = {
176 | 'type': CollectionViewBlock,
177 | 'schema': {
178 | 'J=}2': {
179 | 'type': 'text',
180 | 'name': 'Awoooo'
181 | },
182 | 'J=}x': {
183 | 'type': 'text',
184 | 'name': 'Awooo'
185 | },
186 | 'title': {
187 | 'type': 'text',
188 | 'name': 'Awoo'
189 | }
190 | },
191 | 'rows': [
192 | ['Test100', 'Test200', 'Test300'],
193 | ['', 'Test400', '']
194 | ]
195 | }
196 | schema = blockDescriptor['schema']
197 | rows = blockDescriptor['rows']
198 | notionBlock = Mock()
199 | newBlock = Mock(spec=blockDescriptor['type'])
200 | notionBlock.children.add_new = Mock(return_value=newBlock)
201 |
202 | collection = Mock()
203 | notionBlock._client.create_record = Mock(return_value=collection)
204 | notionBlock._client.get_collection = Mock(return_value=collection)
205 |
206 | #act
207 | uploadBlock(blockDescriptor, notionBlock, '')
208 |
209 | #assert
210 | notionBlock.children.add_new.assert_called_with(CollectionViewBlock)
211 | notionBlock._client.create_record.assert_called_with("collection", parent=newBlock, schema=schema)
212 | notionBlock._client.get_collection.assert_called_with(collection)
213 | #TODO: This is incomplete...
214 |
215 | def MockClient():
216 | #No-op, seal doesn't exist in Python 3.6
217 | if sys.version_info >= (3,7,0):
218 | from unittest.mock import seal
219 | else:
220 | seal = lambda x: x
221 | notionClient = Mock()
222 | notionClient.return_value = notionClient
223 | getBlock = Mock(spec=PageBlock)
224 | class MockNodeList(list):
225 | def add_new(self, t, title=None):
226 | m = Mock(spec=t)
227 | def remove():
228 | self.remove(m)
229 | return None
230 | m.remove = Mock(return_value=None, side_effect=remove)
231 | m.title = title
232 | seal(m)
233 | self.append(m)
234 | return m
235 | getBlock.children = MockNodeList()
236 | getBlock.title = Mock(return_value="")
237 | notionClient.get_block = Mock(return_value=getBlock)
238 | seal(getBlock)
239 | seal(notionClient)
240 | return notionClient
241 |
242 | @patch('md2notion.upload.NotionClient', new_callable=MockClient)
243 | def test_cli_no_arguments(mockClient):
244 | '''should error when nothing is passed'''
245 | #act/assert
246 | with pytest.raises(SystemExit):
247 | cli([])
248 |
249 | @patch('md2notion.upload.upload')
250 | @patch('md2notion.upload.NotionClient', new_callable=MockClient)
251 | def test_cli_create_single_page(mockClient, upload):
252 | '''should create a single page'''
253 | #act
254 | cli(['token_v2', 'page_url', 'tests/TEST.md'])
255 |
256 | #assert
257 | #Should've been called with a file and the passed block
258 | args0, kwargs0 = upload.call_args
259 | assert isinstance(args0[0], IOBase)
260 | assert args0[0].name == 'tests/TEST.md'
261 | assert args0[1] == mockClient.get_block.return_value.children[0]
262 | assert args0[1].title == 'TEST.md'
263 |
264 | @patch('md2notion.upload.upload')
265 | @patch('md2notion.upload.NotionClient', new_callable=MockClient)
266 | def test_cli_create_multiple_pages(mockClient, upload):
267 | '''should create multiple pages'''
268 | #act
269 | cli(['token_v2', 'page_url', 'tests/TEST.md', 'tests/COMPREHENSIVE_TEST.md'])
270 | args0, kwargs0 = upload.call_args_list[0]
271 | assert isinstance(args0[0], IOBase)
272 | assert args0[0].name == 'tests/TEST.md'
273 | assert args0[1] == mockClient.get_block.return_value.children[0]
274 | assert args0[1].title == 'TEST.md'
275 | args1, kwargs1 = upload.call_args_list[1]
276 | assert isinstance(args1[0], IOBase)
277 | assert args1[0].name == 'tests/COMPREHENSIVE_TEST.md'
278 | assert args1[1] == mockClient.get_block.return_value.children[1]
279 | assert args1[1].title == 'COMPREHENSIVE_TEST.md'
280 |
281 | @patch('md2notion.upload.upload')
282 | @patch('md2notion.upload.NotionClient', new_callable=MockClient)
283 | def test_cli_append(mockClient, upload):
284 | '''should append when using that flag'''
285 | #act
286 | cli(['token_v2', 'page_url', 'tests/TEST.md', '--append'])
287 |
288 | #assert
289 | #Should've been called with a file and the passed block
290 | args0, kwargs0 = upload.call_args
291 | assert isinstance(args0[0], IOBase)
292 | assert args0[0].name == 'tests/TEST.md'
293 | assert args0[1] == mockClient.get_block.return_value
294 |
295 | @patch('md2notion.upload.upload')
296 | @patch('md2notion.upload.NotionClient', new_callable=MockClient)
297 | def test_cli_clear_previous(mockClient, upload):
298 | '''should clear previously title pages with the same name when passed that flag'''
299 | #arrange
300 | testNoBlock = mockClient.get_block().children.add_new(PageBlock, title='NO_TEST.md')
301 | testBlock = mockClient.get_block().children.add_new(PageBlock, title='TEST.md')
302 |
303 | #act
304 | cli(['token_v2', 'page_url', 'tests/TEST.md', '--clear-previous'])
305 |
306 | #assert
307 | testNoBlock.remove.assert_not_called()
308 | testBlock.remove.assert_called_with()
309 | args0, kwargs0 = upload.call_args
310 | assert isinstance(args0[0], IOBase)
311 | assert args0[0].name == 'tests/TEST.md'
312 | assert args0[1] == mockClient.get_block.return_value.children[1]
313 | assert args0[1].title == 'TEST.md'
314 |
315 | @patch('md2notion.upload.upload')
316 | @patch('md2notion.upload.NotionClient', new_callable=MockClient)
317 | def test_cli_html_img_tag(mockClient, upload):
318 | '''should enable the extension'''
319 |
320 | #act
321 | cli(['token_v2', 'page_url', 'tests/TEST.md', '--append', '--html-img'])
322 |
323 | #assert
324 | args0, kwargs0 = upload.call_args
325 | renderer = args0[3]()
326 | assert "HTMLSpan" in renderer.render_map
327 | assert "HTMLBlock" in renderer.render_map
328 |
329 | @patch('md2notion.upload.upload')
330 | @patch('md2notion.upload.NotionClient', new_callable=MockClient)
331 | def test_cli_latex(mockClient, upload):
332 | '''should enable the extension'''
333 |
334 | #act
335 | cli(['token_v2', 'page_url', 'tests/TEST.md', '--append', '--latex'])
336 |
337 | #assert
338 | args0, kwargs0 = upload.call_args
339 | renderer = args0[3]()
340 | assert "InlineEquation" in renderer.render_map
341 | assert "BlockEquation" in renderer.render_map
342 |
--------------------------------------------------------------------------------