mirror of
https://github.com/venthur/blag.git
synced 2025-11-25 20:52:43 +00:00
c952c574b7
Blag will throw an error if a template is not found locally. The error message contains an explanation for the user on where to get the missing templates. Quickstart will generate templates for the user in the working directory. Updated tests appropriately.
338 lines
9.0 KiB
Python
338 lines
9.0 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(cleandir: str) -> None:
|
|
globals_: dict[str, object] = {'foo': 'bar', 'test': 'me'}
|
|
env = blag.environment_factory("templates", 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')
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
'template',
|
|
[
|
|
'page.html',
|
|
'article.html',
|
|
'archive.html',
|
|
'tags.html',
|
|
'tag.html',
|
|
]
|
|
)
|
|
def test_missing_template_raises(template: str, args: Namespace) -> None:
|
|
os.remove(f'templates/{template}')
|
|
with pytest.raises(SystemExit):
|
|
blag.build(args)
|
|
|
|
|
|
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
|