many many many Varia's websites, work in progress: https://many.vvvvvvaria.org
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

251 lines
8.6 KiB

"""
test_collate_content.py
=======================
(c) 2014 - Edward J. Stronge
Tests for the collate_content module
"""
from collections import defaultdict, namedtuple
import os
import random
import tempfile
import shutil
import string
import unittest
from pelican import Pelican
from pelican import ArticlesGenerator, PagesGenerator
from pelican.settings import read_settings
import collate_content as cc
TEMP_PAGE_TEMPLATE = """Title: {title}
Category: {category}
"""
Content = namedtuple('Content', ['title', 'path', 'category'])
# Characters likely to appear in blog titles/categories. Could eventually
# extend support to more characters that can't appear in a Python identifier
BLOG_CHARACTERS = string.letters + ' -:'
def make_content(directory, categories, count=5, categories_per_content=1):
"""
make_content --> {(processed_category, original_category): articles, ...}
Writes random titles and categories into `count` temporary
files in `directory`. If desired, specify `categories_per_content`
to assign multiple categories to each written file.
Returns a dictionary whose keys are in `categories` with values
that are (title, path, category) tuples for the generated
content files.
"""
new_content = defaultdict(list)
for _ in range(count):
title = get_random_text_and_whitespace()
category_choice = random.sample(categories, categories_per_content)
categories_string = ', '.join(category_choice)
output = TEMP_PAGE_TEMPLATE.format(
title=title, category=categories_string)
with tempfile.NamedTemporaryFile(
dir=directory, mode='w', suffix='.md', delete=False) as tmp:
tmp.write(output)
path = os.path.join(directory, tmp.name)
for each_cat in category_choice:
new_content[(cc.substitute_category_name(each_cat), each_cat)]\
.append(Content(title, path, categories_string))
return new_content
def get_random_text_and_whitespace(length=10):
"""
Returns at most `length` randomly-generated letters and/or
whitespace. The returned string will not begin or end in whitespace.
"""
return "".join(random.sample(BLOG_CHARACTERS, length)).strip()
def modified_pelican_run(self):
"""Runs the generators and returns the context object
Modified from the Pelican object's run methods.
"""
context = self.settings.copy()
context['filenames'] = {} # share the dict between all the generators
context['localsiteurl'] = self.settings['SITEURL'] # share
generators = [
cls(
context=context,
settings=self.settings,
path=self.path,
theme=self.theme,
output_path=self.output_path,
) for cls in self.get_generator_classes()
]
for p in generators:
if hasattr(p, 'generate_context'):
p.generate_context()
writer = self.get_writer()
for p in generators:
if hasattr(p, 'generate_output'):
p.generate_output(writer)
next(g for g in generators if isinstance(g, ArticlesGenerator))
next(g for g in generators if isinstance(g, PagesGenerator))
return context
class ContentCollationTester(unittest.TestCase):
"""Test generation of lists of content based on their Category metadata"""
def setUp(self, settings_overrides=None, count=5,
categories_per_content=1, categories=None):
self.temp_input_dir = tempfile.mkdtemp(prefix="cc-input-")
page_directory = os.path.join(self.temp_input_dir, 'pages')
os.mkdir(page_directory)
self.temp_output_dir = tempfile.mkdtemp(prefix="cc-output-")
if categories is None:
categories = [get_random_text_and_whitespace() for _ in range(5)]
self.articles = make_content(
self.temp_input_dir, categories, count=count,
categories_per_content=categories_per_content)
self.pages = make_content(
page_directory, categories, count=count,
categories_per_content=categories_per_content)
settings = {
'PATH': self.temp_input_dir,
'PAGE_DIR': 'pages',
'OUTPUT_PATH': self.temp_output_dir,
'PLUGINS': [cc],
'DEFAULT_DATE': (2014, 6, 8),
}
if settings_overrides is not None:
settings.update(settings_overrides)
settings = read_settings(override=settings)
pelican = Pelican(settings=settings)
pelican.modified_run = modified_pelican_run
self.collations = pelican.modified_run(pelican)['collations']
def tearDown(self):
shutil.rmtree(self.temp_input_dir)
shutil.rmtree(self.temp_output_dir)
class TestCollation(ContentCollationTester):
"""Test generation of lists of content based on their Category metadata"""
def test_articles_with_one_category(self):
for substituted_category, original_category in self.articles.keys():
collation_key = '%s_articles' % substituted_category
self.assertIn(collation_key, self.collations)
collated_titles = [a.title for a in self.collations[collation_key]]
for title, _, _ in self.articles[
(substituted_category, original_category)]:
self.assertIn(title, collated_titles)
def test_pages_with_one_category(self):
for substituted_category, original_category in self.pages.keys():
collation_key = '%s_pages' % substituted_category
self.assertIn(collation_key, self.collations)
collated_titles = [a.title for a in self.collations[collation_key]]
for title, _, _ in self.pages[
(substituted_category, original_category)]:
self.assertIn(title, collated_titles)
class TestCollationAndMultipleCategories(TestCollation):
"""
Test collate_content with multiple categories specified in each
article and each page.
"""
def setUp(self):
categories = [get_random_text_and_whitespace() for _ in range(5)]
ContentCollationTester.setUp(
self, categories=categories, categories_per_content=3)
class TestFilteredCategories(ContentCollationTester):
"""
Test collate_content with the `CATEGORIES_TO_COLLATE` setting
in effect
"""
def setUp(self):
categories = [get_random_text_and_whitespace() for _ in range(5)]
self.retained_categories = categories[:2]
override = {'CATEGORIES_TO_COLLATE': self.retained_categories}
ContentCollationTester.setUp(
self, settings_overrides=override, categories=categories)
def test_articles_with_one_category_after_filtering(self):
for substituted_category, original_category in self.articles.keys():
collation_key = '%s_articles' % substituted_category
if original_category not in self.retained_categories:
self.assertNotIn(collation_key, self.collations)
continue
self.assertIn(collation_key, self.collations)
collated_titles = [a.title for a in self.collations[collation_key]]
for title, _, _ in self.articles[
(substituted_category, original_category)]:
self.assertIn(title, collated_titles)
def test_pages_with_one_category_after_filtering(self):
for substituted_category, original_category in self.pages.keys():
collation_key = '%s_pages' % substituted_category
if original_category not in self.retained_categories:
self.assertNotIn(collation_key, self.collations)
continue
self.assertIn(collation_key, self.collations)
collated_titles = [a.title for a in self.collations[collation_key]]
for title, _, _ in self.pages[
(substituted_category, original_category)]:
self.assertIn(title, collated_titles)
class TestFilteredAndMultipleCategories(TestFilteredCategories):
"""
Test collate_content with the `CATEGORIES_TO_COLLATE` setting
in effect as well as with multiple categories specified in each
article and each page.
"""
def setUp(self):
categories = [get_random_text_and_whitespace() for _ in range(5)]
self.retained_categories = categories[:2]
override = {'CATEGORIES_TO_COLLATE': self.retained_categories}
ContentCollationTester.setUp(
self, settings_overrides=override, categories=categories,
categories_per_content=3)
if __name__ == '__main__':
suite = unittest.TestLoader().loadTestsFromNames(['test_collate_content'])
unittest.TextTestRunner(verbosity=1).run(suite)