libloot-python/test/test.py

#!/usr/bin/env python

import cProfile
import os
import os.path
import shutil
import sys
import unittest

sys.path.append(os.getcwd())

from loot import Version
from loot import WrapperVersion
from loot import GameType
from loot import SimpleMessage
from loot import MessageType
from loot import PluginCleanliness
from loot import create_game_handle
from loot import is_compatible
from loot import set_logging_callback

def logging_callback(level, message):
    pass

set_logging_callback(logging_callback)

class GameFixture(unittest.TestCase):
    game_path = os.path.join(u'.', u'Oblivion')
    local_path = os.path.join(u'.', u'local')

    def setUp(self):
        data_path = os.path.join(self.game_path, 'Data')
        master_file = os.path.join(data_path, 'Oblivion.esm')

        if not os.path.exists(data_path):
            os.makedirs(data_path)
        open(master_file, 'a').close()

        if not os.path.exists(self.local_path):
            os.makedirs(self.local_path)

    def tearDown(self):
        shutil.rmtree(self.game_path)
        shutil.rmtree(self.local_path)

class TestLootApi(GameFixture):
    def test_is_compatible(self):
        self.assertFalse(is_compatible(0, 9, 0))
        self.assertTrue(is_compatible(0, 15, 0))

    def test_version(self):
        self.assertEqual(Version.major, 0)
        self.assertEqual(Version.minor, 15)
        self.assertEqual(Version.patch, 0)
        self.assertNotEqual(Version.revision, u'')
        self.assertEqual(Version.string(), "0.15.0")

    def test_wrapper_version(self):
        self.assertEqual(WrapperVersion.major, 4)
        self.assertEqual(WrapperVersion.minor, 0)
        self.assertEqual(WrapperVersion.patch, 2)
        self.assertNotEqual(WrapperVersion.revision, u'')
        self.assertNotEqual(WrapperVersion.revision, Version.revision)
        self.assertEqual(WrapperVersion.string(), "4.0.2")

    def test_create_db(self):
        game = create_game_handle(GameType.tes4, self.game_path, self.local_path)
        db = game.get_database()
        self.assertNotEqual(db, None)

class TestDatabaseInterface(GameFixture):
    masterlist_path = os.path.join(os.path.dirname(__file__), u'masterlist.yaml')

    def setUp(self):
        super(TestDatabaseInterface, self).setUp()

        game = create_game_handle(GameType.tes4, self.game_path, self.local_path)
        game.load_current_load_order_state()

        self.db = game.get_database()

    def test_load_lists(self):
        self.db.load_lists(self.masterlist_path, u'')

    def test_get_plugin_tags(self):
        self.db.load_lists(self.masterlist_path, u'')
        tags = self.db.get_plugin_tags(u'Unofficial Oblivion Patch.esp')

        self.assertNotEqual(tags, None)
        self.assertFalse(tags.userlist_modified)
        self.assertEqual(tags.added, set([
            u'Actors.ACBS',
            u'Actors.AIData',
            u'Actors.AIPackages',
            u'Actors.CombatStyle',
            u'Actors.DeathItem',
            u'Actors.Stats',
            u'C.Climate',
            u'C.Light',
            u'C.Music',
            u'C.Name',
            u'C.Owner',
            u'Creatures.Blood',
            u'Delev',
            u'Factions',
            u'Invent',
            u'Names',
            u'NPC.Class',
            u'Relations',
            u'Relev',
            u'Scripts',
            u'Stats'
        ]))
        self.assertEqual(tags.removed, set([u'C.Water']))

    def test_get_plugin_messages(self):
        self.db.load_lists(self.masterlist_path, u'')

        messages = self.db.get_plugin_metadata(u'Oblivion.esm').get_simple_messages(u'en')

        self.assertEqual(len(messages), 1)
        self.assertEqual(messages[0].type, MessageType.error)
        self.assertEqual(messages[0].text, u'This must not be activated. However, it can be useful when porting Oblivion mods to Nehrim.')

    def test_get_plugin_cleanliness_should_be_unknown_if_no_dirty_or_clean_metadata_exists(self):
        self.db.load_lists(self.masterlist_path, u'')

        cleanliness = self.db.get_plugin_cleanliness(u'unknown.esp')

        self.assertEqual(cleanliness, PluginCleanliness.unknown)

    def test_get_plugin_cleanliness_should_be_unknown_if_dirty_and_clean_metadata_exists(self):
        self.db.load_lists(self.masterlist_path, u'')

        cleanliness = self.db.get_plugin_cleanliness(u'clean_and_dirty.esp')

        self.assertEqual(cleanliness, PluginCleanliness.unknown)

    def test_get_plugin_cleanliness_should_be_clean_if_only_clean_metadata_exists(self):
        self.db.load_lists(self.masterlist_path, u'')

        cleanliness = self.db.get_plugin_cleanliness(u'clean.esp')

        self.assertEqual(cleanliness, PluginCleanliness.clean)

    def test_get_plugin_cleanliness_should_be_dirty_if_only_dirty_metadata_exists(self):
        self.db.load_lists(self.masterlist_path, u'')

        cleanliness = self.db.get_plugin_cleanliness(u'dirty.esp')

        self.assertEqual(cleanliness, PluginCleanliness.dirty)

    def test_get_plugin_cleanliness_should_be_do_not_clean_if_dirty_do_not_clean_info_exists(self):
        self.db.load_lists(self.masterlist_path, u'')

        cleanliness = self.db.get_plugin_cleanliness(u'do_not_clean.esp')

        self.assertEqual(cleanliness, PluginCleanliness.do_not_clean)

if __name__ == '__main__':
    unittest.main()