forked from github.com/blag
322 lines
8.7 KiB
Python
322 lines
8.7 KiB
Python
# remove when we don't support py38 anymore
|
|
from __future__ import annotations
|
|
from tempfile import TemporaryDirectory
|
|
import os
|
|
from datetime import datetime
|
|
from typing import Any
|
|
from argparse import Namespace
|
|
|
|
import pytest
|
|
from pytest import CaptureFixture, LogCaptureFixture
|
|
from jinja2 import Template
|
|
|
|
from blag import __VERSION__
|
|
from blag import blag
|
|
|
|
|
|
def test_generate_feed(cleandir: str) -> None:
|
|
articles: list[tuple[str, dict[str, Any]]] = []
|
|
blag.generate_feed(articles, 'build', ' ', ' ', ' ', ' ')
|
|
assert os.path.exists('build/atom.xml')
|
|
|
|
|
|
def test_feed(cleandir: str) -> None:
|
|
articles: list[tuple[str, dict[str, Any]]] = [
|
|
(
|
|
'dest1.html',
|
|
{
|
|
'title': 'title1',
|
|
'date': datetime(2019, 6, 6),
|
|
'content': 'content1',
|
|
},
|
|
),
|
|
(
|
|
'dest2.html',
|
|
{
|
|
'title': 'title2',
|
|
'date': datetime(1980, 5, 9),
|
|
'content': 'content2',
|
|
},
|
|
),
|
|
]
|
|
|
|
blag.generate_feed(
|
|
articles,
|
|
'build',
|
|
'https://example.com/',
|
|
'blog title',
|
|
'blog description',
|
|
'blog author',
|
|
)
|
|
with open('build/atom.xml') as fh:
|
|
feed = fh.read()
|
|
|
|
assert '<title>blog title</title>' in feed
|
|
# enable when https://github.com/getpelican/feedgenerator/issues/22
|
|
# is fixed
|
|
# assert '<subtitle>blog description</subtitle>' in feed
|
|
assert '<author><name>blog author</name></author>' in feed
|
|
|
|
# article 1
|
|
assert '<title>title1</title>' in feed
|
|
assert '<summary type="html">title1' in feed
|
|
assert '<published>2019-06-06' in feed
|
|
assert '<content type="html">content1' in feed
|
|
assert '<link href="https://example.com/dest1.html"' in feed
|
|
|
|
# article 2
|
|
assert '<title>title2</title>' in feed
|
|
assert '<summary type="html">title2' in feed
|
|
assert '<published>1980-05-09' in feed
|
|
assert '<content type="html">content2' in feed
|
|
assert '<link href="https://example.com/dest2.html"' in feed
|
|
|
|
|
|
def test_generate_feed_with_description(cleandir: str) -> None:
|
|
# if a description is provided, it will be used as the summary in
|
|
# the feed, otherwise we simply use the title of the article
|
|
articles: list[tuple[str, dict[str, Any]]] = [
|
|
(
|
|
'dest.html',
|
|
{
|
|
'title': 'title',
|
|
'description': 'description',
|
|
'date': datetime(2019, 6, 6),
|
|
'content': 'content',
|
|
},
|
|
)
|
|
]
|
|
blag.generate_feed(articles, 'build', ' ', ' ', ' ', ' ')
|
|
|
|
with open('build/atom.xml') as fh:
|
|
feed = fh.read()
|
|
|
|
assert '<title>title</title>' in feed
|
|
assert '<summary type="html">description' in feed
|
|
assert '<published>2019-06-06' in feed
|
|
assert '<content type="html">content' in feed
|
|
|
|
|
|
def test_parse_args_build() -> None:
|
|
# test default args
|
|
args = blag.parse_args(['build'])
|
|
assert args.input_dir == 'content'
|
|
assert args.output_dir == 'build'
|
|
assert args.template_dir == 'templates'
|
|
assert args.static_dir == 'static'
|
|
|
|
# input dir
|
|
args = blag.parse_args(['build', '-i', 'foo'])
|
|
assert args.input_dir == 'foo'
|
|
args = blag.parse_args(['build', '--input-dir', 'foo'])
|
|
assert args.input_dir == 'foo'
|
|
|
|
# output dir
|
|
args = blag.parse_args(['build', '-o', 'foo'])
|
|
assert args.output_dir == 'foo'
|
|
args = blag.parse_args(['build', '--output-dir', 'foo'])
|
|
assert args.output_dir == 'foo'
|
|
|
|
# template dir
|
|
args = blag.parse_args(['build', '-t', 'foo'])
|
|
assert args.template_dir == 'foo'
|
|
args = blag.parse_args(['build', '--template-dir', 'foo'])
|
|
assert args.template_dir == 'foo'
|
|
|
|
# static dir
|
|
args = blag.parse_args(['build', '-s', 'foo'])
|
|
assert args.static_dir == 'foo'
|
|
args = blag.parse_args(['build', '--static-dir', 'foo'])
|
|
assert args.static_dir == 'foo'
|
|
|
|
|
|
def test_get_config() -> None:
|
|
config = """
|
|
[main]
|
|
base_url = https://example.com/
|
|
title = title
|
|
description = description
|
|
author = a. u. thor
|
|
"""
|
|
# happy path
|
|
with TemporaryDirectory() as dir:
|
|
configfile = f'{dir}/config.ini'
|
|
with open(configfile, 'w') as fh:
|
|
fh.write(config)
|
|
|
|
config_parsed = blag.get_config(configfile)
|
|
assert config_parsed['base_url'] == 'https://example.com/'
|
|
assert config_parsed['title'] == 'title'
|
|
assert config_parsed['description'] == 'description'
|
|
assert config_parsed['author'] == 'a. u. thor'
|
|
|
|
# a missing required config causes a sys.exit
|
|
for x in 'base_url', 'title', 'description', 'author':
|
|
config2 = '\n'.join(
|
|
[line for line in config.splitlines() if not line.startswith(x)]
|
|
)
|
|
with TemporaryDirectory() as dir:
|
|
configfile = f'{dir}/config.ini'
|
|
with open(configfile, 'w') as fh:
|
|
fh.write(config2)
|
|
with pytest.raises(SystemExit):
|
|
config_parsed = blag.get_config(configfile)
|
|
|
|
# base_url gets / appended if it is missing
|
|
config = """
|
|
[main]
|
|
base_url = https://example.com
|
|
title = title
|
|
description = description
|
|
author = a. u. thor
|
|
"""
|
|
with TemporaryDirectory() as dir:
|
|
configfile = f'{dir}/config.ini'
|
|
with open(configfile, 'w') as fh:
|
|
fh.write(config)
|
|
|
|
config_parsed = blag.get_config(configfile)
|
|
assert config_parsed['base_url'] == 'https://example.com/'
|
|
|
|
|
|
def test_environment_factory() -> None:
|
|
globals_: dict[str, object] = {'foo': 'bar', 'test': 'me'}
|
|
env = blag.environment_factory(globals_=globals_)
|
|
assert env.globals['foo'] == 'bar'
|
|
assert env.globals['test'] == 'me'
|
|
|
|
|
|
def test_process_markdown(
|
|
cleandir: str,
|
|
page_template: Template,
|
|
article_template: Template,
|
|
) -> None:
|
|
page1 = """\
|
|
title: some page
|
|
|
|
some text
|
|
foo bar
|
|
"""
|
|
|
|
article1 = """\
|
|
title: some article1
|
|
date: 2020-01-01
|
|
|
|
some text
|
|
foo bar
|
|
"""
|
|
|
|
article2 = """\
|
|
title: some article2
|
|
date: 2021-01-01
|
|
|
|
some text
|
|
foo bar
|
|
"""
|
|
|
|
convertibles = []
|
|
for i, txt in enumerate((page1, article1, article2)):
|
|
with open(f'content/{str(i)}', 'w') as fh:
|
|
fh.write(txt)
|
|
convertibles.append((str(i), str(i)))
|
|
|
|
articles, pages = blag.process_markdown(
|
|
convertibles, 'content', 'build', page_template, article_template
|
|
)
|
|
|
|
assert isinstance(articles, list)
|
|
assert len(articles) == 2
|
|
for dst, context in articles:
|
|
assert isinstance(dst, str)
|
|
assert isinstance(context, dict)
|
|
assert 'content' in context
|
|
|
|
assert isinstance(pages, list)
|
|
assert len(pages) == 1
|
|
for dst, context in pages:
|
|
assert isinstance(dst, str)
|
|
assert isinstance(context, dict)
|
|
assert 'content' in context
|
|
|
|
|
|
def test_build(args: Namespace) -> None:
|
|
page1 = """\
|
|
title: some page
|
|
|
|
some text
|
|
foo bar
|
|
"""
|
|
|
|
article1 = """\
|
|
title: some article1
|
|
date: 2020-01-01
|
|
tags: foo, bar
|
|
|
|
some text
|
|
foo bar
|
|
"""
|
|
|
|
article2 = """\
|
|
title: some article2
|
|
date: 2021-01-01
|
|
tags: baz
|
|
|
|
some text
|
|
foo bar
|
|
"""
|
|
|
|
# write some convertibles
|
|
convertibles = []
|
|
for i, txt in enumerate((page1, article1, article2)):
|
|
with open(f'{args.input_dir}/{str(i)}.md', 'w') as fh:
|
|
fh.write(txt)
|
|
convertibles.append((str(i), str(i)))
|
|
|
|
# some static files
|
|
with open(f'{args.static_dir}/test', 'w') as fh:
|
|
fh.write('hello')
|
|
|
|
os.mkdir(f'{args.input_dir}/testdir')
|
|
with open(f'{args.input_dir}/testdir/test', 'w') as fh:
|
|
fh.write('hello')
|
|
|
|
blag.build(args)
|
|
|
|
# test existence of the three converted files
|
|
for i in range(3):
|
|
assert os.path.exists(f'{args.output_dir}/{i}.html')
|
|
# ... static file
|
|
assert os.path.exists(f'{args.output_dir}/test')
|
|
# ... directory
|
|
assert os.path.exists(f'{args.output_dir}/testdir/test')
|
|
# ... feed
|
|
assert os.path.exists(f'{args.output_dir}/atom.xml')
|
|
# ... archive
|
|
assert os.path.exists(f'{args.output_dir}/index.html')
|
|
# ... tags
|
|
assert os.path.exists(f'{args.output_dir}/tags/index.html')
|
|
assert os.path.exists(f'{args.output_dir}/tags/foo.html')
|
|
assert os.path.exists(f'{args.output_dir}/tags/bar.html')
|
|
|
|
|
|
def test_main(cleandir: str) -> None:
|
|
blag.main(['build'])
|
|
|
|
|
|
def test_cli_version(capsys: CaptureFixture[str]) -> None:
|
|
with pytest.raises(SystemExit) as ex:
|
|
blag.main(['--version'])
|
|
# normal system exit
|
|
assert ex.value.code == 0
|
|
# proper version reported
|
|
out, _ = capsys.readouterr()
|
|
assert __VERSION__ in out
|
|
|
|
|
|
def test_cli_verbose(cleandir: str, caplog: LogCaptureFixture) -> None:
|
|
blag.main(['build'])
|
|
assert 'DEBUG' not in caplog.text
|
|
|
|
blag.main(['--verbose', 'build'])
|
|
assert 'DEBUG' in caplog.text
|