comtypes 1.4.9__zip → 1.4.10__zip

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/test/test_monikers.py

@@ -1,39 +1,53 @@
-from _ctypes import COMError
-from ctypes import byref, POINTER
 import contextlib
 import unittest
+from _ctypes import COMError
+from ctypes import HRESULT, POINTER, OleDLL, byref, c_wchar_p
+from ctypes.wintypes import DWORD
 
-import comtypes
-from comtypes.client import GetModule, CreateObject
-from comtypes import hresult, GUID
+from comtypes import GUID, hresult
+from comtypes.client import CreateObject, GetModule
 
 with contextlib.redirect_stdout(None):  # supress warnings
     GetModule("msvidctl.dll")
 from comtypes.gen import MSVidCtlLib as msvidctl
 from comtypes.gen.MSVidCtlLib import IBindCtx, IMoniker, IRunningObjectTable
 
-
 MKSYS_ITEMMONIKER = 4
 ROTFLAGS_ALLOWANYCLIENT = 1
+LPOLESTR = LPCOLESTR = c_wchar_p
+
+_ole32 = OleDLL("ole32")
+
+_CreateItemMoniker = _ole32.CreateItemMoniker
+_CreateItemMoniker.argtypes = [LPCOLESTR, LPCOLESTR, POINTER(POINTER(IMoniker))]
+_CreateItemMoniker.restype = HRESULT
+
+_CreateBindCtx = _ole32.CreateBindCtx
+_CreateBindCtx.argtypes = [DWORD, POINTER(POINTER(IBindCtx))]
+_CreateBindCtx.restype = HRESULT
+
+_GetRunningObjectTable = _ole32.GetRunningObjectTable
+_GetRunningObjectTable.argtypes = [DWORD, POINTER(POINTER(IRunningObjectTable))]
+_GetRunningObjectTable.restype = HRESULT
 
 
 def _create_item_moniker(delim: str, item: str) -> IMoniker:
     mon = POINTER(IMoniker)()
-    comtypes._ole32.CreateItemMoniker(delim, item, byref(mon))
+    _CreateItemMoniker(delim, item, byref(mon))
     return mon  # type: ignore
 
 
 def _create_bctx() -> IBindCtx:
     bctx = POINTER(IBindCtx)()
     # The first parameter is reserved and must be 0.
-    comtypes._ole32.CreateBindCtx(0, byref(bctx))
+    _CreateBindCtx(0, byref(bctx))
     return bctx  # type: ignore
 
 
 def _create_rot() -> IRunningObjectTable:
     rot = POINTER(IRunningObjectTable)()
     # The first parameter is reserved and must be 0.
-    comtypes._ole32.GetRunningObjectTable(0, byref(rot))
+    _GetRunningObjectTable(0, byref(rot))
     return rot  # type: ignore
 
 

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/test/test_msscript.py

@@ -1,8 +1,9 @@
 import unittest
 from ctypes import POINTER
+
+from comtypes import GUID
 from comtypes.automation import IDispatch
 from comtypes.client import CreateObject
-from comtypes import GUID
 
 ##from test import test_support
 ##from comtypes.unittests import support

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/test/test_npsupport.py

@@ -3,7 +3,7 @@ import functools
 import importlib
 import inspect
 import unittest
-from ctypes import c_long, c_double, pointer, POINTER
+from ctypes import POINTER, c_double, c_long, pointer
 from decimal import Decimal
 
 import comtypes._npsupport
@@ -11,13 +11,13 @@ from comtypes import IUnknown
 from comtypes._safearray import SafeArrayGetVartype
 from comtypes.automation import (
     BSTR,
+    VARIANT,
+    VARIANT_BOOL,
     VT_BSTR,
     VT_DATE,
     VT_I4,
-    _midlSAFEARRAY,
-    VARIANT,
     VT_VARIANT,
-    VARIANT_BOOL,
+    _midlSAFEARRAY,
 )
 from comtypes.safearray import safearray_as_ndarray
 

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/test/test_outparam.py

