ChatMastermind/tests/test_glossary_cmd.py

import unittest
import argparse
import tempfile
import io
from contextlib import redirect_stdout
from chatmastermind.configuration import Config
from chatmastermind.commands.glossary import (
    Glossary,
    GlossaryCmdError,
    glossary_cmd,
    get_glossary_file_path,
    create_glossary,
    print_glossary,
    list_glossaries
)


class TestGlossaryCmdNoGlossaries(unittest.TestCase):

    def setUp(self) -> None:
        # create DB and cache
        self.db_dir = tempfile.TemporaryDirectory()
        self.cache_dir = tempfile.TemporaryDirectory()
        self.glossaries_dir = tempfile.TemporaryDirectory()
        # create configuration
        self.config = Config()
        self.config.cache = self.cache_dir.name
        self.config.db = self.db_dir.name
        self.config.glossaries = self.glossaries_dir.name
        # create a mock argparse.Namespace
        self.args = argparse.Namespace(
            create=True,
            list=False,
            print=False,
            name='new_glossary',
            file=None,
            source_lang='en',
            target_lang='de',
            description=False,
        )

    def test_glossary_create_no_glossaries_err(self) -> None:
        self.config.glossaries = None
        with self.assertRaises(GlossaryCmdError) as err:
            create_glossary(self.args, self.config)
            self.assertIn(str(err.exception).lower(), "glossaries directory missing")

    def test_glossary_create_no_name_err(self) -> None:
        self.args.name = None
        with self.assertRaises(GlossaryCmdError) as err:
            create_glossary(self.args, self.config)
            self.assertIn(str(err.exception).lower(), "missing glossary name")

    def test_glossary_create_no_source_lang_err(self) -> None:
        self.args.source_lang = None
        with self.assertRaises(GlossaryCmdError) as err:
            create_glossary(self.args, self.config)
            self.assertIn(str(err.exception).lower(), "missing source language")

    def test_glossary_create_no_target_lang_err(self) -> None:
        self.args.target_lang = None
        with self.assertRaises(GlossaryCmdError) as err:
            create_glossary(self.args, self.config)
            self.assertIn(str(err.exception).lower(), "missing target language")

    def test_glossary_print_no_name_err(self) -> None:
        self.args.name = None
        with self.assertRaises(GlossaryCmdError) as err:
            print_glossary(self.args, self.config)
            self.assertIn(str(err.exception).lower(), "missing glossary name")

    def test_glossary_list_no_glossaries_err(self) -> None:
        self.config.glossaries = None
        with self.assertRaises(GlossaryCmdError) as err:
            list_glossaries(self.args, self.config)
            self.assertIn(str(err.exception).lower(), "glossaries directory missing")

    def test_glossary_create(self) -> None:
        self.args.create = True
        self.args.list = False
        self.args.print = False
        glossary_cmd(self.args, self.config)
        expected_path = get_glossary_file_path(self.args.name, self.config)
        glo = Glossary.from_file(expected_path)
        self.assertEqual(glo.name, self.args.name)
        expected_path.unlink()

    def test_glossary_create_twice_err(self) -> None:
        self.args.create = True
        self.args.list = False
        self.args.print = False
        glossary_cmd(self.args, self.config)
        expected_path = get_glossary_file_path(self.args.name, self.config)
        glo = Glossary.from_file(expected_path)
        self.assertEqual(glo.name, self.args.name)
        # create glossary with the same name again
        with self.assertRaises(GlossaryCmdError) as err:
            create_glossary(self.args, self.config)
            self.assertIn(str(err.exception).lower(), "already exists")
        expected_path.unlink()


class TestGlossaryCmdWithGlossaries(unittest.TestCase):

    def setUp(self) -> None:
        # create DB and cache
        self.db_dir = tempfile.TemporaryDirectory()
        self.cache_dir = tempfile.TemporaryDirectory()
        self.glossaries_dir = tempfile.TemporaryDirectory()
        # create configuration
        self.config = Config()
        self.config.cache = self.cache_dir.name
        self.config.db = self.db_dir.name
        self.config.glossaries = self.glossaries_dir.name
        # create a mock argparse.Namespace
        self.args = argparse.Namespace(
            create=True,
            list=False,
            print=False,
            name='Glossary1',
            file=None,
            source_lang='en',
            target_lang='de',
            description=False,
        )
        # create Glossary1
        glossary_cmd(self.args, self.config)
        self.Glossary1_path = get_glossary_file_path('Glossary1', self.config)
        # create Glossary2
        self.args.name = 'Glossary2'
        glossary_cmd(self.args, self.config)
        self.Glossary2_path = get_glossary_file_path('Glossary2', self.config)

    def test_glossaries_exist(self) -> None:
        """
        Test if the default glossaries created in setUp exist.
        """
        glo = Glossary.from_file(self.Glossary1_path)
        self.assertEqual(glo.name, 'Glossary1')
        glo = Glossary.from_file(self.Glossary2_path)
        self.assertEqual(glo.name, 'Glossary2')

    def test_glossaries_list(self) -> None:
        self.args.create = False
        self.args.list = True
        with redirect_stdout(io.StringIO()) as list_output:
            glossary_cmd(self.args, self.config)
            self.assertIn('Glossary1', list_output.getvalue())
            self.assertIn('Glossary2', list_output.getvalue())