NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

test_controller.py (9692B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\eve\client\script\ui\shared\skins\test\test_controller.py
      2 import __builtin__
      3 import contextlib
      4 import mock
      5 import unittest
      6 import signals
      7 from testhelpers.evemocks import SMMock
      8 from testsuites.testcases import ClientTestCase
      9 
     10 class MockSkin(object):
     11 
     12     def __init__(self, materialID, skinID = None, licensed = False):
     13         self.materialID = materialID
     14         self.skinID = skinID
     15         self.licensed = licensed
     16 
     17     @property
     18     def material(self):
     19         return str(self.materialID)
     20 
     21     def __eq__(self, other):
     22         if other is None:
     23             return False
     24         return self.materialID == other.materialID and self.skinID == other.skinID and self.licensed == other.licensed
     25 
     26     def __repr__(self):
     27         return '<MockSkin materialID=%s skinID=%s licensed=%s>' % (self.materialID, self.skinID, self.licensed)
     28 
     29 
     30 class MockFittingController(object):
     31 
     32     def __init__(self, itemID, typeID):
     33         self.itemID = itemID
     34         self.typeID = typeID
     35         self.on_new_itemID = signals.Signal(signalName='on_new_itemID')
     36         self.material = None
     37 
     38     def GetItemID(self):
     39         return self.itemID
     40 
     41     def GetTypeID(self):
     42         return self.typeID
     43 
     44     def UpdateItem(self, itemID, typeID):
     45         oldItemID = self.itemID
     46         oldTypeID = self.typeID
     47         self.itemID = itemID
     48         self.typeID = typeID
     49         self.on_new_itemID(self.itemID, oldItemID, self.typeID, oldTypeID)
     50 
     51     def SetSkinMaterial(self, material):
     52         self.material = material
     53 
     54 
     55 class MockLock(object):
     56 
     57     def __init__(self, lock):
     58         self._lock = lock
     59 
     60     def __enter__(self):
     61         self._lock.acquire()
     62 
     63     def __exit__(self, ex_type, ex_value, traceback):
     64         self._lock.release()
     65         return ex_type is None
     66 
     67     @property
     68     def acquire(self):
     69         return self._lock.acquire
     70 
     71     @property
     72     def release(self):
     73         return self._lock.release
     74 
     75 
     76 TYPE_ID = 1
     77 OTHER_TYPE_ID = 2
     78 SKIN_ID = 10
     79 SKIN = MockSkin(materialID=1)
     80 OTHER_SKIN = MockSkin(materialID=2)
     81 LICENSED_SKIN = MockSkin(materialID=1, skinID=20, licensed=True)
     82 OTHER_LICENSED_SKIN = MockSkin(materialID=2, skinID=30, licensed=True)
     83 UNLICENSED_SKIN = MockSkin(materialID=3, licensed=False)
     84 OTHER_UNLICENSED_SKIN = MockSkin(materialID=4, licensed=False)
     85 ITEM_ID = 100
     86 OTHER_ITEM_ID = 200
     87 
     88 class SkinPanelControllerBase(ClientTestCase):
     89 
     90     @classmethod
     91     def setUpClass(cls):
     92         super(SkinPanelControllerBase, cls).setUpClass()
     93         cls.locks_module = mock.Mock()
     94         mock_modules = {'uthread': mock.Mock(),
     95          'locks': cls.locks_module,
     96          'trinity': mock.Mock()}
     97         cls.import_patcher = mock.patch.dict('sys.modules', mock_modules)
     98         cls.import_patcher.start()
     99         from eve.client.script.ui.shared.skins import controller
    100         cls.module = controller
    101 
    102     @classmethod
    103     def tearDownClass(cls):
    104         super(SkinPanelControllerBase, cls).tearDownClass()
    105         cls.import_patcher.stop()
    106 
    107     def setUp(self):
    108         super(SkinPanelControllerBase, self).setUp()
    109         self.lock = MockLock(mock.MagicMock())
    110         self.locks_module.Lock.return_value = self.lock
    111 
    112     def prime_skins_cache(self, cached = None, fresh = None):
    113         cached = cached or []
    114         fresh = fresh or []
    115         self.adapter.GetSkins.return_value = cached
    116         self.controller.skins
    117         self.adapter.GetSkins.return_value = fresh
    118 
    119     def assertSkinState(self, applied = None, pending = None, previewed = None):
    120         if applied is None:
    121             self.assertIsNone(self.controller.applied)
    122         else:
    123             self.assertEqual(self.controller.applied, applied)
    124         if pending is None:
    125             self.assertIsNone(self.controller.pending)
    126         else:
    127             self.assertEqual(self.controller.pending, pending)
    128         if previewed is None:
    129             self.assertIsNone(self.controller.previewed)
    130         else:
    131             self.assertEqual(self.controller.previewed, previewed)
    132 
    133     @contextlib.contextmanager
    134     def assertLockedTransaction(self):
    135         self.lock.acquire.reset_mock()
    136         self.lock.release.reset_mock()
    137         try:
    138             yield
    139         finally:
    140             self.lock.acquire.assert_called_once_with()
    141             self.lock.release.assert_called_once_with()
    142 
    143     @contextlib.contextmanager
    144     def assertNotLockedTransaction(self):
    145         self.lock.acquire.reset_mock()
    146         self.lock.release.reset_mock()
    147         try:
    148             yield
    149         finally:
    150             self.assertFalse(self.lock.acquire.called)
    151             self.assertFalse(self.lock.release.called)
    152 
    153 
    154 class TestSkinPanelController(SkinPanelControllerBase):
    155     SKIN_LIST = [SKIN, OTHER_SKIN]
    156 
    157     def setUp(self):
    158         super(TestSkinPanelController, self).setUp()
    159         self.adapter = mock.Mock(spec=self.module.SkinPanelAdapter)
    160         self.adapter.GetSkins.return_value = self.SKIN_LIST
    161         self.adapter.GetTypesForSkin.return_value = [TYPE_ID]
    162         __builtin__.sm = SMMock()
    163         self.controller = self.module.SkinPanelController(adapter=self.adapter, hullTypeID=TYPE_ID)
    164         self.events = mock.Mock()
    165         self.controller.onChange.connect(self.events.onChange)
    166         self.controller.onSkinsChange.connect(self.events.onSkinsChange)
    167 
    168     def test_initial_state(self):
    169         self.assertEqual(self.controller.typeID, TYPE_ID)
    170         self.assertSkinState(applied=None, previewed=None, pending=None)
    171 
    172     @unittest.skip('test is failing and needs fixing')
    173     def test_change_type(self):
    174         with self.assertLockedTransaction():
    175             self.controller.typeID = OTHER_TYPE_ID
    176         self.events.onChange.assert_called_once_with()
    177         self.events.onSkinsChange.assert_called_once_with()
    178         self.assertEqual(self.controller.typeID, OTHER_TYPE_ID)
    179         self.assertSkinState(applied=None, previewed=None, pending=None)
    180 
    181     @unittest.skip('test is failing and needs fixing')
    182     def test_pick_skin(self):
    183         with self.assertLockedTransaction():
    184             self.controller.PickSkin(SKIN)
    185         self.events.onChange.assert_called_once_with()
    186         self.assertSkinState(previewed=SKIN)
    187 
    188     def test_change_type_resets_picked_skin(self):
    189         self.controller.PickSkin(SKIN)
    190         self.controller.typeID = OTHER_TYPE_ID
    191         self.assertSkinState(applied=None, previewed=None, pending=None)
    192 
    193     def test_pick_same_skin_again(self):
    194         self.controller.PickSkin(SKIN)
    195         self.controller.PickSkin(SKIN)
    196         self.assertSkinState(applied=None, previewed=None, pending=None)
    197 
    198     def test_pick_none_skin_after_another_skin(self):
    199         self.controller.PickSkin(SKIN)
    200         self.controller.PickSkin(None)
    201         self.assertSkinState(applied=None, previewed=None, pending=None)
    202 
    203     def test_pick_another_skin(self):
    204         self.controller.PickSkin(SKIN)
    205         self.controller.PickSkin(OTHER_SKIN)
    206         self.assertSkinState(previewed=OTHER_SKIN)
    207 
    208     def test_change_type_with_picked_skin(self):
    209         self.controller.PickSkin(SKIN)
    210         self.controller.typeID = OTHER_TYPE_ID
    211         self.assertEqual(self.controller.typeID, OTHER_TYPE_ID)
    212         self.assertSkinState(previewed=None)
    213 
    214     def test_get_skins(self):
    215         self.adapter.GetSkins.return_value = self.SKIN_LIST
    216         skins = self.controller.skins
    217         self.assertItemsEqual(skins, self.SKIN_LIST)
    218 
    219     def test_skins_are_cached(self):
    220         self.prime_skins_cache(cached=self.SKIN_LIST)
    221         with self.assertNotLockedTransaction():
    222             skins = self.controller.skins
    223         self.assertItemsEqual(skins, self.SKIN_LIST)
    224 
    225     def test_changing_type_resets_skins_cache(self):
    226         self.prime_skins_cache(fresh=self.SKIN_LIST)
    227         self.controller.typeID = OTHER_TYPE_ID
    228         self.assertItemsEqual(self.controller.skins, self.SKIN_LIST)
    229 
    230     @unittest.skip('test is failing and needs fixing')
    231     def test_controller_registers_for_events(self):
    232         self.assertIn('OnSkinLicenseActivated', self.controller.__notifyevents__)
    233         self.adapter.RegisterNotify.assert_called_once_with(self.controller)
    234 
    235     @unittest.skip('test is failing and needs fixing')
    236     def test_skin_license_activated_event(self):
    237         with self.assertLockedTransaction():
    238             self.controller.OnSkinLicenseActivated(SKIN_ID)
    239         self.events.onChange.assert_called_once_with()
    240         self.events.onSkinsChange.assert_called_once_with()
    241 
    242     @unittest.skip('test is failing and needs fixing')
    243     def test_skins_cache_is_reset_on_license_activated_for_relevant_type(self):
    244         self.prime_skins_cache(fresh=self.SKIN_LIST)
    245         self.controller.OnSkinLicenseActivated(SKIN_ID)
    246         self.assertItemsEqual(self.controller.skins, self.SKIN_LIST)
    247 
    248     @unittest.skip('test is failing and needs fixing')
    249     def test_skins_cache_is_not_reset_on_license_activated_for_irrelevant_type(self):
    250         self.adapter.GetTypesForSkin.return_value = [OTHER_TYPE_ID]
    251         self.prime_skins_cache(cached=self.SKIN_LIST)
    252         self.controller.OnSkinLicenseActivated(SKIN_ID)
    253         self.assertItemsEqual(self.controller.skins, self.SKIN_LIST)
    254 
    255     @unittest.skip('test is failing and needs fixing')
    256     def test_license_activated_does_not_change_preview_state(self):
    257         self.controller.PickSkin(SKIN)
    258         self.adapter.GetSkins.return_value = [LICENSED_SKIN]
    259         self.events.onChange.reset_mock()
    260         self.controller.OnSkinLicenseActivated(LICENSED_SKIN.skinID)
    261         self.events.onChange.assert_called_once_with()
    262         self.events.onSkinsChange.assert_called_once_with()
    263         self.assertSkinState(previewed=LICENSED_SKIN)
    264 
    265 
    266 if __name__ == '__main__':
    267     unittest.main()