@@ -1,23 +1,26 @@
 import unittest
 from ctypes import (
+    HRESULT,
     POINTER,
+    OleDLL,
+    WinDLL,
     byref,
     c_int,
+    c_size_t,
     c_ulong,
     c_void_p,
     c_wchar,
     c_wchar_p,
     cast,
     memmove,
-    oledll,
     sizeof,
-    windll,
     wstring_at,
 )
+from ctypes.wintypes import DWORD, LPVOID
 from unittest.mock import patch
 
 from comtypes import COMMETHOD, GUID, IUnknown
-
+from comtypes.GUID import _CoTaskMemFree
 
 text_type = str
 
@@ -34,8 +37,21 @@ class IMalloc(IUnknown):
     ]
 
 
+_ole32 = OleDLL("ole32")
+
+_CoGetMalloc = _ole32.CoGetMalloc
+_CoGetMalloc.argtypes = [DWORD, POINTER(POINTER(IMalloc))]
+_CoGetMalloc.restype = HRESULT
+
+_ole32_nohresult = WinDLL("ole32")
+
+SIZE_T = c_size_t
+_CoTaskMemAlloc = _ole32_nohresult.CoTaskMemAlloc
+_CoTaskMemAlloc.argtypes = [SIZE_T]
+_CoTaskMemAlloc.restype = LPVOID
+
 malloc = POINTER(IMalloc)()
-oledll.ole32.CoGetMalloc(1, byref(malloc))
+_CoGetMalloc(1, byref(malloc))
 assert bool(malloc)
 
 
@@ -45,14 +61,14 @@ def from_outparm(self):
     result = wstring_at(self)
     if not malloc.DidAlloc(self):
         raise ValueError("memory was NOT allocated by CoTaskMemAlloc")
-    windll.ole32.CoTaskMemFree(self)
+    _CoTaskMemFree(self)
     return result
 
 
 def comstring(text, typ=c_wchar_p):
     text = text_type(text)
     size = (len(text) + 1) * sizeof(c_wchar)
-    mem = windll.ole32.CoTaskMemAlloc(size)
+    mem = _CoTaskMemAlloc(size)
     print("malloc'd 0x%x, %d bytes" % (mem, size))
     ptr = cast(mem, typ)
     memmove(mem, text, size)

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/test/test_persist.py

@@ -1,10 +1,8 @@
-from pathlib import Path
 import tempfile
 import unittest as ut
+from pathlib import Path
 
-from comtypes import CoCreateInstance, GUID, IPersist
-from comtypes import persist
-
+from comtypes import GUID, CoCreateInstance, IPersist, persist
 
 CLSID_ShellLink = GUID("{00021401-0000-0000-C000-000000000046}")
 

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/test/test_recordinfo.py

@@ -1,10 +1,10 @@
 # coding: utf-8
 
 import unittest
+from ctypes import byref, pointer, sizeof
 
 from comtypes import typeinfo
 from comtypes.client import GetModule
-from ctypes import byref, pointer, sizeof
 
 ComtypesCppTestSrvLib_GUID = "{07D2AEE5-1DF8-4D2C-953A-554ADFD25F99}"
 

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/test/test_sapi.py

@@ -2,7 +2,10 @@
 # ../gen/_C866CA3A_32F7_11D2_9602_00C04F8EE628_0_5_0
 # http://thread.gmane.org/gmane.comp.python.ctypes.user/1485
 
-import os, unittest, tempfile
+import os
+import tempfile
+import unittest
+
 from comtypes.client import CreateObject
 
 

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/test/test_server_register.py

@@ -1,5 +1,4 @@
 import _ctypes
-import ctypes
 import os
 import sys
 import unittest as ut
@@ -10,17 +9,71 @@ import comtypes
 import comtypes.server.inprocserver
 from comtypes import GUID
 from comtypes.server import register
-from comtypes.server.register import Registrar, RegistryEntries, _get_serverdll
+from comtypes.server.register import (
+    FrozenRegistryEntries,
+    InterpRegistryEntries,
+    Registrar,
+    _delete_key,
+    _get_serverdll,
+)
 
 HKCR = winreg.HKEY_CLASSES_ROOT
 MULTI_SZ = winreg.REG_MULTI_SZ
 SZ = winreg.REG_SZ
 
+ERROR_ACCESS_DENIED = 5
+ERROR_FILE_NOT_FOUND = 2
 
+
+@mock.patch.object(register, "SHDeleteKey")
+@mock.patch.object(register, "winreg")
+class Test_delete_key(ut.TestCase):
+    def test_calls_sh_deletekey_if_forced(self, _winreg, _sh_deletekey):
+        _delete_key(123, "subkey", force=True)
+        _winreg.DeleteKey.assert_not_called()
+        _sh_deletekey.assert_called_once_with(123, "subkey")
+
+    def test_calls_winreg_deletekey_if_not_forced(self, _winreg, _sh_deletekey):
+        _delete_key(123, "subkey", force=False)
+        _winreg.DeleteKey.assert_called_once_with(123, "subkey")
+        _sh_deletekey.assert_not_called()
+
+    def test_ignores_error_on_sh_deletekey(self, _winreg, _sh_deletekey):
+        err = OSError(ERROR_FILE_NOT_FOUND, "msg", "filename", ERROR_FILE_NOT_FOUND)
+        _sh_deletekey.side_effect = err
+        _delete_key(123, "subkey", force=True)
+        _winreg.DeleteKey.assert_not_called()
+        _sh_deletekey.assert_called_once_with(123, "subkey")
+
+    def test_ignores_error_on_winreg_deletekey(self, _winreg, _sh_deletekey):
+        err = OSError(ERROR_FILE_NOT_FOUND, "msg", "filename", ERROR_FILE_NOT_FOUND)
+        _winreg.DeleteKey.side_effect = err
+        _delete_key(123, "subkey", force=False)
+        _winreg.DeleteKey.assert_called_once_with(123, "subkey")
+        _sh_deletekey.assert_not_called()
+
+    def test_not_ignores_winerror_on_sh_deletekey(self, _winreg, _sh_deletekey):
+        err = OSError(ERROR_ACCESS_DENIED, "msg", "filename", ERROR_ACCESS_DENIED)
+        _sh_deletekey.side_effect = err
+        with self.assertRaises(OSError) as e:
+            _delete_key(123, "subkey", force=True)
+        self.assertEqual(e.exception.winerror, ERROR_ACCESS_DENIED)
+        _winreg.DeleteKey.assert_not_called()
+        _sh_deletekey.assert_called_once_with(123, "subkey")
+
+    def test_not_ignores_winerror_on_winreg_deletekey(self, _winreg, _sh_deletekey):
+        err = OSError(ERROR_ACCESS_DENIED, "msg", "filename", ERROR_ACCESS_DENIED)
+        _winreg.DeleteKey.side_effect = err
+        with self.assertRaises(OSError) as e:
+            _delete_key(123, "subkey", force=False)
+        self.assertEqual(e.exception.winerror, ERROR_ACCESS_DENIED)
+        _winreg.DeleteKey.assert_called_once_with(123, "subkey")
+        _sh_deletekey.assert_not_called()
+
+
+@mock.patch.object(register, "winreg")
 class Test_Registrar_nodebug(ut.TestCase):
-    @mock.patch.object(register, "winreg")
     def test_calls_openkey_and_deletekey(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         hkey = mock.Mock(spec=winreg.HKEYType)
         _winreg.OpenKey.return_value = hkey
         reg_clsid = GUID.create_new()
@@ -33,10 +86,7 @@ class Test_Registrar_nodebug(ut.TestCase):
         _winreg.OpenKey.assert_called_once_with(HKCR, rf"CLSID\{reg_clsid}")
         _winreg.DeleteKey.assert_called_once_with(hkey, "Logging")
 
-    @mock.patch.object(register, "winreg")
     def test_ignores_winerror(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
-        ERROR_FILE_NOT_FOUND = 2
         err = OSError(ERROR_FILE_NOT_FOUND, "msg", "filename", ERROR_FILE_NOT_FOUND)
         _winreg.OpenKey.side_effect = err
         reg_clsid = GUID.create_new()
@@ -49,12 +99,9 @@ class Test_Registrar_nodebug(ut.TestCase):
         _winreg.OpenKey.assert_called_once_with(HKCR, rf"CLSID\{reg_clsid}")
         _winreg.DeleteKey.assert_not_called()
 
-    @mock.patch.object(register, "winreg")
     def test_not_ignores_winerror(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         hkey = mock.Mock(spec=winreg.HKEYType)
         _winreg.OpenKey.return_value = hkey
-        ERROR_ACCESS_DENIED = 5
         err = OSError(ERROR_ACCESS_DENIED, "msg", "filename", ERROR_ACCESS_DENIED)
         _winreg.OpenKey.return_value = hkey
         _winreg.DeleteKey.side_effect = err
@@ -71,10 +118,9 @@ class Test_Registrar_nodebug(ut.TestCase):
         _winreg.DeleteKey.assert_called_once_with(hkey, "Logging")
 
 
+@mock.patch.object(register, "winreg")
 class Test_Registrar_debug(ut.TestCase):
-    @mock.patch.object(register, "winreg")
     def test_calls_createkey_and_sets_format(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         _winreg.REG_MULTI_SZ = MULTI_SZ
         _winreg.REG_SZ = SZ
         hkey = mock.Mock(spec=winreg.HKEYType)
@@ -97,9 +143,7 @@ class Test_Registrar_debug(ut.TestCase):
             ],
         )
 
-    @mock.patch.object(register, "winreg")
     def test_calls_createkey_and_deletes_format(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         _winreg.REG_MULTI_SZ = MULTI_SZ
         hkey = mock.Mock(spec=winreg.HKEYType)
         _winreg.CreateKey.return_value = hkey
@@ -117,13 +161,10 @@ class Test_Registrar_debug(ut.TestCase):
         )
         _winreg.DeleteValue.assert_called_once_with(hkey, "format")
 
-    @mock.patch.object(register, "winreg")
     def test_calls_createkey_and_ignores_errors_on_deleting(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         _winreg.REG_MULTI_SZ = MULTI_SZ
         hkey = mock.Mock(spec=winreg.HKEYType)
         _winreg.CreateKey.return_value = hkey
-        ERROR_FILE_NOT_FOUND = 2
         err = OSError(ERROR_FILE_NOT_FOUND, "msg", "filename", ERROR_FILE_NOT_FOUND)
         _winreg.DeleteValue.side_effect = err
         levels = ["lv=DEBUG"]
@@ -140,13 +181,10 @@ class Test_Registrar_debug(ut.TestCase):
         )
         _winreg.DeleteValue.assert_called_once_with(hkey, "format")
 
-    @mock.patch.object(register, "winreg")
     def test_calls_createkey_and_not_ignores_errors_on_deleting(self, _winreg):
-        _winreg.HKEY_CLASSES_ROOT = HKCR
         _winreg.REG_MULTI_SZ = MULTI_SZ
         hkey = mock.Mock(spec=winreg.HKEYType)
         _winreg.CreateKey.return_value = hkey
-        ERROR_ACCESS_DENIED = 5
         err = OSError(ERROR_ACCESS_DENIED, "msg", "filename", ERROR_ACCESS_DENIED)
         _winreg.DeleteValue.side_effect = err
         levels = ["lv=DEBUG"]
@@ -191,24 +229,17 @@ class Test_Registrar_unregister(ut.TestCase):
 
 
 class Test_get_serverdll(ut.TestCase):
-    def test_nonfrozen(self):
-        self.assertEqual(_ctypes.__file__, _get_serverdll())
-
-    def test_frozen(self):
-        with mock.patch.object(register, "sys") as _sys:
-            with mock.patch.object(register, "windll") as _windll:
-                handle = 1234
-                _sys.frozendllhandle = handle
-                self.assertEqual(b"\x00" * 260, _get_serverdll())
-                GetModuleFileName = _windll.kernel32.GetModuleFileNameA
-                (((hModule, lpFilename, nSize), _),) = GetModuleFileName.call_args_list
-                self.assertEqual(handle, hModule)
-                buf_type = type(ctypes.create_string_buffer(260))
-                self.assertIsInstance(lpFilename, buf_type)
-                self.assertEqual(260, nSize)
-
-
-class Test_NonFrozen_RegistryEntries(ut.TestCase):
+    @mock.patch.object(register, "GetModuleFileName")
+    def test_frozen(self, GetModuleFileName):
+        handle, dll_path = 1234, r"path\to\frozen.dll"
+        GetModuleFileName.return_value = dll_path
+        self.assertEqual(dll_path, _get_serverdll(handle))
+        (((hmodule, maxsize), _),) = GetModuleFileName.call_args_list
+        self.assertEqual(handle, hmodule)
+        self.assertEqual(260, maxsize)
+
+
+class Test_InterpRegistryEntries(ut.TestCase):
     def test_reg_clsid(self):
         reg_clsid = GUID.create_new()
 
@@ -216,7 +247,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             _reg_clsid_ = reg_clsid
 
         expected = [(HKCR, rf"CLSID\{reg_clsid}", "", "")]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_reg_desc(self):
         reg_clsid = GUID.create_new()
@@ -227,7 +258,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             _reg_desc_ = reg_desc
 
         expected = [(HKCR, rf"CLSID\{reg_clsid}", "", reg_desc)]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_reg_novers_progid(self):
         reg_clsid = GUID.create_new()
@@ -238,7 +269,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             _reg_novers_progid_ = reg_novers_progid
 
         expected = [(HKCR, rf"CLSID\{reg_clsid}", "", "Lib Server")]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_progid(self):
         reg_clsid = GUID.create_new()
@@ -254,7 +285,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, reg_progid, "", "Lib Server 1"),
             (HKCR, rf"{reg_progid}\CLSID", "", str(reg_clsid)),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_reg_progid_reg_desc(self):
         reg_clsid = GUID.create_new()
@@ -272,7 +303,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, reg_progid, "", "description for testing"),
             (HKCR, rf"{reg_progid}\CLSID", "", str(reg_clsid)),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_reg_progid_reg_novers_progid(self):
         reg_clsid = GUID.create_new()
@@ -295,7 +326,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, rf"{reg_novers_progid}\CurVer", "", "Lib.Server.1"),
             (HKCR, rf"{reg_novers_progid}\CLSID", "", str(reg_clsid)),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_local_server(self):
         reg_clsid = GUID.create_new()
@@ -311,7 +342,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, clsid_sub, "", ""),
             (HKCR, local_srv_sub, "", f"{sys.executable} {__file__}"),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_inproc_server(self):
         reg_clsid = GUID.create_new()
@@ -330,7 +361,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, inproc_srv_sub, "PythonClass", full_classname),
             (HKCR, inproc_srv_sub, "PythonPath", os.path.dirname(__file__)),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_inproc_server_reg_threading(self):
         reg_clsid = GUID.create_new()
@@ -352,7 +383,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, inproc_srv_sub, "PythonPath", os.path.dirname(__file__)),
             (HKCR, inproc_srv_sub, "ThreadingModel", reg_threading),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_reg_typelib(self):
         reg_clsid = GUID.create_new()
@@ -367,7 +398,7 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, rf"CLSID\{reg_clsid}", "", ""),
             (HKCR, rf"CLSID\{reg_clsid}\Typelib", "", libid),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
     def test_all_entries(self):
         reg_clsid = GUID.create_new()
@@ -408,34 +439,17 @@ class Test_NonFrozen_RegistryEntries(ut.TestCase):
             (HKCR, inproc_srv_sub, "ThreadingModel", reg_threading),
             (HKCR, rf"{clsid_sub}\Typelib", "", libid),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(expected, list(InterpRegistryEntries(Cls)))
 
 
-class Test_Frozen_RegistryEntries(ut.TestCase):
-    @mock.patch.object(register, "sys")
-    def test_local_dll(self, _sys):
-        _sys.mock_add_spec(["executable", "frozen"])
-        _sys.executable = sys.executable
-        _sys.frozen = "dll"
-        reg_clsid = GUID.create_new()
-        reg_clsctx = comtypes.CLSCTX_LOCAL_SERVER
+class Test_FrozenRegistryEntries(ut.TestCase):
+    SERVERDLL = r"my\target\server.dll"
 
-        class Cls:
-            _reg_clsid_ = reg_clsid
-            _reg_clsctx_ = reg_clsctx
-
-        clsid_sub = rf"CLSID\{reg_clsid}"
-        expected = [
-            (HKCR, clsid_sub, "", ""),
-            (HKCR, rf"{clsid_sub}\LocalServer32", "", sys.executable),
-        ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+    # We do not test the scenario where `frozen` is `'dll'` but
+    # `frozendllhandle` is `None`, as it is not a situation
+    # we anticipate.
 
-    @mock.patch.object(register, "sys")
-    def test_local_frozendllhandle(self, _sys):
-        _sys.mock_add_spec(["frozen", "frozendllhandle"])
-        _sys.frozen = "dll"
-        _sys.frozendllhandle = 1234
+    def test_local_dll(self):
         reg_clsid = GUID.create_new()
         reg_clsctx = comtypes.CLSCTX_LOCAL_SERVER
 
@@ -443,53 +457,30 @@ class Test_Frozen_RegistryEntries(ut.TestCase):
             _reg_clsid_ = reg_clsid
             _reg_clsctx_ = reg_clsctx
 
+        # In such cases, the server does not start because the
+        # InprocServer32/LocalServer32 keys are not registered.
         expected = [(HKCR, rf"CLSID\{reg_clsid}", "", "")]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        entries = FrozenRegistryEntries(Cls, frozen="dll", frozendllhandle=1234)
+        self.assertEqual(expected, list(entries))
 
-    @mock.patch.object(register, "sys")
-    def test_inproc_windows_exe(self, _sys):
-        _sys.mock_add_spec(["frozen"])
-        _sys.frozen = "windows_exe"
+    def test_local_windows_exe(self):
         reg_clsid = GUID.create_new()
-        reg_clsctx = comtypes.CLSCTX_INPROC_SERVER
-
-        class Cls:
-            _reg_clsid_ = reg_clsid
-            _reg_clsctx_ = reg_clsctx
-
-        expected = [(HKCR, rf"CLSID\{reg_clsid}", "", "")]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
-
-    @mock.patch.object(register, "_get_serverdll", lambda: r"my\target\server.dll")
-    @mock.patch.object(register, "sys")
-    def test_inproc_dll_frozendllhandle_clsid_to_class(self, _sys):
-        _sys.mock_add_spec(["frozen", "frozendllhandle"])
-        _sys.frozen = "dll"
-        _sys.frozendllhandle = 1234
-        reg_clsid = GUID.create_new()
-        reg_clsctx = comtypes.CLSCTX_INPROC_SERVER
+        reg_clsctx = comtypes.CLSCTX_LOCAL_SERVER
 
         class Cls:
             _reg_clsid_ = reg_clsid
             _reg_clsctx_ = reg_clsctx
 
-        clsid_sub = rf"CLSID\{reg_clsid}"
-        inproc_srv_sub = rf"{clsid_sub}\InprocServer32"
         expected = [
-            (HKCR, clsid_sub, "", ""),
-            (HKCR, inproc_srv_sub, "", r"my\target\server.dll"),
+            (HKCR, rf"CLSID\{reg_clsid}", "", ""),
+            (HKCR, rf"CLSID\{reg_clsid}\LocalServer32", "", sys.executable),
         ]
+        self.assertEqual(
+            expected, list(FrozenRegistryEntries(Cls, frozen="windows_exe"))
+        )
 
-        with mock.patch.dict(comtypes.server.inprocserver._clsid_to_class):
-            comtypes.server.inprocserver._clsid_to_class.update({5678: Cls})
-            self.assertEqual(expected, list(RegistryEntries(Cls)))
-
-    @mock.patch.object(register, "_get_serverdll", lambda: r"my\target\server.dll")
-    @mock.patch.object(register, "sys")
-    def test_inproc_dll(self, _sys):
-        _sys.mock_add_spec(["frozen", "modules"])
-        _sys.frozen = "dll"
-        _sys.modules = sys.modules
+    @mock.patch.object(register, "_get_serverdll", return_value=SERVERDLL)
+    def test_inproc_dll(self, get_serverdll):
         reg_clsid = GUID.create_new()
         reg_clsctx = comtypes.CLSCTX_INPROC_SERVER
 
@@ -499,21 +490,17 @@ class Test_Frozen_RegistryEntries(ut.TestCase):
 
         clsid_sub = rf"CLSID\{reg_clsid}"
         inproc_srv_sub = rf"{clsid_sub}\InprocServer32"
-        full_classname = f"{__name__}.Cls"
         expected = [
             (HKCR, clsid_sub, "", ""),
-            (HKCR, inproc_srv_sub, "", r"my\target\server.dll"),
-            (HKCR, inproc_srv_sub, "PythonClass", full_classname),
-            (HKCR, inproc_srv_sub, "PythonPath", os.path.dirname(__file__)),
+            (HKCR, inproc_srv_sub, "", self.SERVERDLL),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
-
-    @mock.patch.object(register, "_get_serverdll", lambda: r"my\target\server.dll")
-    @mock.patch.object(register, "sys")
-    def test_inproc_dll_reg_threading(self, _sys):
-        _sys.mock_add_spec(["frozen", "modules"])
-        _sys.frozen = "dll"
-        _sys.modules = sys.modules
+
+        entries = FrozenRegistryEntries(Cls, frozen="dll", frozendllhandle=1234)
+        self.assertEqual(expected, list(entries))
+        get_serverdll.assert_called_once_with(1234)
+
+    @mock.patch.object(register, "_get_serverdll", return_value=SERVERDLL)
+    def test_inproc_reg_threading(self, get_serverdll):
         reg_clsid = GUID.create_new()
         reg_threading = "Both"
         reg_clsctx = comtypes.CLSCTX_INPROC_SERVER
@@ -525,12 +512,13 @@ class Test_Frozen_RegistryEntries(ut.TestCase):
 
         clsid_sub = rf"CLSID\{reg_clsid}"
         inproc_srv_sub = rf"{clsid_sub}\InprocServer32"
-        full_classname = f"{__name__}.Cls"
         expected = [
             (HKCR, clsid_sub, "", ""),
-            (HKCR, inproc_srv_sub, "", r"my\target\server.dll"),
-            (HKCR, inproc_srv_sub, "PythonClass", full_classname),
-            (HKCR, inproc_srv_sub, "PythonPath", os.path.dirname(__file__)),
+            (HKCR, inproc_srv_sub, "", self.SERVERDLL),
             (HKCR, inproc_srv_sub, "ThreadingModel", reg_threading),
         ]
-        self.assertEqual(expected, list(RegistryEntries(Cls)))
+        self.assertEqual(
+            expected,
+            list(FrozenRegistryEntries(Cls, frozen="dll", frozendllhandle=1234)),
+        )
+        get_serverdll.assert_called_once_with(1234)

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/test/test_shelllink.py

@@ -1,12 +1,11 @@
-from pathlib import Path
 import tempfile
 import unittest as ut
+from pathlib import Path
 
-from comtypes import CoCreateInstance, GUID, shelllink
 import comtypes.hresult
+from comtypes import GUID, CoCreateInstance, shelllink
 from comtypes.persist import IPersistFile
 
-
 CLSID_ShellLink = GUID("{00021401-0000-0000-C000-000000000046}")