diff --git a/src/core/bugcheck_error.py b/src/core/bugcheck_error.py index 5cd4ae7..c6c408d 100644 --- a/src/core/bugcheck_error.py +++ b/src/core/bugcheck_error.py @@ -296,6 +296,18 @@ def UnknownOptionValueType( __class__.Helper__Raise(errMsg) + # -------------------------------------------------------------------- + @staticmethod + def UnsupportedPgConfStrategy( + strategy: typing.Any, + ) -> typing.NoReturn: + + errMsg = "Unsupported data strategy {!r}.".format( + strategy, + ) + + __class__.Helper__Raise(errMsg) + # Helper methods ----------------------------------------------------- @staticmethod def Helper__Raise(msg: str) -> typing.NoReturn: diff --git a/src/implementation/v00/configuration_base_ds_standard.py b/src/implementation/v00/configuration_base_ds_standard.py new file mode 100644 index 0000000..28fcdc1 --- /dev/null +++ b/src/implementation/v00/configuration_base_ds_standard.py @@ -0,0 +1,1098 @@ +# ////////////////////////////////////////////////////////////////////////////// +# Postgres Pro. PostgreSQL Configuration Python Library. + +# fmt: off +from .configuration_base import PostgresConfiguration_Base +from .configuration_base import PostgresConfigurationSetOptionValueResult_Base +from .configuration_base import PostgresConfigurationSetOptionValueEventID +from .configuration_base import PostgresConfigurationOption_Base +from .configuration_base import PostgresConfigurationFactory_Base +from .configuration_base import PgCfgModel__DataHandler + +from ...core.model import ConfigurationData as PgCfgModel__ConfigurationData +from ...core.model import OptionData as PgCfgModel__OptionData +from ...core.model import FileLineData as PgCfgModel__FileLineData +from ...core.model import FileData as PgCfgModel__FileData +from ...core.model import MultiIndex as PgCfgModel__MultiIndex +from ...core.model import T_OPTIONS_INDEX as PgCfgModel__T_OPTIONS_INDEX + +from ...core.model_utils import ModelUtils as PgCfgModel__ModelUtils + +from ...core.handlers import OptionHandlerCtxToPrepareGetValue as PgCfgModel__OptionHandlerCtxPrepareToGetValue +from ...core.handlers import OptionHandlerToPrepareGetValue as PgCfgModel__OptionHandlerToPrepareGetValue + +from ...core.helpers import Helpers +from ...core.bugcheck_error import BugCheckError +# fmt: on + +import typing + +# ////////////////////////////////////////////////////////////////////////////// +# PostgresConfiguration_Base__DataStrategy_Standard + + +class PostgresConfiguration_Base__DataStrategy_Standard: + @staticmethod + def SetOptionValue__Simple( + cfg: PostgresConfiguration_Base, + targetData: PgCfgModel__DataHandler.T_TARGET_OF_SET_OPTION_VALUE, + optionName: str, + optionValue: typing.Any, + ) -> PostgresConfigurationSetOptionValueResult_Base: + assert isinstance(cfg, PostgresConfiguration_Base) + assert ( + targetData is None + or type(targetData) is PgCfgModel__FileData + or type(targetData) is PgCfgModel__OptionData + ) + assert type(optionName) is str + assert optionValue is not None + + # ------------------------------------------------ + if targetData is None: + return __class__.Helper__SetSimpleOptionValue__Common( + cfg, + optionName, + optionValue, + ) + + # ------------------------------------------------ + assert targetData is not None + + if type(targetData) is PgCfgModel__OptionData: + return __class__.Helper__SetSimpleOptionValue__Exact( + cfg, + targetData, + optionValue, + ) + + if type(targetData) is PgCfgModel__FileData: + return __class__.Helper__SetSimpleOptionValue__File( + cfg, + targetData, + optionName, + optionValue, + ) + + # ------------------------------------------------ + BugCheckError.UnkObjectDataType(type(targetData)) + + # -------------------------------------------------------------------- + @staticmethod + def GetOptionValue__Simple( + cfg: PostgresConfiguration_Base, + sourceData: PgCfgModel__DataHandler.T_TARGET_OF_GET_OPTION_VALUE, + optionName: str, + ) -> typing.Any: + assert isinstance(cfg, PostgresConfiguration_Base) + assert ( + sourceData is None + or type(sourceData) is PgCfgModel__FileData + or type(sourceData) is PgCfgModel__OptionData + ) + assert type(optionName) is str + + # -------------------------------------- ROOT + if sourceData is None: + if optionName not in cfg.m_Data.m_AllOptionsByName.keys(): + return None + + optionData = __class__.Helper__FindActiveSimpleOption__Common( + cfg, + optionName, + ) + + if optionData is None: + return None + + assert optionData is not None + assert optionData.IsAlive() + assert optionData.m_Name == optionName + assert optionData.m_Value is not None + + return __class__.Helper__PrepareGetValue( + cfg, + optionName, + optionData.m_Value, + ) + + # -------------------------------------- OPTION DATA + if type(sourceData) is PgCfgModel__OptionData: + optionData = sourceData + + assert optionData.IsAlive() + assert optionData.m_Value is not None + assert optionData.m_Name == optionName + return __class__.Helper__PrepareGetValue( + cfg, + optionData.m_Name, + optionData.m_Value, + ) + + # -------------------------------------- FILE DATA + if type(sourceData) is PgCfgModel__FileData: + if optionName not in cfg.m_Data.m_AllOptionsByName.keys(): + return None + + findCtx = PgCfgModel__ModelUtils.tagFindCtx() + + optionData = PgCfgModel__ModelUtils.File__FindSimpleOption( + findCtx, + sourceData, + optionName, + enterIntoIncludes=True, + ) + + if optionData is not None: + assert type(optionData) is PgCfgModel__OptionData + assert optionData.IsAlive() + assert optionData.m_Value is not None + assert optionData.m_Name == optionName + return __class__.Helper__PrepareGetValue( + cfg, + optionData.m_Name, + optionData.m_Value, + ) + + return None + + BugCheckError.UnkObjectDataType(type(sourceData)) + + # -------------------------------------------------------------------- + @staticmethod + def Helper__FindActiveSimpleOption__Common( + cfg: PostgresConfiguration_Base, + optionName: str, + ) -> typing.Optional[PgCfgModel__OptionData]: + assert isinstance(cfg, PostgresConfiguration_Base) + assert type(optionName) is str + + findCtx: typing.Optional[PgCfgModel__ModelUtils.tagFindCtx] = None + + autoConfFileData = PgCfgModel__ModelUtils.Cfg__FindTopLevelFileByName( + cfg.m_Data, + cfg.Internal__GetAutoConfFileName(), + ) + + if autoConfFileData is not None: + findCtx = PgCfgModel__ModelUtils.tagFindCtx() + + optionData = PgCfgModel__ModelUtils.File__FindSimpleOption( + findCtx, + autoConfFileData, + optionName, + enterIntoIncludes=True, + ) + + if optionData is not None: + assert type(optionData) is PgCfgModel__OptionData + assert optionData.IsAlive() + assert optionData.m_Value is not None + assert optionData.m_Name == optionName + return optionData + + iFile = len(cfg.m_Data.m_TopLevelFiles) + + while iFile > 0: + iFile -= 1 + fileData = cfg.m_Data.m_TopLevelFiles[iFile] + + if autoConfFileData is None: + pass + elif autoConfFileData.m_Path == fileData.m_Path: + continue + + if findCtx is None: + findCtx = PgCfgModel__ModelUtils.tagFindCtx() + + optionData = PgCfgModel__ModelUtils.File__FindSimpleOption( + findCtx, + fileData, + optionName, + enterIntoIncludes=True, + ) + + if optionData is None: + continue + + assert type(optionData) is PgCfgModel__OptionData + assert optionData.IsAlive() + assert optionData.m_Value is not None + assert optionData.m_Name == optionName + return optionData + + return None + + # -------------------------------------------------------------------- + @staticmethod + def GetOptionValue__UnionList( + cfg: PostgresConfiguration_Base, + sourceData: PgCfgModel__DataHandler.T_TARGET_OF_GET_OPTION_VALUE, + optionName: str, + ) -> typing.Any: + assert isinstance(cfg, PostgresConfiguration_Base) + assert ( + sourceData is None + or type(sourceData) is PgCfgModel__FileData + or type(sourceData) is PgCfgModel__OptionData + ) + assert type(optionName) is str + + return __class__.GetOptionValue__Simple( + cfg, + sourceData, + optionName, + ) + + # -------------------------------------------------------------------- + @staticmethod + def ResetOption( + cfg: PostgresConfiguration_Base, + targetData: PgCfgModel__DataHandler.T_TARGET_OF_RESET_OPTION, + optionName: str, + ) -> PostgresConfigurationSetOptionValueResult_Base: + assert isinstance(cfg, PostgresConfiguration_Base) + assert ( + targetData is None + or type(targetData) is PgCfgModel__FileData + or type(targetData) is PgCfgModel__OptionData + ) + assert type(optionName) is str + + # -------------------------------- target is NONE + if targetData is None: + eventID = __class__.Helper__FindAndDeleteOption( + cfg, + cfg.m_Data.m_AllOptionsByName, + optionName, + ) + + assert eventID in [ + PostgresConfigurationSetOptionValueEventID.NONE, + PostgresConfigurationSetOptionValueEventID.OPTION_WAS_DELETED, + ] + + return PostgresConfigurationSetOptionValueResult_Base( + None, + None, + eventID, + ) + + # -------------------------------- target is FileData or OptionData + if type(targetData) is PgCfgModel__OptionData: + cfg.Debug__CheckOurObjectData( + targetData, + ) + + PgCfgModel__ModelUtils.Option__delete( + cfg.m_Data, + targetData, + True, + ) + + return ( + PostgresConfigurationSetOptionValueResult_Base.Create__OptWasDeleted() + ) + + if type(targetData) is PgCfgModel__FileData: + assert type(targetData) is PgCfgModel__FileData + + eventID = __class__.Helper__FindAndDeleteOption( + cfg, + targetData.m_OptionsByName, + optionName, + ) + + assert eventID in [ + PostgresConfigurationSetOptionValueEventID.NONE, + PostgresConfigurationSetOptionValueEventID.OPTION_WAS_DELETED, + ] + + return PostgresConfigurationSetOptionValueResult_Base( + None, + None, + eventID, + ) + + BugCheckError.UnkObjectDataType(type(targetData)) + + # -------------------------------------------------------------------- + @staticmethod + def AddSimpleOption( + cfg: PostgresConfiguration_Base, + targetData: PgCfgModel__DataHandler.T_TARGET_OF_ADD_OPTION, + optionOffset: typing.Optional[int], + optionName: str, + optionValue: typing.Any, + ) -> PostgresConfigurationOption_Base: + assert isinstance(cfg, PostgresConfiguration_Base) + assert ( + targetData is None + or type(targetData) is PgCfgModel__FileData + or type(targetData) is PgCfgModel__FileLineData + ) + assert optionOffset is None or type(optionOffset) is int + assert type(optionName) is str + assert optionValue is not None + + assert cfg.m_Data is not None + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert cfg.m_Data.m_AllOptionsByName is not None + assert type(cfg.m_Data.m_AllOptionsByName) is PgCfgModel__MultiIndex + + if type(targetData) is PgCfgModel__FileLineData: + return __class__.Helper__AddSimpleOption__FileLine( + cfg, + targetData, + optionOffset, + optionName, + optionValue, + ) + + assert optionOffset is None + + if type(targetData) is PgCfgModel__FileData: + return __class__.Helper__AddSimpleOption__File( + cfg, + targetData, + optionName, + optionValue, + ) + + if targetData is None: + return __class__.Helper__AddSimpleOption__Common( + cfg, + optionName, + optionValue, + ) + + BugCheckError.UnkObjectDataType(type(targetData)) + + # -------------------------------------------------------------------- + @staticmethod + def SetUniqueOptionValueItem( + cfg: PostgresConfiguration_Base, + targetData: PgCfgModel__DataHandler.T_TARGET_OF_SET_OPTION_VALUE, + optionName: str, + optionValueItem: typing.Any, + ) -> PostgresConfigurationSetOptionValueResult_Base: + assert isinstance(cfg, PostgresConfiguration_Base) + assert ( + targetData is None + or type(targetData) is PgCfgModel__FileData + or type(targetData) is PgCfgModel__OptionData + ) + assert type(optionName) is str + assert optionValueItem is not None + + currentOptData: typing.Optional[PgCfgModel__OptionData] = None + + if targetData is None: + currentOptData = __class__.Helper__FindActiveSimpleOption__Common( + cfg, + optionName, + ) + elif type(targetData) is PgCfgModel__OptionData: + assert targetData.IsAlive() + assert targetData.m_Name == optionName + cfg.Debug__CheckOurObjectData(targetData) + currentOptData = targetData + elif type(targetData) is PgCfgModel__FileData: + assert targetData.IsAlive() + findCtx = PgCfgModel__ModelUtils.tagFindCtx() + currentOptData = PgCfgModel__ModelUtils.File__FindSimpleOption( + findCtx, + targetData, + optionName, + enterIntoIncludes=True, + ) + else: + BugCheckError.UnkObjectDataType(type(targetData)) + + if currentOptData is None: + return __class__.SetOptionValue__Simple( + cfg, + targetData, + optionName, + [optionValueItem], + ) + + assert currentOptData.IsAlive() + assert type(currentOptData.m_Value) is list + + if __class__.Helper__DoesOptionValueAlreadyHaveThisUniqueItem( + currentOptData, + optionValueItem, + ): + return PostgresConfigurationSetOptionValueResult_Base.Create__OptValueItemWasAlreadyDefined( + cfg, + currentOptData, + ) + + newList = currentOptData.m_Value.copy() + newList.append(optionValueItem) + + res = __class__.SetOptionValue__Simple( + cfg, + targetData, + optionName, + newList, + ) + + assert res.m_OptData is not None + return ( + PostgresConfigurationSetOptionValueResult_Base.Create__OptValueItemWasAdded( + cfg, + res.m_OptData, + ) + ) + + # Helper methods ----------------------------------------------------- + @staticmethod + def Helper__FindAndDeleteOption( + cfg: PostgresConfiguration_Base, + allOptionsByName: PgCfgModel__T_OPTIONS_INDEX, + optionName: str, + ) -> PostgresConfigurationSetOptionValueEventID: + assert isinstance(cfg, PostgresConfiguration_Base) + assert type(allOptionsByName) is PgCfgModel__MultiIndex + assert type(optionName) is str + + if optionName not in allOptionsByName.keys(): + return PostgresConfigurationSetOptionValueEventID.NONE + + data = allOptionsByName[optionName] + assert data is not None + + if type(data) is PgCfgModel__OptionData: + assert data.IsAlive() + assert data.m_Name == optionName + + PgCfgModel__ModelUtils.Option__delete( + cfg.m_Data, + data, + True, + ) + + return PostgresConfigurationSetOptionValueEventID.OPTION_WAS_DELETED + + if type(data) is list: + data = data.copy() + assert type(data) is list + + for optionData in data: + assert optionData is not None + assert type(optionData) is PgCfgModel__OptionData + assert optionData.IsAlive() + assert optionData.m_Name == optionName + + PgCfgModel__ModelUtils.Option__delete( + cfg.m_Data, + optionData, + True, + ) + continue + + # [2025-01-02] It is expected + assert optionName not in allOptionsByName.keys() + + return PostgresConfigurationSetOptionValueEventID.OPTION_WAS_DELETED + + # Unknown type of option data in dictionary + + assert type(optionName) is str + BugCheckError.UnkOptObjectDataType( + optionName, + type(data), + ) + + # -------------------------------------------------------------------- + @staticmethod + def Helper__SetSimpleOptionValue__Common( + cfg: PostgresConfiguration_Base, + optionName: str, + optionValue: typing.Any, + ) -> PostgresConfigurationSetOptionValueResult_Base: + assert isinstance(cfg, PostgresConfiguration_Base) + assert type(optionName) is str + assert optionValue is not None + + assert cfg.m_Data is not None + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert type(cfg.m_Data.m_AllOptionsByName) is PgCfgModel__MultiIndex + + autoConfFileData = PgCfgModel__ModelUtils.Cfg__FindTopLevelFileByName( + cfg.m_Data, + cfg.Internal__GetAutoConfFileName(), + ) + + if autoConfFileData is not None: + return __class__.Helper__SetSimpleOptionValue__File( + cfg, + autoConfFileData, + optionName, + optionValue, + ) + + assert autoConfFileData is None + + autoConfFileData = PgCfgModel__ModelUtils.Cfg__CreateAndAddTopLevelFile__AUTO( + cfg.m_Data, + cfg.Internal__GetAutoConfFileName(), + ) + + assert autoConfFileData is not None + + try: + # Append new property into auto conf + optionData = PgCfgModel__ModelUtils.File__add_Option( + cfg.m_Data, + autoConfFileData, + optionName, + optionValue, + ) + except BaseException: + # TODO: delete autoConfFileData + raise + + assert optionData is not None + assert optionData.IsAlive() + assert optionData.get_Parent().get_Parent() is autoConfFileData + + return PostgresConfigurationSetOptionValueResult_Base.Create__OptWasAdded( + cfg, + optionData, + ) + + # -------------------------------------------------------------------- + @staticmethod + def Helper__SetSimpleOptionValue__File( + cfg: PostgresConfiguration_Base, + fileData: PgCfgModel__FileData, + optionName: str, + optionValue: typing.Any, + ) -> PostgresConfigurationSetOptionValueResult_Base: + assert isinstance(cfg, PostgresConfiguration_Base) + assert type(fileData) is PgCfgModel__FileData + assert type(fileData.m_OptionsByName) is PgCfgModel__MultiIndex + assert type(optionName) is str + assert optionValue is not None + + # ------------------------------------------------ + optionData = PgCfgModel__ModelUtils.File__FindSimpleOption( + None, + fileData, + optionName, + enterIntoIncludes=False, + ) + + if optionData is not None: + assert type(optionData) is PgCfgModel__OptionData + assert optionData.IsAlive() + assert optionData.m_Value is not None + assert optionData.m_Name == optionName + + PgCfgModel__ModelUtils.Option__set_Value( + optionData, + optionValue, + ) + + return PostgresConfigurationSetOptionValueResult_Base.Create__OptWasUpdated( + cfg, + optionData, + ) + + # Append new property into auto conf + optionData = PgCfgModel__ModelUtils.File__add_Option( + cfg.m_Data, + fileData, + optionName, + optionValue, + ) + + assert optionData is not None + assert optionData.IsAlive() + assert optionData.get_Parent().get_Parent() is fileData + + return PostgresConfigurationSetOptionValueResult_Base.Create__OptWasAdded( + cfg, + optionData, + ) + + # -------------------------------------------------------------------- + @staticmethod + def Helper__SetSimpleOptionValue__Exact( + cfg: PostgresConfiguration_Base, + optionData: PgCfgModel__OptionData, + optionValue: typing.Any, + ) -> PostgresConfigurationSetOptionValueResult_Base: + assert isinstance(cfg, PostgresConfiguration_Base) + assert type(optionData) is PgCfgModel__OptionData + assert optionData.IsAlive() + assert optionValue is not None + + # ------------------------------------------------ + cfg.Debug__CheckOurObjectData(optionData) + + # ------------------------------------------------ + PgCfgModel__ModelUtils.Option__set_Value( + optionData, + optionValue, + ) + + return PostgresConfigurationSetOptionValueResult_Base.Create__OptWasUpdated( + cfg, + optionData, + ) + + # -------------------------------------------------------------------- + @staticmethod + def Helper__DoesOptionValueAlreadyHaveThisUniqueItem( + optionData: PgCfgModel__OptionData, + optionValueItem: typing.Any, + ) -> bool: + assert optionData is not None + assert optionValueItem is not None + assert type(optionData) is PgCfgModel__OptionData + assert optionData.IsAlive() + assert optionData.m_Value is not None + assert type(optionData.m_Value) is list + + return Helpers.DoesContainerContainsValue__NotNullAndExact( + optionData.m_Value, + optionValueItem, + ) + + # -------------------------------------------------------------------- + @staticmethod + def Helper__AddSimpleOption__Common( + cfg: PostgresConfiguration_Base, + optionName: str, + optionValue: typing.Any, + ) -> PostgresConfigurationOption_Base: + assert isinstance(cfg, PostgresConfiguration_Base) + assert type(optionName) is str + assert optionValue is not None + + assert cfg.m_Data is not None + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert cfg.m_Data.m_AllOptionsByName is not None + assert type(cfg.m_Data.m_AllOptionsByName) is PgCfgModel__MultiIndex + + # OK. Let's add this option + assert optionValue is not None + + # Let's select the file to append this new option + getFileData_r = __class__.Helper__GetFileForNewSimpleOption( + cfg, + ) + + assert type(getFileData_r) is tuple + assert len(getFileData_r) == 2 + + assert type(getFileData_r[0]) is PgCfgModel__FileData + assert type(getFileData_r[1]) is bool + + fileData = getFileData_r[0] + assert type(fileData) is PgCfgModel__FileData + + try: + # may raise + optionData = PgCfgModel__ModelUtils.File__add_Option( + cfg.m_Data, + fileData, + optionName, + optionValue, + ) + + assert optionData is not None + assert type(optionData) is PgCfgModel__OptionData + + assert optionName in cfg.m_Data.m_AllOptionsByName.keys() + assert optionName in fileData.m_OptionsByName.keys() + + try: + # may raise + option = PostgresConfigurationFactory_Base.GetObject( + cfg, + optionData, + ) + + assert option is not None + assert type(option) is PostgresConfigurationOption_Base + assert option.m_OptionData is optionData + except: # rollback line with option + assert optionData.IsAlive() + + PgCfgModel__ModelUtils.FileLine__delete( + cfg.m_Data, + optionData.get_Parent(), + ) + + assert not optionData.IsAlive() + + assert optionName not in cfg.m_Data.m_AllOptionsByName.keys() + assert optionName not in fileData.m_OptionsByName.keys() + raise + except: # rollback file + assert type(getFileData_r) is tuple + assert len(getFileData_r) == 2 + + assert type(getFileData_r[0]) is PgCfgModel__FileData + assert type(getFileData_r[1]) is bool + + if getFileData_r[1]: + pass # TODO: delete file + + raise + + assert option is not None + assert type(option) is PostgresConfigurationOption_Base + assert option.m_OptionData is optionData + assert option.m_OptionData.IsAlive() + return option + + # -------------------------------------------------------------------- + @staticmethod + def Helper__AddSimpleOption__FileLine( + cfg: PostgresConfiguration_Base, + fileLineData: PgCfgModel__FileLineData, + optionOffset: typing.Optional[int], + optionName: str, + optionValue: typing.Any, + ): + assert isinstance(cfg, PostgresConfiguration_Base) + assert fileLineData is not None + assert type(fileLineData) is PgCfgModel__FileLineData + assert optionOffset is None or type(optionOffset) is int + assert type(optionName) is str + assert optionValue is not None + + assert cfg.m_Data is not None + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert cfg.m_Data.m_AllOptionsByName is not None + assert type(cfg.m_Data.m_AllOptionsByName) is PgCfgModel__MultiIndex + + fileData = fileLineData.m_Parent + assert fileData is not None + assert type(fileData) is PgCfgModel__FileData + + assert fileData.m_OptionsByName is not None + assert type(fileData.m_OptionsByName) is PgCfgModel__MultiIndex + + # OK. Let's add this option + assert optionValue is not None + + optionData = PgCfgModel__ModelUtils.FileLine__add_Option( + cfg.m_Data, + fileLineData, + optionName, + optionValue, + optionOffset, + ) + + assert optionData is not None + assert type(optionData) is PgCfgModel__OptionData + + assert optionName in fileData.m_OptionsByName.keys() + assert optionName in cfg.m_Data.m_AllOptionsByName.keys() + + try: + option = PostgresConfigurationFactory_Base.GetObject( + cfg, + optionData, + ) + + assert option is not None + assert type(option) is PostgresConfigurationOption_Base + assert option.m_OptionData is optionData + except: + PgCfgModel__ModelUtils.Option__delete( + cfg.m_Data, + optionData, + withLine=False, + ) + + assert not optionData.IsAlive() + assert optionName not in fileData.m_OptionsByName.keys() + assert optionName not in cfg.m_Data.m_AllOptionsByName.keys() + raise + + assert option is not None + assert type(option) is PostgresConfigurationOption_Base + assert option.m_OptionData is optionData + assert option.m_OptionData.IsAlive() + return option + + # -------------------------------------------------------------------- + @staticmethod + def Helper__AddSimpleOption__File( + cfg: PostgresConfiguration_Base, + fileData: PgCfgModel__FileData, + optionName: str, + optionValue: typing.Any, + ): + assert isinstance(cfg, PostgresConfiguration_Base) + assert fileData is not None + assert type(fileData) is PgCfgModel__FileData + assert type(optionName) is str + assert optionValue is not None + + assert cfg.m_Data is not None + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert cfg.m_Data.m_AllOptionsByName is not None + assert type(cfg.m_Data.m_AllOptionsByName) is PgCfgModel__MultiIndex + + assert fileData.m_OptionsByName is not None + assert type(fileData.m_OptionsByName) is PgCfgModel__MultiIndex + + # OK. Let's add this option + assert optionValue is not None + + optionData = PgCfgModel__ModelUtils.File__add_Option( + cfg.m_Data, + fileData, + optionName, + optionValue, + ) + + assert optionData is not None + assert type(optionData) is PgCfgModel__OptionData + + assert optionName in fileData.m_OptionsByName.keys() + assert optionName in cfg.m_Data.m_AllOptionsByName.keys() + + try: + option = PostgresConfigurationFactory_Base.GetObject( + cfg, + optionData, + ) + + assert option is not None + assert type(option) is PostgresConfigurationOption_Base + assert option.m_OptionData is optionData + except: + PgCfgModel__ModelUtils.FileLine__delete( + cfg.m_Data, + optionData.get_Parent(), + ) + + assert not optionData.IsAlive() + assert optionName not in fileData.m_OptionsByName.keys() + assert optionName not in cfg.m_Data.m_AllOptionsByName.keys() + raise + + assert option is not None + assert type(option) is PostgresConfigurationOption_Base + assert option.m_OptionData is optionData + assert option.m_OptionData.IsAlive() + return option + + # -------------------------------------------------------------------- + # returns tuple[FileData, Bool_signal_about_creating_a_new_file] + @staticmethod + def Helper__GetFileForNewSimpleOption( + cfg: PostgresConfiguration_Base, + ) -> typing.Tuple[PgCfgModel__FileData, bool]: + assert isinstance(cfg, PostgresConfiguration_Base) + + # We always append into standard "postgresql.auto.conf" + + fileData = PgCfgModel__ModelUtils.Cfg__FindTopLevelFileByName( + cfg.m_Data, + cfg.Internal__GetAutoConfFileName(), + ) + + if fileData is not None: + assert type(fileData) is PgCfgModel__FileData + return (fileData, False) + + assert fileData is None + + fileData = PgCfgModel__ModelUtils.Cfg__CreateAndAddTopLevelFile__AUTO( + cfg.m_Data, + cfg.Internal__GetAutoConfFileName(), + ) + + assert fileData is not None + assert type(fileData) is PgCfgModel__FileData + + return (fileData, True) + + # -------------------------------------------------------------------- + @staticmethod + def Helper__FinalRegSimpleOptionValue__Common( + cfg: PostgresConfiguration_Base, + optionName: str, + preparedOptionValue: typing.Any, + ) -> PostgresConfigurationSetOptionValueResult_Base: + assert isinstance(cfg, PostgresConfiguration_Base) + assert type(optionName) is str + assert preparedOptionValue is not None + + assert cfg.m_Data is not None + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert type(cfg.m_Data.m_AllOptionsByName) is PgCfgModel__MultiIndex + + assert optionName not in cfg.m_Data.m_AllOptionsByName.keys() + + # Select the file to append this new option + getFileData_r = __class__.Helper__GetFileForNewSimpleOption( + cfg, + ) + + assert getFileData_r is not None + assert type(getFileData_r) is tuple + assert len(getFileData_r) == 2 + assert type(getFileData_r[0]) is PgCfgModel__FileData + assert type(getFileData_r[1]) is bool + + fileData = getFileData_r[0] + assert type(fileData) is PgCfgModel__FileData + + try: + result = __class__.Helper__FinalRegSimpleOptionValue__File( + cfg, + fileData, + optionName, + preparedOptionValue, + ) + except: # rollback file + assert type(getFileData_r) is tuple + assert len(getFileData_r) == 2 + + assert type(getFileData_r[0]) is PgCfgModel__FileData + assert type(getFileData_r[1]) is bool + + if getFileData_r[1]: + pass # TODO: delete file + + raise + + assert result is not None + assert type(result) is PostgresConfigurationSetOptionValueResult_Base + assert result.m_EventID in [ + PostgresConfigurationSetOptionValueEventID.OPTION_WAS_ADDED, + ] + assert result.m_OptData is not None + assert type(result.m_OptData) is PgCfgModel__OptionData + assert result.m_OptData.IsAlive() + assert result.m_OptData.m_Name == optionName + return result + + # -------------------------------------------------------------------- + @staticmethod + def Helper__FinalRegSimpleOptionValue__File( + cfg: PostgresConfiguration_Base, + fileData: PgCfgModel__FileData, + optionName: str, + preparedOptionValue: typing.Any, + ) -> PostgresConfigurationSetOptionValueResult_Base: + assert isinstance(cfg, PostgresConfiguration_Base) + assert type(fileData) is PgCfgModel__FileData + assert type(optionName) is str + assert preparedOptionValue is not None + + assert cfg.m_Data is not None + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert type(cfg.m_Data.m_AllOptionsByName) is PgCfgModel__MultiIndex + + assert optionName not in fileData.m_OptionsByName.keys() + assert optionName not in cfg.m_Data.m_AllOptionsByName.keys() + + optionData = PgCfgModel__ModelUtils.File__add_Option( + cfg.m_Data, + fileData, + optionName, + preparedOptionValue, + ) + + assert optionData is not None + assert type(optionData) is PgCfgModel__OptionData + assert optionData.IsAlive() + assert optionData.m_Name == optionName + assert type(optionData.m_Parent) is PgCfgModel__FileLineData + assert optionData.m_Parent.m_Parent is fileData + assert optionName in fileData.m_OptionsByName.keys() + assert optionName in cfg.m_Data.m_AllOptionsByName.keys() + + try: + result = PostgresConfigurationSetOptionValueResult_Base.Create__OptWasAdded( + cfg, + optionData, + ) + assert result is not None + assert type(result) is PostgresConfigurationSetOptionValueResult_Base + assert result.m_EventID in [ + PostgresConfigurationSetOptionValueEventID.OPTION_WAS_ADDED, + ] + assert result.m_OptData is optionData + except: # rollback line with option + assert optionData.IsAlive() + + PgCfgModel__ModelUtils.FileLine__delete( + cfg.m_Data, + optionData.get_Parent(), + ) + + assert not optionData.IsAlive() + + assert optionName not in fileData.m_OptionsByName.keys() + assert optionName not in cfg.m_Data.m_AllOptionsByName.keys() + raise + + assert result is not None + assert type(result) is PostgresConfigurationSetOptionValueResult_Base + assert result.m_EventID in [ + PostgresConfigurationSetOptionValueEventID.OPTION_WAS_ADDED, + ] + assert result.m_OptData is optionData + + return result + + # -------------------------------------------------------------------- + @staticmethod + def Helper__PrepareGetValue( + cfg: PostgresConfiguration_Base, + optionName: str, + optionValue: typing.Any, + ) -> typing.Any: + assert isinstance(cfg, PostgresConfiguration_Base) + assert optionName is not None + assert optionValue is not None + assert type(optionName) is str + + prepareHandler = cfg.Internal__GetOptionHandlerToPrepareGetValue( + optionName, + ) + assert prepareHandler is not None + assert isinstance( + prepareHandler, + PgCfgModel__OptionHandlerToPrepareGetValue, + ) + + prepareCtx = PgCfgModel__OptionHandlerCtxPrepareToGetValue( + cfg, + optionName, + optionValue, + ) + + return prepareHandler.PrepareGetValue(prepareCtx) + + +# ////////////////////////////////////////////////////////////////////////////// +# g_PgCfgBaseDataStrategy__Standard + + +g_PgCfgBaseDataStrategy__Standard = PostgresConfiguration_Base.tagDataStrategy( + # fmt: off + SetOptionValue__Simple=PostgresConfiguration_Base__DataStrategy_Standard.SetOptionValue__Simple, + GetOptionValue__Simple=PostgresConfiguration_Base__DataStrategy_Standard.GetOptionValue__Simple, + GetOptionValue__UnionList=PostgresConfiguration_Base__DataStrategy_Standard.GetOptionValue__UnionList, + ResetOption=PostgresConfiguration_Base__DataStrategy_Standard.ResetOption, + AddSimpleOption=PostgresConfiguration_Base__DataStrategy_Standard.AddSimpleOption, + SetUniqueOptionValueItem=PostgresConfiguration_Base__DataStrategy_Standard.SetUniqueOptionValueItem, + # fmt: on +) + +# ////////////////////////////////////////////////////////////////////////////// diff --git a/src/implementation/v00/configuration_std.py b/src/implementation/v00/configuration_std.py index afccb40..d1c144d 100644 --- a/src/implementation/v00/configuration_std.py +++ b/src/implementation/v00/configuration_std.py @@ -19,6 +19,7 @@ from .configuration_base_w import PostgresConfigurationWriterCtx_Base from .configuration_base_ds_strict import g_PgCfgBaseDataStrategy__Strict +from .configuration_base_ds_standard import g_PgCfgBaseDataStrategy__Standard from ...core.option.handlers.instances import g_OptionHandlers__Std__Bool from ...core.option.handlers.instances import g_OptionHandlers__Std__Int @@ -33,12 +34,18 @@ from ...core.bugcheck_error import BugCheckError import typing +import enum # ////////////////////////////////////////////////////////////////////////////// # class PostgresConfiguration_Std class PostgresConfiguration_Std(PostgresConfiguration_Base): + class Strategy(enum.Enum): + Standard = "Standard" + Strict = "Strict" + + # -------------------------------------------------------------------- C_POSTGRESQL_CONF = "postgresql.conf" C_POSTGRESQL_AUTO_CONF = "postgresql.auto.conf" @@ -53,9 +60,14 @@ class PostgresConfiguration_Std(PostgresConfiguration_Base): "listen_addresses": g_OptionHandlers__Std__Str, "shared_preload_libraries": g_OptionHandlers__Std__UniqueStrList, "restart_after_crash": g_OptionHandlers__Std__Bool, + "max_connections": g_OptionHandlers__Std__Int, # PROXIMA ------------------------------------------------------------ "proxima.port": g_OptionHandlers__Std__Int, + "proxima.pool_size": g_OptionHandlers__Std__Int, + + # BIHA ------------------------------------------------------------ + "biha.node_id": g_OptionHandlers__Std__Int, # fmt: on } @@ -64,6 +76,7 @@ def __init__( self, data_dir: str, cfgOsOps: typing.Optional[ConfigurationOsOps] = None, + strategy: Strategy = Strategy.Strict, ): assert type(data_dir) is str assert cfgOsOps is None or isinstance(cfgOsOps, ConfigurationOsOps) @@ -73,10 +86,15 @@ def __init__( assert isinstance(cfgOsOps, ConfigurationOsOps) + dataStrategy = __class__.Helper__GetDataStrategy( + strategy, + ) + assert dataStrategy is not None + super().__init__( data_dir, cfgOsOps, - g_PgCfgBaseDataStrategy__Strict, + dataStrategy, ) return @@ -259,6 +277,23 @@ def Internal__GetOptionHandlerToWrite( return optionHandlers.Write # Helper methods ----------------------------------------------------- + @staticmethod + def Helper__GetDataStrategy( + strategy: Strategy, + ) -> PostgresConfiguration_Base.tagDataStrategy: + assert type(strategy) is __class__.Strategy + + if strategy == __class__.Strategy.Standard: + return g_PgCfgBaseDataStrategy__Standard + + if strategy == __class__.Strategy.Strict: + return g_PgCfgBaseDataStrategy__Strict + + BugCheckError.UnsupportedPgConfStrategy( + strategy, + ) + + # -------------------------------------------------------------------- def Helper__GetOptionHandlers( self, name: str, diff --git a/tests/TestServices.py b/tests/TestServices.py index 330aaf7..763ef33 100644 --- a/tests/TestServices.py +++ b/tests/TestServices.py @@ -97,6 +97,11 @@ def PrintExceptionOK(e: Exception): "OK. We catch an exception ({0}) - {1}".format(type(e).__name__, e) ) + # -------------------------------------------------------------------- + @staticmethod + def RaiseSkip_NotApplicable(): + pytest.skip("Тot applicable") + # -------------------------------------------------------------------- @staticmethod def ThrowWeWaitAnException(): diff --git a/tests/implementation/v00/configuration_std/Mix/test_set002__real_work.py b/tests/implementation/v00/configuration_std/Mix/test_set002__real_work.py new file mode 100644 index 0000000..82202f8 --- /dev/null +++ b/tests/implementation/v00/configuration_std/Mix/test_set002__real_work.py @@ -0,0 +1,158 @@ +# ////////////////////////////////////////////////////////////////////////////// +# Postgres Pro. PostgreSQL Configuration Python Library. Tests. + +# fmt: off +from src.implementation.v00.configuration_std import PostgresConfiguration_Std as PgCfg_Std +from src.implementation.v00.configuration_std import PostgresConfigurationReader_Base as PgCfg_Reader_Base +from src.implementation.v00.configuration_std import PostgresConfigurationWriterCtx_Base as PgCfg_WriterCtx_Base +from src.implementation.v00.configuration_std import PostgresConfigurationWriter_Base as PgCfg_Writer_Base + +from src.implementation.v00.configuration_base import PostgresConfigurationSetOptionValueEventID as PgCfg_SetOptionEventID + + +from .....TestServices import TestServices +# fmt: on + +import pytest +import os + +# ////////////////////////////////////////////////////////////////////////////// +# TestSet002__RealWork + + +class TestSet002__RealWork: + def test_001__modify_and_save_realistic_config__Standard( + self, + request: pytest.FixtureRequest, + ): + assert isinstance(request, pytest.FixtureRequest) + + # Author: Mark G. + + rootTmpDir = TestServices.GetCurTestTmpDir(request) + + os.makedirs(rootTmpDir, exist_ok=True) + + # --------------- + C_PG_CONF = PgCfg_Std.C_POSTGRESQL_CONF + C_BIHA_CONF = "postgresql.biha.conf" + C_PROXIMA_CONF = "postgresql.proxima.conf" + C_AUTO_CONF = PgCfg_Std.C_POSTGRESQL_AUTO_CONF + + # 1. Prepare initial files on disk with comments and duplicates + pgConfPath = os.path.join(rootTmpDir, C_PG_CONF) + with open(pgConfPath, "x") as f: + # fmt: off + f.write("# Main PostgreSQL config\n") + f.write("port = 5432 # default port\n") + f.write("max_connections = 100\n") + f.write("max_connections = 200 # inline override\n") + f.write("shared_preload_libraries = 'pg_stat_statements'\n") + f.write("include '{0}'\n".format(C_BIHA_CONF)) + f.write("include '{0}'\n".format(C_PROXIMA_CONF)) + f.write("listen_addresses = 'localhost'\n") + f.flush() + # fmt: on + f.close() + + bihaConfPath = os.path.join(rootTmpDir, C_BIHA_CONF) + with open(bihaConfPath, "x") as f: + # fmt: off + f.write("# BiHA settings\n") + f.write("shared_preload_libraries = 'pg_stat_statements, biha'\n") + f.write("biha.node_id = 1\n") + f.flush() + # fmt: on + f.close() + + proximaConfPath = os.path.join(rootTmpDir, C_PROXIMA_CONF) + with open(proximaConfPath, "x") as f: + # fmt: off + f.write("# Proxima settings\n") + f.write("proxima.port = 6432\n") + f.write("proxima.pool_size = 32\n") + f.flush() + # fmt: on + f.close() + + # Note: postgresql.auto.conf does NOT exist yet on disk + + # 2. Load configuration in Standard mode + cfg = PgCfg_Std( + rootTmpDir, + strategy=PgCfg_Std.Strategy.Standard, + ) + + pgFile = PgCfg_Reader_Base.LoadConfigurationFile(cfg, C_PG_CONF) + assert pgFile is not None + assert len(cfg.get_AllFiles()) == 3 + + bihaFile = cfg.get_AllFiles().GetFileByName(C_BIHA_CONF) + proximaFile = cfg.get_AllFiles().GetFileByName(C_PROXIMA_CONF) + + # 3. Perform modifications via object interfaces + + # 3.1. Global override -> must create postgresql.auto.conf and write there + r_port = cfg.SetOptionValue("port", 5433) + assert r_port.EventID == PgCfg_SetOptionEventID.OPTION_WAS_ADDED + assert r_port.Option is not None + assert r_port.Option.get_Parent().get_Parent().get_Path().endswith(C_AUTO_CONF) + + # 3.2. Global list item addition -> inherits active list from biha.conf + # and writes ['pg_stat_statements', 'biha', 'proxima'] into postgresql.auto.conf + r_libs = cfg.SetOptionValueItem("shared_preload_libraries", "proxima") + assert r_libs.EventID == PgCfg_SetOptionEventID.VALUE_ITEM_WAS_ADDED + assert r_libs.Option is not None + assert r_libs.Option.get_Value() == [ + "pg_stat_statements", + "biha", + "proxima", + ] + + # 3.3. File-scoped update -> updates existing option in-place inside biha.conf + r_biha = bihaFile.SetOptionValue("biha.node_id", 2) + assert r_biha.EventID == PgCfg_SetOptionEventID.OPTION_WAS_UPDATED + + # 3.4. File-scoped addition -> appends new option and comment to proxima.conf + proximaFile.AddComment("Added via API") + proximaFile.SetOptionValue("proxima.pool_size", 64) + + # 4. Save all changes to disk via Writer + # (Replace with your actual Writer call, e.g., PgCfg_Writer_Base.SaveConfiguration(cfg)) + writeCtx = PgCfg_WriterCtx_Base(cfg) + + PgCfg_Writer_Base.DoWork(writeCtx) + + # 5. Verify disk state by reloading into a fresh configuration instance + cfg_reloaded = PgCfg_Std( + rootTmpDir, + strategy=PgCfg_Std.Strategy.Standard, + ) + PgCfg_Reader_Base.LoadConfigurationFile(cfg_reloaded, C_PG_CONF) + PgCfg_Reader_Base.LoadConfigurationFile(cfg_reloaded, C_AUTO_CONF) + + assert len(cfg_reloaded.get_AllFiles()) == 4 + + # Check effective values after reload + assert cfg_reloaded.GetOptionValue("port") == 5433 + assert cfg_reloaded.GetOptionValue("max_connections") == 200 + assert cfg_reloaded.GetOptionValue("listen_addresses") == "localhost" + assert cfg_reloaded.GetOptionValue("biha.node_id") == 2 + assert cfg_reloaded.GetOptionValue("proxima.port") == 6432 + assert cfg_reloaded.GetOptionValue("proxima.pool_size") == 64 + assert cfg_reloaded.GetOptionValue("shared_preload_libraries") == [ + "pg_stat_statements", + "biha", + "proxima", + ] + + # Verify that original postgresql.conf preserved its comments and duplicates intact + pgFile_reloaded = cfg_reloaded.get_AllFiles().GetFileByName(C_PG_CONF) + assert pgFile_reloaded.GetOptionValue("port") == 5432 + assert pgFile_reloaded.GetOptionValue("max_connections") == 200 + assert len(pgFile_reloaded.get_Lines()) == 8 + + return + + +# ////////////////////////////////////////////////////////////////////////////// diff --git a/tests/implementation/v00/configuration_std/Mix/test_set003__edge_cases.py b/tests/implementation/v00/configuration_std/Mix/test_set003__edge_cases.py new file mode 100644 index 0000000..91e0418 --- /dev/null +++ b/tests/implementation/v00/configuration_std/Mix/test_set003__edge_cases.py @@ -0,0 +1,404 @@ +# ////////////////////////////////////////////////////////////////////////////// +# Postgres Pro. PostgreSQL Configuration Python Library. Tests. + +# fmt: off +from src.implementation.v00.configuration_std import PostgresConfiguration_Std as PgCfg_Std +from src.implementation.v00.configuration_std import PostgresConfigurationReader_Base as PgCfg_Reader_Base + +from src.implementation.v00.configuration_base import PostgresConfigurationSetOptionValueEventID as PgCfg_SetOptionEventID + +from src.exceptions import PostgresConfigException + +from .....TestServices import TestServices +# fmt: on + +import pytest +import logging +import os + +# ////////////////////////////////////////////////////////////////////////////// +# TestSet002__EdgeCases + + +class TestSet003__EdgeCases: + def test_001__diamond_include__Standard( + self, + request: pytest.FixtureRequest, + ): + assert isinstance(request, pytest.FixtureRequest) + + # Author: Mark G. + + rootTmpDir = TestServices.GetCurTestTmpDir(request) + os.makedirs(rootTmpDir, exist_ok=True) + + # --------------- + C_PG_CONF = PgCfg_Std.C_POSTGRESQL_CONF + C_COMMON_CONF = "common.conf" + C_OVERRIDE_CONF = "override.conf" + + # 1. Create common.conf with base port value + commonConfPath = os.path.join(rootTmpDir, C_COMMON_CONF) + logging.info("Creating {0}...".format(commonConfPath)) + with open(commonConfPath, "x") as f: + # fmt: off + f.write("# Common base configuration\n") + f.write("port = 5432\n") + f.flush() + # fmt: on + + # 2. Create override.conf which changes the port + overrideConfPath = os.path.join(rootTmpDir, C_OVERRIDE_CONF) + logging.info("Creating {0}...".format(overrideConfPath)) + with open(overrideConfPath, "x") as f: + # fmt: off + f.write("# Override configuration\n") + f.write("port = 5433\n") + f.flush() + # fmt: on + + # 3. Create postgresql.conf with diamond/repeated include: + # common.conf (5432) -> override.conf (5433) -> common.conf (5432) + pgConfPath = os.path.join(rootTmpDir, C_PG_CONF) + logging.info("Creating {0}...".format(pgConfPath)) + with open(pgConfPath, "x") as f: + # fmt: off + f.write("include '{0}'\n".format(C_COMMON_CONF)) + f.write("include '{0}'\n".format(C_OVERRIDE_CONF)) + f.write("include '{0}'\n".format(C_COMMON_CONF)) + f.flush() + # fmt: on + + # --------------- + # Initialize in Standard mode + cfg = PgCfg_Std( + rootTmpDir, + strategy=PgCfg_Std.Strategy.Standard, + ) + + # --------------- + # Load configuration + PgCfg_Reader_Base.LoadConfigurationFile(cfg, C_PG_CONF) + + # Should load 3 unique files despite repeated includes + assert len(cfg.get_AllFiles()) == 3 + + # Reverse DFS must hit the last include ('common.conf') first + # and return 5432, ignoring the earlier 'override.conf' (5433) + assert cfg.GetOptionValue("port") == 5432 + + # Total option instances across unique loaded files must be 2 + # (one in common.conf, one in override.conf) + assert len(cfg.get_AllOptions()) == 2 + return + + # -------------------------------------------------------------------- + def test_002__fallback_after_delete__Standard( + self, + request: pytest.FixtureRequest, + ): + assert isinstance(request, pytest.FixtureRequest) + + # Author: Mark G. + + rootTmpDir = TestServices.GetCurTestTmpDir(request) + os.makedirs(rootTmpDir, exist_ok=True) + + # --------------- + C_PG_CONF = PgCfg_Std.C_POSTGRESQL_CONF + C_AUTO_CONF = PgCfg_Std.C_POSTGRESQL_AUTO_CONF + + # 1. Create postgresql.conf with two inline definitions of max_connections + pgConfPath = os.path.join(rootTmpDir, C_PG_CONF) + with open(pgConfPath, "x") as f: + # fmt: off + f.write("max_connections = 100\n") + f.write("max_connections = 200\n") + f.flush() + # fmt: on + + # 2. Initialize in Standard mode and load postgresql.conf + cfg = PgCfg_Std( + rootTmpDir, + strategy=PgCfg_Std.Strategy.Standard, + ) + pgFile = PgCfg_Reader_Base.LoadConfigurationFile(cfg, C_PG_CONF) + + assert cfg.GetOptionValue("max_connections") == 200 + assert len(cfg.get_AllOptions()) == 2 + + # 3. Override globally -> creates postgresql.auto.conf with max_connections = 500 + r_auto = cfg.SetOptionValue("max_connections", 500) + assert r_auto.Option is not None + autoOpt = r_auto.Option + + autoLine = autoOpt.get_Parent() + assert autoLine.get_Parent().get_Path().endswith(C_AUTO_CONF) + assert cfg.GetOptionValue("max_connections") == 500 + assert len(cfg.get_AllOptions()) == 3 + + # 4. Clear the line containing the top-level override in postgresql.auto.conf + autoLine.Clear() + + # The line itself stays alive (now empty), but the option object must be dead + assert len(autoLine) == 0 + + with pytest.raises(PostgresConfigException): + autoOpt.get_Value() + + # Global value must fall back to the latest duplicate in postgresql.conf (200) + assert cfg.GetOptionValue("max_connections") == 200 + assert len(cfg.get_AllOptions()) == 2 + + # 5. Clear the second line in postgresql.conf (which holds max_connections = 200) + pgLines = list(pgFile.get_Lines()) + assert len(pgLines) == 2 + + pgLines[1].Clear() + + # Find the option object located on line 1 (comparing underlying m_FileLineData) + secondOpt = None + for opt in cfg.get_AllOptions(): + if opt.get_Parent().m_FileLineData.m_Parent is pgFile.m_FileData: + secondOpt = opt + break + + assert secondOpt is not None + assert secondOpt.get_Value() == 100 + + # Global value must now fall back to the very first definition (100) + assert cfg.GetOptionValue("max_connections") == 100 + assert len(cfg.get_AllOptions()) == 1 + return + + # -------------------------------------------------------------------- + def test_003__insert_include_after_option_and_update__Standard( + self, + request: pytest.FixtureRequest, + ): + assert isinstance(request, pytest.FixtureRequest) + + # Author: Mark G. + + rootTmpDir = TestServices.GetCurTestTmpDir(request) + os.makedirs(rootTmpDir, exist_ok=True) + + # --------------- + C_PG_CONF = PgCfg_Std.C_POSTGRESQL_CONF + C_OVERRIDE_CONF = "override.conf" + + # 1. Create override.conf on disk with port = 5433 + overrideConfPath = os.path.join(rootTmpDir, C_OVERRIDE_CONF) + with open(overrideConfPath, "x") as f: + # fmt: off + f.write("port = 5433\n") + f.flush() + # fmt: on + + # 2. Initialize in Standard mode and create top-level postgresql.conf + cfg = PgCfg_Std( + rootTmpDir, + strategy=PgCfg_Std.Strategy.Standard, + ) + pgFile = cfg.AddTopLevelFile(C_PG_CONF) + + # Add initial option: port = 5432 + r_init = pgFile.SetOptionValue("port", 5432) + assert r_init.EventID == PgCfg_SetOptionEventID.OPTION_WAS_ADDED + assert r_init.Option is not None + firstOpt = r_init.Option + + assert pgFile.GetOptionValue("port") == 5432 + assert cfg.GetOptionValue("port") == 5432 + + # 3. Append include directive AFTER the existing option + inc = pgFile.AddInclude(C_OVERRIDE_CONF) + incFile = inc.get_File() + + with cfg.m_Data.OsOps.OpenFileToRead(incFile.get_Path()) as f: + PgCfg_Reader_Base.LoadFileContent(incFile, f) + + # Now override.conf takes precedence (5433) + assert pgFile.GetOptionValue("port") == 5433 + assert cfg.GetOptionValue("port") == 5433 + + # 4. Update 'port' via pgFile.SetOptionValue + # Because an include exists below the initial option, enterIntoIncludes=False + # must prevent updating line 0 in-place and must append a new option at the tail. + r_upd = pgFile.SetOptionValue("port", 5434) + assert r_upd.EventID == PgCfg_SetOptionEventID.OPTION_WAS_ADDED + assert r_upd.Option is not None + lastOpt = r_upd.Option + + # Verify that a new distinct OptionData was created at the end of postgresql.conf + assert lastOpt.m_OptionData is not firstOpt.m_OptionData + assert firstOpt.get_Value() == 5432 + assert lastOpt.get_Value() == 5434 + + # Verify effective values across file and global config + assert pgFile.GetOptionValue("port") == 5434 + assert cfg.GetOptionValue("port") == 5434 + + # Total lines in postgresql.conf: + # 0: port = 5432 + # 1: include 'override.conf' + # 2: port = 5434 + assert len(pgFile.get_Lines()) == 3 + assert len(cfg.get_AllOptions()) == 3 + return + + # -------------------------------------------------------------------- + def test_004__global_reset_with_multiple_duplicates__Standard( + self, + request: pytest.FixtureRequest, + ): + assert isinstance(request, pytest.FixtureRequest) + + # Author: Mark G. + + rootTmpDir = TestServices.GetCurTestTmpDir(request) + os.makedirs(rootTmpDir, exist_ok=True) + + # --------------- + C_PG_CONF = PgCfg_Std.C_POSTGRESQL_CONF + C_BIHA_CONF = "postgresql.biha.conf" + + # 1. Create postgresql.conf with two definitions of 'port' (one with inline comment) + # and an unrelated option 'max_connections' + pgConfPath = os.path.join(rootTmpDir, C_PG_CONF) + with open(pgConfPath, "x") as f: + # fmt: off + f.write("port = 5432 # first def\n") + f.write("max_connections = 100\n") + f.write("port = 5433\n") + f.write("include '{0}'\n".format(C_BIHA_CONF)) + f.flush() + # fmt: on + + # 2. Create postgresql.biha.conf with a third definition of 'port' + bihaConfPath = os.path.join(rootTmpDir, C_BIHA_CONF) + with open(bihaConfPath, "x") as f: + # fmt: off + f.write("port = 5434\n") + f.flush() + # fmt: on + + # 3. Initialize in Standard mode and load files + cfg = PgCfg_Std( + rootTmpDir, + strategy=PgCfg_Std.Strategy.Standard, + ) + pgFile = PgCfg_Reader_Base.LoadConfigurationFile(cfg, C_PG_CONF) + bihaFile = cfg.get_AllFiles().GetFileByName(C_BIHA_CONF) + + assert cfg.GetOptionValue("port") == 5434 + # 3 instances of 'port' + 1 instance of 'max_connections' = 4 total + assert len(cfg.get_AllOptions()) == 4 + + # Collect references to all 3 'port' option objects before deletion + portOptions = [opt for opt in cfg.get_AllOptions() if opt.get_Name() == "port"] + assert len(portOptions) == 3 + + # 4. Perform global reset of 'port' (SetOptionValue with None) + res = cfg.SetOptionValue("port", None) + assert res.EventID == PgCfg_SetOptionEventID.OPTION_WAS_DELETED + assert res.Option is None + + # Verify 'port' is completely gone globally and from each file + assert cfg.GetOptionValue("port") is None + assert pgFile.GetOptionValue("port") is None + assert bihaFile.GetOptionValue("port") is None + + # Verify unrelated option 'max_connections' is untouched + assert cfg.GetOptionValue("max_connections") == 100 + assert len(cfg.get_AllOptions()) == 1 + + # Verify all 3 previously acquired Option objects are now dead + for opt in portOptions: + with pytest.raises(PostgresConfigException): + opt.get_Value() + + # Verify file lines structure is preserved: + # Line 0 in postgresql.conf still holds its inline comment '# first def' + pgLines = list(pgFile.get_Lines()) + assert len(pgLines) == 2 + assert len(pgLines[0]) == 1 + assert len(pgLines[1]) == 1 + + assert pgFile.GetOptionValue("max_connections") == 100 + + bihaLines = list(bihaFile.get_Lines()) + assert len(bihaLines) == 0 + + # 5. Repeated reset on already deleted option must return NONE event + res_again = cfg.SetOptionValue("port", None) + assert res_again.EventID == PgCfg_SetOptionEventID.NONE + return + + # -------------------------------------------------------------------- + def test_005__repeated_set_option_item_around_include__Standard( + self, + request: pytest.FixtureRequest, + ): + assert isinstance(request, pytest.FixtureRequest) + + # Author: Mark G. + + rootTmpDir = TestServices.GetCurTestTmpDir(request) + os.makedirs(rootTmpDir, exist_ok=True) + + # --------------- + C_PG_CONF = PgCfg_Std.C_POSTGRESQL_CONF + C_INC_CONF = "a.conf" + C_AUTO_CONF = PgCfg_Std.C_POSTGRESQL_AUTO_CONF + C_OPT_NAME = "shared_preload_libraries" + + # 1. Create empty a.conf and postgresql.conf with initial library + include + with open(os.path.join(rootTmpDir, C_INC_CONF), "x") as f: + f.flush() + + with open(os.path.join(rootTmpDir, C_PG_CONF), "x") as f: + # fmt: off + f.write("{0} = 'biha'\n".format(C_OPT_NAME)) + f.write("include '{0}'\n".format(C_INC_CONF)) + f.flush() + # fmt: on + + # 2. Load configuration in Standard mode + cfg = PgCfg_Std( + rootTmpDir, + strategy=PgCfg_Std.Strategy.Standard, + ) + pgFile = PgCfg_Reader_Base.LoadConfigurationFile(cfg, C_PG_CONF) + + assert cfg.GetOptionValue(C_OPT_NAME) == ["biha"] + assert len(cfg.get_AllOptions()) == 1 + + # 3. First global SetOptionValueItem -> creates entry in postgresql.auto.conf + r1 = cfg.SetOptionValueItem(C_OPT_NAME, "proxima") + assert r1.EventID == PgCfg_SetOptionEventID.VALUE_ITEM_WAS_ADDED + assert r1.Option is not None + assert r1.Option.get_Value() == ["biha", "proxima"] + assert r1.Option.get_Parent().get_Parent().get_Path().endswith(C_AUTO_CONF) + assert len(cfg.get_AllOptions()) == 2 + + # 4. Second global SetOptionValueItem -> must update the same entry in auto.conf + # without creating a third duplicate + r2 = cfg.SetOptionValueItem(C_OPT_NAME, "pg_stat_statements") + assert r2.EventID == PgCfg_SetOptionEventID.VALUE_ITEM_WAS_ADDED + assert r2.Option is not None + assert r2.Option.m_OptionData is r1.Option.m_OptionData + assert r2.Option.get_Value() == ["biha", "proxima", "pg_stat_statements"] + + # Verify total count and original file isolation + assert len(cfg.get_AllOptions()) == 2 + assert cfg.GetOptionValue(C_OPT_NAME) == [ + "biha", + "proxima", + "pg_stat_statements", + ] + assert pgFile.GetOptionValue(C_OPT_NAME) == ["biha"] + return + + +# ////////////////////////////////////////////////////////////////////////////// diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/AddOption/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/AddOption/test_set001__common.py index dc35285..4a61ca8 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/AddOption/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/AddOption/test_set001__common.py @@ -39,15 +39,20 @@ class TestSet001__Common: def test_001__int_opt( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -145,15 +150,20 @@ def Helper__CheckStateOfCfgWithOneIntOpt( def test_002__None_value( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -167,13 +177,18 @@ def test_002__None_value( def test_003__empty_name( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -187,13 +202,18 @@ def test_003__empty_name( def test_004__None_name( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -205,18 +225,26 @@ def test_004__None_name( # -------------------------------------------------------------------- @pytest.mark.parametrize("optName", sm_OPTS001, ids=lambda x: f"{x}") - def test_005__already_defined( + def test_005__00A__already_defined__Strict( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str + if pg_conf_strategy == PgCfg_Std.Strategy.Standard: + TestServices.RaiseSkip_NotApplicable() + rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=PgCfg_Std.Strategy.Strict, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -234,17 +262,75 @@ def test_005__already_defined( assert option.get_Value() == 123 return + # -------------------------------------------------------------------- + @pytest.mark.parametrize("optName", sm_OPTS001, ids=lambda x: f"{x}") + def test_005__00B__already_defined__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + optName: str, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + assert type(optName) is str + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=PgCfg_Std.Strategy.Standard, + ) + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert cfg.m_Data.m_DataDir == rootTmpDir + + option1 = cfg.AddOption(optName, 123) + assert option1 is not None + assert option1.m_FileLine is not None + assert option1.m_FileLine.get_Parent() is not None + assert option1.m_FileLine.get_Parent().m_FileData is not None + assert len(option1.m_FileLine.get_Parent().m_FileData.m_Lines) == 1 + + option2 = cfg.AddOption(optName, 321) + assert option2 is not None + assert option2.m_FileLine is not None + assert option2.m_FileLine.get_Parent() is not None + assert option2.m_FileLine.get_Parent().m_FileData is not None + assert len(option2.m_FileLine.get_Parent().m_FileData.m_Lines) == 2 + + assert option1 is not option2 + assert option1.m_FileLine is not option2.m_FileLine + assert ( + option1.m_FileLine.get_Parent().m_FileData + is option2.m_FileLine.get_Parent().m_FileData + ) + + assert option1.get_Name() == optName + assert option1.get_Value() == 123 + + assert option2.get_Name() == optName + assert option2.get_Value() == 321 + return + # -------------------------------------------------------------------- def test_006__two_options( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/AddTopLevelFile/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/AddTopLevelFile/test_set001__common.py index bf5761f..07e0eff 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/AddTopLevelFile/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/AddTopLevelFile/test_set001__common.py @@ -19,13 +19,18 @@ class TestSet001__Common: def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) C_FILE_NAME = "postgresql.auto.conf" diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/GetOptionValue/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/GetOptionValue/test_set001__common.py index 98db67e..08fbddf 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/GetOptionValue/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/GetOptionValue/test_set001__common.py @@ -30,15 +30,20 @@ class TestSet001__Common: def test_001__port( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) set_r = cfg.SetOptionValue(optName, 123) assert type(set_r) is PgCfg_SetOptionResult_Base @@ -63,13 +68,18 @@ def test_001__port( def test_002__None_name( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) with pytest.raises(PostgresConfigException) as x: cfg.GetOptionValue(None) @@ -81,13 +91,18 @@ def test_002__None_name( def test_003__empty_name( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) with pytest.raises(PostgresConfigException) as x: cfg.GetOptionValue("") @@ -99,20 +114,274 @@ def test_003__empty_name( def test_004__opt_with_list__get_None( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) v = cfg.GetOptionValue(C_OPT_NAME) assert v is None return + # -------------------------------------------------------------------- + def test_005__mult_opts_in_auto__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + C_OPT_NAME = "port" + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + opt1 = cfg.AddOption(C_OPT_NAME, 1) + assert opt1 is not None + + opt2 = cfg.AddOption(C_OPT_NAME, 2) + assert opt2 is not None + + assert opt1.m_OptionData is not opt2.m_OptionData + + assert opt1.get_Name() == C_OPT_NAME + assert opt1.get_Value() == 1 + + assert opt2.get_Name() == C_OPT_NAME + assert opt2.get_Value() == 2 + + # ---------- + v = cfg.GetOptionValue(C_OPT_NAME) + assert v is not None + assert type(v) is int + assert v == 2 + + return + + # -------------------------------------------------------------------- + def test_006__mult_opts_in_pgconf__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + C_OPT_NAME = "port" + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file1 = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) + + opt1 = file1.AddOption(C_OPT_NAME, 1) + assert opt1 is not None + + opt2 = file1.AddOption(C_OPT_NAME, 2) + assert opt2 is not None + + assert opt1.m_OptionData is not opt2.m_OptionData + + assert opt1.get_Name() == C_OPT_NAME + assert opt1.get_Value() == 1 + + assert opt2.get_Name() == C_OPT_NAME + assert opt2.get_Value() == 2 + + # ---------- + v = cfg.GetOptionValue(C_OPT_NAME) + assert v is not None + assert type(v) is int + assert v == 2 + + return + + # -------------------------------------------------------------------- + def test_007__mult_opts_and_includes__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + C_OPT_NAME = "port" + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file1 = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) + assert file1 is not None + file2 = cfg.AddTopLevelFile("a.conf") + assert file2 is not None + file3 = cfg.AddTopLevelFile("b.conf") + assert file3 is not None + file4 = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_AUTO_CONF) + assert file4 is not None + + opt1 = file2.AddOption(C_OPT_NAME, 1) + assert opt1 is not None + + opt2 = file2.AddOption(C_OPT_NAME, 2) + assert opt2 is not None + + file2.AddInclude("b.conf") + file2.AddInclude("b.conf") + + file4.AddInclude("b.conf") + file4.AddComment("O-LA-LA") + file4.AddEmptyLine() + file4.AddOption("blablabla", "123") + + assert opt1.m_OptionData is not opt2.m_OptionData + + assert opt1.get_Name() == C_OPT_NAME + assert opt1.get_Value() == 1 + + assert opt2.get_Name() == C_OPT_NAME + assert opt2.get_Value() == 2 + + # ---------- + v = cfg.GetOptionValue(C_OPT_NAME) + assert v is not None + assert type(v) is int + assert v == 2 + + return + + # -------------------------------------------------------------------- + def test_008__opt_in_include( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + C_OPT_NAME = "port" + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file1 = cfg.AddTopLevelFile("a.conf") + assert file1 is not None + file2 = file1.AddInclude("b.conf").get_File() + assert file2 is not None + file3 = file1.AddInclude("c.conf").get_File() + assert file3 is not None + + option = file3.AddOption(C_OPT_NAME, 321) + assert option is not None + + v = cfg.GetOptionValue(C_OPT_NAME) + assert v is not None + assert type(v) is int + assert v == 321 + + # -------------------------------------------------------------------- + def test_009__cycle_in_files( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file1 = cfg.AddTopLevelFile("a.conf") + assert file1 is not None + file2 = file1.AddInclude("b.conf").get_File() + assert file2 is not None + file3 = file1.AddInclude("c.conf").get_File() + assert file3 is not None + + file1a = file3.AddInclude("a.conf").get_File() + assert file1a is not None + assert file1.m_FileData is file1a.m_FileData + + v = cfg.GetOptionValue("a") + assert v is None + return + + # -------------------------------------------------------------------- + def test_010__subcycle_in_files( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file1 = cfg.AddTopLevelFile("a.conf") + assert file1 is not None + file2 = file1.AddInclude("b.conf").get_File() + assert file2 is not None + file3 = file1.AddInclude("c.conf").get_File() + assert file3 is not None + + file2a = file3.AddInclude("b.conf").get_File() + assert file2a is not None + assert file2.m_FileData is file2a.m_FileData + + v = cfg.GetOptionValue("c") + assert v is None + return + # ////////////////////////////////////////////////////////////////////////////// diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/Mix/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/Mix/test_set001__common.py index d0973f0..f82571b 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/Mix/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/Mix/test_set001__common.py @@ -19,13 +19,18 @@ class TestSet001__Common: def test_001__get_Configuration( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -36,13 +41,18 @@ def test_001__get_Configuration( def test_002__get_Parent( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/SetOptionValue/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/SetOptionValue/test_set001__common.py index 771960e..446a95a 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/SetOptionValue/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/SetOptionValue/test_set001__common.py @@ -43,15 +43,20 @@ class TestSet001__Common: def test_001__int_opt( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -80,15 +85,20 @@ def test_001__int_opt( def test_002__port___reasign( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -183,13 +193,18 @@ def Helper__CheckStateOfCfgWithOneOpt( def test_003__port___bad_type( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) with pytest.raises(PostgresConfigException) as x: cfg.SetOptionValue("port", True) @@ -206,13 +221,18 @@ def test_003__port___bad_type( def test_004__port___cont_convert_value( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) with pytest.raises(PostgresConfigException) as x: cfg.SetOptionValue("port", "123.") @@ -230,15 +250,20 @@ def test_004__port___cont_convert_value( def test_006( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -276,15 +301,20 @@ def test_006( def test_007__set_None( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -302,15 +332,20 @@ def test_007__set_None( def test_008__set_Int_set_None( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -384,7 +419,7 @@ def test_008__set_Int_set_None( return # -------------------------------------------------------------------- - def test_009__spec_file( + def test_009__spec_file__Strict( self, request: pytest.FixtureRequest, ): @@ -393,7 +428,10 @@ def test_009__spec_file( rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=PgCfg_Std.Strategy.Strict, + ) file1 = cfg.AddTopLevelFile("postgresql.proxima.conf") assert file1 is not None @@ -455,13 +493,18 @@ def test_009__spec_file( def test_010__None_name( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) with pytest.raises(PostgresConfigException) as x: cfg.SetOptionValue(None, 123) @@ -473,13 +516,18 @@ def test_010__None_name( def test_011__empty_name( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) with pytest.raises(PostgresConfigException) as x: cfg.SetOptionValue("", 123) @@ -509,16 +557,21 @@ def data012( def test_012__one_opt( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, data012: typing.Tuple[str, typing.Any, typing.Any], ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(data012) is tuple assert len(data012) == 3 rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -540,5 +593,179 @@ def test_012__one_opt( ) return + # -------------------------------------------------------------------- + def test_013__set_twice( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert cfg.m_Data.m_DataDir == rootTmpDir + + C_OPT_NAME = "port" + + r1 = cfg.SetOptionValue(C_OPT_NAME, 123) + assert r1 is not None + assert r1.Option is not None + assert r1.Option.get_Name() == C_OPT_NAME + assert r1.Option.get_Value() == 123 + + r2 = cfg.SetOptionValue(C_OPT_NAME, 321) + assert r2 is not None + assert r2.Option is not None + assert r2.Option.get_Name() == C_OPT_NAME + assert r2.Option.get_Value() == 321 + + assert r1.Option.m_OptionData is r2.Option.m_OptionData + return + + # -------------------------------------------------------------------- + def test_014__00A__opt_in_file__Strict( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Standard: + TestServices.RaiseSkip_NotApplicable() + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert cfg.m_Data.m_DataDir == rootTmpDir + + C_OPT_NAME = "port" + + file1 = cfg.AddTopLevelFile("file1.conf") + + r1 = file1.SetOptionValue(C_OPT_NAME, 123) + assert r1 is not None + assert r1.Option is not None + assert r1.Option.get_Name() == C_OPT_NAME + assert r1.Option.get_Value() == 123 + + r2 = cfg.SetOptionValue(C_OPT_NAME, 321) + assert r2 is not None + assert r2.Option is not None + assert r2.Option.get_Name() == C_OPT_NAME + assert r2.Option.get_Value() == 321 + + assert r1.Option.m_OptionData is r2.Option.m_OptionData + + assert cfg.GetOptionValue(C_OPT_NAME) == 321 + return + + # -------------------------------------------------------------------- + def test_014__00B__opt_in_file__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert cfg.m_Data.m_DataDir == rootTmpDir + + C_OPT_NAME = "port" + + file1 = cfg.AddTopLevelFile("file1.conf") + assert file1.get_Path() == cfg.m_Data.OsOps.Path_Join( + rootTmpDir, + "file1.conf", + ) + + r1 = file1.SetOptionValue(C_OPT_NAME, 123) + assert r1 is not None + assert r1.Option is not None + assert r1.Option.get_Name() == C_OPT_NAME + assert r1.Option.get_Value() == 123 + + r2 = cfg.SetOptionValue(C_OPT_NAME, 321) + assert r2 is not None + assert r2.Option is not None + assert r2.Option.get_Name() == C_OPT_NAME + assert r2.Option.get_Value() == 321 + r2_file = r2.Option.get_Parent().get_Parent() + assert r2_file.get_Path() == cfg.m_Data.OsOps.Path_Join( + rootTmpDir, + cfg.C_POSTGRESQL_AUTO_CONF, + ) + + assert r1.Option.m_OptionData is not r2.Option.m_OptionData + + assert cfg.GetOptionValue(C_OPT_NAME) == 321 + assert file1.GetOptionValue(C_OPT_NAME) == 123 + return + + # -------------------------------------------------------------------- + def test_015__set_twice_around_include__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert cfg.m_Data.m_DataDir == rootTmpDir + + C_OPT_NAME = "port" + + r1 = cfg.SetOptionValue(C_OPT_NAME, 1) + assert r1.EventID == PgCfg_SetOptionEventID.OPTION_WAS_ADDED + assert r1.Option is not None + assert r1.Option.get_Value() == 1 + file2 = r1.Option.get_Parent().get_Parent().AddInclude("a.conf") + assert file2 is not None + assert cfg.GetOptionValue(C_OPT_NAME) == 1 + assert r1.Option.get_Value() == 1 + r2 = cfg.SetOptionValue(C_OPT_NAME, 2) + assert r2.EventID == PgCfg_SetOptionEventID.OPTION_WAS_ADDED + assert r2.Option is not None + assert r2.Option.get_Value() == 2 + assert r2.Option.m_OptionData is not r1.Option.m_OptionData + assert r1.Option.get_Value() == 1 + + assert cfg.GetOptionValue(C_OPT_NAME) == 2 + return + # ////////////////////////////////////////////////////////////////////////////// diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/SetOptionValueItem/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/SetOptionValueItem/test_set001__common.py index 48e1022..30cfec6 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/SetOptionValueItem/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/SetOptionValueItem/test_set001__common.py @@ -26,15 +26,20 @@ class TestSet001__Common: def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) for nPass in range(3): logging.info("--------- pass: {0}".format(nPass)) @@ -76,8 +81,10 @@ def test_001( def test_002( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" @@ -86,7 +93,10 @@ def test_002( rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) expectedValue: typing.List[str] = list() @@ -152,15 +162,20 @@ def test_002( def test_003( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) r1 = cfg.SetOptionValueItem(C_OPT_NAME, "biha") @@ -176,15 +191,20 @@ def test_003( def test_004__check_get_prepare_filter__unique( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) r1 = cfg.SetOptionValueItem(C_OPT_NAME, "biha") @@ -203,15 +223,20 @@ def test_004__check_get_prepare_filter__unique( def test_005__check_get_prepare_filter__to_str( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) r1 = cfg.SetOptionValueItem(C_OPT_NAME, "biha") @@ -232,15 +257,20 @@ def test_005__check_get_prepare_filter__to_str( def test_006__set_value_item_with_bad_type( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) r1 = cfg.SetOptionValueItem(C_OPT_NAME, "biha") @@ -266,15 +296,20 @@ def test_006__set_value_item_with_bad_type( def test_007__set_None( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) r1 = cfg.SetOptionValueItem(C_OPT_NAME, "biha") @@ -292,5 +327,82 @@ def test_007__set_None( assert r1.Option.get_Value() == ["biha"] return + # -------------------------------------------------------------------- + def test_008__two_items( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + C_OPT_NAME = "shared_preload_libraries" + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + r1 = cfg.SetOptionValueItem(C_OPT_NAME, "biha") + assert r1 is not None + assert type(r1) is PgCfg_SetOptionResult_Base + assert r1.Option is not None + assert r1.Option.get_Value() == ["biha"] + + r2 = cfg.SetOptionValueItem(C_OPT_NAME, "proxima") + assert r2 is not None + assert type(r2) is PgCfg_SetOptionResult_Base + assert r2.EventID == PgCfg_SetOptionEventID.VALUE_ITEM_WAS_ADDED + assert r2.Option is not None + assert r2.Option.get_Value() == ["biha", "proxima"] + + assert r1.Option.get_Value() == ["biha", "proxima"] + return + + # -------------------------------------------------------------------- + def test_009__two_items__arround_include__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + C_OPT_NAME = "shared_preload_libraries" + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + r1 = cfg.SetOptionValueItem(C_OPT_NAME, "biha") + assert r1 is not None + assert type(r1) is PgCfg_SetOptionResult_Base + assert r1.Option is not None + assert r1.Option.get_Value() == ["biha"] + + r1.Option.get_Parent().get_Parent().AddInclude("a.conf") + + r2 = cfg.SetOptionValueItem(C_OPT_NAME, "proxima") + assert r2 is not None + assert type(r2) is PgCfg_SetOptionResult_Base + assert r2.EventID == PgCfg_SetOptionEventID.VALUE_ITEM_WAS_ADDED + assert r2.Option is not None + assert r2.Option.get_Value() == ["biha", "proxima"] + + assert r1.Option.m_OptionData is not r2.Option.m_OptionData + + assert r1.Option.get_Value() == ["biha"] + return + # ////////////////////////////////////////////////////////////////////////////// diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/get_AllFiles/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/get_AllFiles/test_set001__common.py index 9fa4f4b..3b5232d 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/get_AllFiles/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/get_AllFiles/test_set001__common.py @@ -26,13 +26,18 @@ class TestSet001__Common: def test_000( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) allFiles1 = cfg.get_AllFiles() assert allFiles1 is not None @@ -51,15 +56,20 @@ def test_000( def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) cfg.SetOptionValue(optName, 123) @@ -88,13 +98,18 @@ def test_001( def test_002__iter( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) allFiles1 = cfg.get_AllFiles() assert type(allFiles1) is PgCfg_Base__AllFiles @@ -121,13 +136,18 @@ def test_002__iter( def test_003__transform_to_list( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) allFiles1 = cfg.get_AllFiles() v = list(allFiles1) diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/get_AllOptions/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/get_AllOptions/test_set001__common.py index 126213a..8e99223 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/get_AllOptions/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfiguration/get_AllOptions/test_set001__common.py @@ -26,13 +26,18 @@ class TestSet001__Common: def test_000( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) allOptions1 = cfg.get_AllOptions() assert allOptions1 is not None @@ -51,15 +56,20 @@ def test_000( def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) cfg.SetOptionValue(optName, 123) @@ -90,13 +100,18 @@ def test_001( def test_002__iter( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) allOptions1 = cfg.get_AllOptions() assert type(allOptions1) is PgCfg_Base__AllOptions @@ -123,13 +138,18 @@ def test_002__iter( def test_003__transform_to_list( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) allOptions1 = cfg.get_AllOptions() v = list(allOptions1) @@ -144,13 +164,18 @@ def test_003__transform_to_list( def test_004__two_options( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) cfg.SetOptionValue("port", 123) cfg.SetOptionValue("proxima.port", 321) diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddComment/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddComment/test_set001__common.py index 19aaed7..2bf6bb5 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddComment/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddComment/test_set001__common.py @@ -43,15 +43,20 @@ def offset001( def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, offset001: typing.Optional[int], ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert offset001 is None or type(offset001) is int rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -82,13 +87,18 @@ def test_001( def test_E01__second_comment_in_line( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -124,13 +134,18 @@ def test_E01__second_comment_in_line( def test_E02__bad_symbol( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddInclude/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddInclude/test_set001__common.py index 94b6172..59fc3a5 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddInclude/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddInclude/test_set001__common.py @@ -7,6 +7,8 @@ from src.implementation.v00.configuration_base import PostgresConfigurationIncludedFile_Base as PgCfg_IncludedFile_Base from src.implementation.v00.configuration_base import PostgresConfigurationInclude_Base as PgCfg_Include_Base from src.implementation.v00.configuration_base import PostgresConfigurationOption_Base as PgCfg_Option_Base +from src.implementation.v00.configuration_base import PostgresConfigurationFile_Base as PgCfg_File_Base +from src.implementation.v00.configuration_base import PostgresConfigurationFileLine_Base as PgCfg_FileLine_Base from src.implementation.v00.configuration_base import PgCfgModel__OptionData from src.implementation.v00.configuration_base import PgCfgModel__IncludeData @@ -19,6 +21,7 @@ import pytest import os import typing +import logging # ////////////////////////////////////////////////////////////////////////////// # TestSet001__Common @@ -47,15 +50,20 @@ def offset001( def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, offset001: typing.Optional[int], ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert offset001 is None or type(offset001) is int rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -65,7 +73,74 @@ def test_001( C_FILE_NAME = "a.conf" - include = fileLine.AddInclude(C_FILE_NAME, offset001) + __class__.Helper__AddLineAndInclude( + file, + C_FILE_NAME, + offset001, + rootTmpDir, + ) + return + + # -------------------------------------------------------------------- + def test_002__multiple( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + offset001: typing.Optional[int], + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + assert offset001 is None or type(offset001) is int + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) + + C_FILE_NAME = "a.conf" + C_INCLUDES = 3 + + passN = 0 + + while passN < C_INCLUDES: + passN += 1 + + logging.info("------------- pass: {}".format(passN)) + + __class__.Helper__AddLineAndInclude( + file, + C_FILE_NAME, + offset001, + rootTmpDir, + ) + continue + + assert len(file.get_Lines()) == C_INCLUDES + assert len(file.m_FileData.m_Lines) == C_INCLUDES + + return + + # -------------------------------------------------------------------- + @staticmethod + def Helper__AddLineAndInclude( + file: PgCfg_File_Base, + name: str, + offset: typing.Optional[int], + rootTmpDir: str, + ) -> typing.Tuple[PgCfg_FileLine_Base, PgCfg_Include_Base]: + + fileLine = file.AddEmptyLine() + + assert len(fileLine) == 0 + + C_FILE_NAME = "a.conf" + + include = fileLine.AddInclude(name, offset) assert len(fileLine) == 1 @@ -74,13 +149,13 @@ def test_001( assert include.m_FileLine.m_FileLineData is fileLine.m_FileLineData assert include.m_FileLine is fileLine assert type(include.m_IncludeData) is PgCfgModel__IncludeData - assert include.m_IncludeData.m_Offset == offset001 + assert include.m_IncludeData.m_Offset == offset assert include.m_IncludeData.IsAlive() assert include.m_IncludeData.m_Path == C_FILE_NAME assert include.m_IncludeData.m_Parent == fileLine.m_FileLineData - assert include.get_Configuration() is cfg + assert include.get_Configuration() is file.get_Configuration() assert include.get_Parent() is fileLine includedFile = include.get_File() @@ -88,19 +163,25 @@ def test_001( # assert include.get_File() is includedFile assert includedFile.get_Path() == os.path.join(rootTmpDir, C_FILE_NAME) assert includedFile.get_Parent() is include - return + + return (fileLine, include) # -------------------------------------------------------------------- def test_E01__after_option( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -140,13 +221,18 @@ def test_E01__after_option( def test_E02__after_include( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -170,13 +256,18 @@ def test_E02__after_include( def test_E03__after_comment( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddOption/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddOption/test_set001__common.py index 83293da..8e97b29 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddOption/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/AddOption/test_set001__common.py @@ -43,15 +43,20 @@ def offset001( def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, offset001: typing.Optional[int], ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert offset001 is None or type(offset001) is int rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -84,15 +89,20 @@ def test_001( def test_002__shared_preload_libraries( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, offset001: typing.Optional[int], ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert offset001 is None or type(offset001) is int rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -130,15 +140,20 @@ def test_002__shared_preload_libraries( def test_003__shared_preload_libraries__as_str( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, offset001: typing.Optional[int], ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert offset001 is None or type(offset001) is int rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -176,13 +191,18 @@ def test_003__shared_preload_libraries__as_str( def test_004__shared_preload_libraries__with_None_item( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -207,13 +227,18 @@ def test_004__shared_preload_libraries__with_None_item( def test_E01__after_option( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -252,13 +277,18 @@ def test_E01__after_option( def test_E02__after_include( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -281,13 +311,18 @@ def test_E02__after_include( def test_E03__after_comment( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -307,16 +342,24 @@ def test_E03__after_comment( return # -------------------------------------------------------------------- - def test_E04__conflict_with_this_file( + def test_X04__00A__conflict_with_this_file__Strict( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Standard: + TestServices.RaiseSkip_NotApplicable() rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -328,7 +371,7 @@ def test_E04__conflict_with_this_file( assert len(fileLine2) == 0 with pytest.raises(PostgresConfigException) as x: - fileLine2.AddOption("port", 321, 2) + fileLine2.AddOption("port", 321, 22) assert str(x.value) == ErrorMessageBuilder.OptionIsAlreadyExistInThisFile( file.get_Path(), @@ -354,16 +397,107 @@ def test_E04__conflict_with_this_file( return # -------------------------------------------------------------------- - def test_E05__conflict_with_another_file( + def test_X04__00B__conflict_with_this_file__Standard( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) + + fileLine1 = file.AddEmptyLine() + assert len(fileLine1) == 0 + option1 = fileLine1.AddOption("port", 123, 2) + + fileLine2 = file.AddEmptyLine() + assert len(fileLine2) == 0 + option2 = fileLine2.AddOption("port", 321, 22) + + assert len(fileLine1) == 1 + assert len(fileLine2) == 1 + + assert option1.m_OptionData.IsAlive() + assert fileLine1.m_FileLineData.IsAlive() + assert fileLine1.m_FileLineData.m_Parent is not None + assert fileLine1.m_FileLineData.m_Parent.IsAlive() + + assert option2.m_OptionData.IsAlive() + assert fileLine2.m_FileLineData.IsAlive() + assert fileLine2.m_FileLineData.m_Parent is not None + assert fileLine2.m_FileLineData.m_Parent.IsAlive() + + assert fileLine1.m_FileLineData is not fileLine2.m_FileLineData + assert option1.m_OptionData is not option2.m_OptionData + assert fileLine1.m_FileLineData.m_Parent is fileLine2.m_FileLineData.m_Parent + + # ------------- + assert option1 is not None + assert type(option1) is PgCfg_Option_Base + assert option1.m_FileLine.m_FileLineData is fileLine1.m_FileLineData + assert type(option1.m_OptionData) is PgCfgModel__OptionData + assert option1.m_OptionData.m_Offset == 2 + + assert option1.m_OptionData.IsAlive() + assert option1.m_OptionData.m_Name == "port" + assert option1.m_OptionData.m_Value == 123 + assert option1.m_OptionData.m_Parent == fileLine1.m_FileLineData + + assert option1.get_Configuration() is cfg + assert option1.get_Parent().m_FileLineData is fileLine1.m_FileLineData + assert option1.get_Name() == "port" + assert option1.get_Value() == 123 + + # ------------- + assert option2 is not None + assert type(option2) is PgCfg_Option_Base + assert option2.m_FileLine.m_FileLineData is fileLine2.m_FileLineData + assert type(option2.m_OptionData) is PgCfgModel__OptionData + assert option2.m_OptionData.m_Offset == 22 + + assert option2.m_OptionData.IsAlive() + assert option2.m_OptionData.m_Name == "port" + assert option2.m_OptionData.m_Value == 321 + assert option2.m_OptionData.m_Parent == fileLine2.m_FileLineData + + assert option2.get_Configuration() is cfg + assert option2.get_Parent().m_FileLineData is fileLine2.m_FileLineData + assert option2.get_Name() == "port" + assert option2.get_Value() == 321 + + return + + # -------------------------------------------------------------------- + def test_X05__00A__conflict_with_another_file__Strict( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Standard: + TestServices.RaiseSkip_NotApplicable() + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) fileLine = file.AddEmptyLine() @@ -400,5 +534,98 @@ def test_E05__conflict_with_another_file( assert option.get_Value() == 123 return + # -------------------------------------------------------------------- + def test_X05__00B__conflict_with_another_file__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file1 = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) + fileLine1 = file1.AddEmptyLine() + assert len(fileLine1) == 0 + option1 = fileLine1.AddOption("port", 123, 2) + assert option1 is not None + assert len(fileLine1) == 1 + + file2 = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_AUTO_CONF) + fileLine2 = file2.AddEmptyLine() + assert len(fileLine2) == 0 + option2 = fileLine2.AddOption("port", 321, 22) + assert option2 is not None + assert len(fileLine2) == 1 + + # again + assert len(fileLine1) == 1 + + # --------- + assert option1.m_OptionData.IsAlive() + assert fileLine1.m_FileLineData.IsAlive() + assert fileLine1.m_FileLineData.m_Parent is not None + assert fileLine1.m_FileLineData.m_Parent.IsAlive() + + assert option2.m_OptionData.IsAlive() + assert fileLine2.m_FileLineData.IsAlive() + assert fileLine2.m_FileLineData.m_Parent is not None + assert fileLine2.m_FileLineData.m_Parent.IsAlive() + + assert fileLine1.m_FileLineData is not fileLine2.m_FileLineData + assert option1.m_OptionData is not option2.m_OptionData + assert ( + fileLine1.m_FileLineData.m_Parent is not fileLine2.m_FileLineData.m_Parent + ) + + assert fileLine1.m_FileLineData.m_Parent is file1.m_FileData + assert fileLine2.m_FileLineData.m_Parent is file2.m_FileData + + # --------- + assert option1 is not None + assert type(option1) is PgCfg_Option_Base + assert option1.m_FileLine.m_FileLineData is fileLine1.m_FileLineData + assert type(option1.m_OptionData) is PgCfgModel__OptionData + assert option1.m_OptionData.m_Offset == 2 + + assert option1.m_OptionData.IsAlive() + assert option1.m_OptionData.m_Name == "port" + assert option1.m_OptionData.m_Value == 123 + assert option1.m_OptionData.m_Parent == fileLine1.m_FileLineData + + assert option1.get_Configuration() is cfg + assert option1.get_Parent().m_FileLineData is fileLine1.m_FileLineData + assert option1.get_Name() == "port" + assert option1.get_Value() == 123 + + # --------- + assert option2 is not None + assert type(option2) is PgCfg_Option_Base + assert option2.m_FileLine.m_FileLineData is fileLine2.m_FileLineData + assert type(option2.m_OptionData) is PgCfgModel__OptionData + assert option2.m_OptionData.m_Offset == 22 + + assert option2.m_OptionData.IsAlive() + assert option2.m_OptionData.m_Name == "port" + assert option2.m_OptionData.m_Value == 321 + assert option2.m_OptionData.m_Parent == fileLine2.m_FileLineData + + assert option2.get_Configuration() is cfg + assert option2.get_Parent().m_FileLineData is fileLine2.m_FileLineData + assert option2.get_Name() == "port" + assert option2.get_Value() == 321 + + return + # ////////////////////////////////////////////////////////////////////////////// diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/Clear/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/Clear/test_set001__common.py index 7babd11..09156f4 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/Clear/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationFileLine/Clear/test_set001__common.py @@ -38,13 +38,18 @@ class TestSet001__Common: def test_001__line_with_option( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) set_r = cfg.SetOptionValue("port", 123) assert set_r is not None @@ -125,13 +130,18 @@ def test_001__line_with_option( def test_002__line_with_comment( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) cfg.SetOptionValue("port", 123) diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationOption/set_ValueItem/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationOption/set_ValueItem/test_set001__common.py index ee9f978..35f79d5 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationOption/set_ValueItem/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationOption/set_ValueItem/test_set001__common.py @@ -29,15 +29,20 @@ class TestSet001__Common: def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -84,15 +89,20 @@ def test_001( def test_002__set_None( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -117,15 +127,20 @@ def test_002__set_None( def test_003__set_value_item_with_bad_type( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -154,15 +169,20 @@ def test_003__set_value_item_with_bad_type( def test_004_set_list( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir @@ -183,15 +203,20 @@ def test_004_set_list( def test_005__set_str( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert type(cfg.m_Data) is PgCfgModel__ConfigurationData assert cfg.m_Data.m_DataDir == rootTmpDir diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationReader_Base/LoadConfigurationFile/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationReader_Base/LoadConfigurationFile/test_set001__common.py index d82044a..f114e16 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationReader_Base/LoadConfigurationFile/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationReader_Base/LoadConfigurationFile/test_set001__common.py @@ -32,7 +32,11 @@ class TestSet001__Common: def test_000__empty( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + rootTmpDir = TestServices.GetCurTestTmpDir(request) os.makedirs(rootTmpDir, exist_ok=True) @@ -50,7 +54,10 @@ def test_000__empty( f.close() # --------------- - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) # --------------- logging.info("File object is loading...") @@ -73,7 +80,11 @@ def test_000__empty( def test_001__comment_and_options( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + rootTmpDir = TestServices.GetCurTestTmpDir(request) os.makedirs(rootTmpDir, exist_ok=True) @@ -100,7 +111,10 @@ def test_001__comment_and_options( f.close() # --------------- - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) # --------------- logging.info("File object is loading...") @@ -162,7 +176,11 @@ def test_001__comment_and_options( def test_002__two_files( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + rootTmpDir = TestServices.GetCurTestTmpDir(request) os.makedirs(rootTmpDir, exist_ok=True) @@ -206,7 +224,10 @@ def test_002__two_files( f.close() # --------------- - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) # --------------- logging.info("File {0} is loading...".format(C_FILE_NAME1)) @@ -235,7 +256,11 @@ def test_002__two_files( def test_003__two_files__duplication_and_cycles( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + rootTmpDir = TestServices.GetCurTestTmpDir(request) os.makedirs(rootTmpDir, exist_ok=True) @@ -282,7 +307,10 @@ def test_003__two_files__duplication_and_cycles( f.close() # --------------- - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) # --------------- logging.info("File {0} is loading...".format(C_FILE_NAME1)) @@ -300,5 +328,184 @@ def test_003__two_files__duplication_and_cycles( assert file2.GetOptionValue("port") == 123 return + # -------------------------------------------------------------------- + def test_004__realistic_config_overrides__Standard( + self, + request: pytest.FixtureRequest, + ): + assert isinstance(request, pytest.FixtureRequest) + + # Author: Mark G. + + rootTmpDir = TestServices.GetCurTestTmpDir(request) + + os.makedirs(rootTmpDir, exist_ok=True) + + # --------------- + C_PG_CONF = PgCfg_Std.C_POSTGRESQL_CONF + C_BIHA_CONF = "postgresql.biha.conf" + C_PROXIMA_CONF = "postgresql.proxima.conf" + C_AUTO_CONF = PgCfg_Std.C_POSTGRESQL_AUTO_CONF + + # 1. Create main postgresql.conf + # Contains base settings, an inline duplicate, and includes for extensions. + pgConfPath = os.path.join(rootTmpDir, C_PG_CONF) + logging.info("Creating {0}...".format(pgConfPath)) + + with open(pgConfPath, "x") as f: + # fmt: off + f.write("# Base PostgreSQL configuration\n") + f.write("listen_addresses = 'localhost'\n") + f.write("port = 5432\n") + f.write("max_connections = 100\n") + f.write("shared_buffers = '128MB'\n") + f.write("shared_preload_libraries = 'pg_stat_statements'\n") + f.write("\n") + f.write("# Inline override within the same file\n") + f.write("max_connections = 200\n") + f.write("\n") + f.write("# Include extension configurations in specific order\n") + f.write("include '{0}'\n".format(C_BIHA_CONF)) + f.write("include '{0}'\n".format(C_PROXIMA_CONF)) + f.write("\n") + f.write("# Final override at the tail of main config\n") + f.write("listen_addresses = '*'\n") + f.flush() + # fmt: on + f.close() + + # 2. Create postgresql.biha.conf + # Overrides shared_preload_libraries and sets BiHA-specific options. + bihaConfPath = os.path.join(rootTmpDir, C_BIHA_CONF) + logging.info("Creating {0}...".format(bihaConfPath)) + + with open(bihaConfPath, "x") as f: + # fmt: off + f.write("# BiHA extension configuration\n") + f.write("shared_preload_libraries = 'pg_stat_statements, biha'\n") + f.write("wal_level = 'logical'\n") + f.write("biha.node_id = 1\n") + f.flush() + # fmt: on + f.close() + + # 3. Create postgresql.proxima.conf + # Included after BiHA; overrides shared_preload_libraries again and tunes memory. + proximaConfPath = os.path.join(rootTmpDir, C_PROXIMA_CONF) + logging.info("Creating {0}...".format(proximaConfPath)) + + with open(proximaConfPath, "x") as f: + # fmt: off + f.write("# Proxima extension configuration\n") + f.write("shared_preload_libraries = 'pg_stat_statements, biha, proxima'\n") + f.write("shared_buffers = '1GB'\n") + f.write("proxima.pool_size = 64\n") + f.flush() + # fmt: on + f.close() + + # 4. Create postgresql.auto.conf (simulating ALTER SYSTEM overrides) + # Takes highest precedence over postgresql.conf and all its includes. + autoConfPath = os.path.join(rootTmpDir, C_AUTO_CONF) + logging.info("Creating {0}...".format(autoConfPath)) + + with open(autoConfPath, "x") as f: + # fmt: off + f.write("# Do not edit this file manually!\n") + f.write("# It will be overwritten by the ALTER SYSTEM command.\n") + f.write("max_connections = 500\n") + f.write("port = 5433\n") + f.flush() + # fmt: on + f.close() + + # --------------- + # Initialize configuration manager in Standard mode (duplicates allowed) + cfg = PgCfg_Std( + rootTmpDir, + strategy=PgCfg_Std.Strategy.Standard, + ) + + # --------------- + # Load top-level configuration files + logging.info("Loading configuration files...") + + pgFile = PgCfg_Reader_Base.LoadConfigurationFile(cfg, C_PG_CONF) + autoFile = PgCfg_Reader_Base.LoadConfigurationFile(cfg, C_AUTO_CONF) + + assert len(cfg.get_AllFiles()) == 4 + + bihaFile = cfg.get_AllFiles().GetFileByName(C_BIHA_CONF) + proximaFile = cfg.get_AllFiles().GetFileByName(C_PROXIMA_CONF) + + # --------------- + # Verify effective global configuration values (last definition wins) + + # Overridden in postgresql.auto.conf + assert cfg.GetOptionValue("port") == 5433 + assert cfg.GetOptionValue("max_connections") == 500 + + # Overridden at the tail of postgresql.conf (after includes) + assert cfg.GetOptionValue("listen_addresses") == "*" + + # Overridden in postgresql.proxima.conf (the last include defining these) + assert cfg.GetOptionValue("shared_buffers") == "1GB" + assert cfg.GetOptionValue("shared_preload_libraries") == [ + "pg_stat_statements", + "biha", + "proxima", + ] + + # Defined only in specific extension files + assert cfg.GetOptionValue("wal_level") == "logical" + assert cfg.GetOptionValue("biha.node_id") == 1 + assert cfg.GetOptionValue("proxima.pool_size") == 64 + + # --------------- + # Verify file-scoped effective values (subtree lookup) + + # In context of postgresql.conf (ignoring postgresql.auto.conf): + # max_connections is 200 (inline override), port is 5432 + assert pgFile.GetOptionValue("max_connections") == 200 + assert pgFile.GetOptionValue("port") == 5432 + assert pgFile.GetOptionValue("shared_preload_libraries") == [ + "pg_stat_statements", + "biha", + "proxima", + ] + + # In context of postgresql.biha.conf (ignoring proxima.conf): + assert bihaFile.GetOptionValue("shared_preload_libraries") == [ + "pg_stat_statements", + "biha", + ] + assert bihaFile.GetOptionValue("proxima.pool_size") is None + + # In context of postgresql.proxima.conf: + assert proximaFile.GetOptionValue("shared_preload_libraries") == [ + "pg_stat_statements", + "biha", + "proxima", + ] + assert proximaFile.GetOptionValue("biha.node_id") is None + + # In context of postgresql.auto.conf: + assert autoFile.GetOptionValue("port") == 5433 + assert autoFile.GetOptionValue("max_connections") == 500 + assert autoFile.GetOptionValue("shared_buffers") is None + + # --------------- + # Verify total count of all option instances (including duplicates) + # postgresql.conf: 6 options (listen_addresses x2, port, max_connections x2, shared_buffers, shared_preload_libraries -> 7 total) + # biha.conf: 3 options + # proxima.conf: 3 options + # auto.conf: 2 options + # Total = 15 option instances across 4 files + allOptions = list(cfg.get_AllOptions()) + assert len(allOptions) == 15 + assert len(cfg.get_AllOptions()) == 15 + + return + # ////////////////////////////////////////////////////////////////////////////// diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddComment/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddComment/test_set001__common.py index 55ea8eb..9b74ae1 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddComment/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddComment/test_set001__common.py @@ -34,13 +34,18 @@ class TestSet001__Common: def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) cfg.SetOptionValue("port", 123) @@ -103,13 +108,18 @@ def test_001( def test_002( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) cfg.SetOptionValue("port", 123) diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddEmptyLine/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddEmptyLine/test_set001__common.py index a71b2bd..1f08bbf 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddEmptyLine/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddEmptyLine/test_set001__common.py @@ -25,13 +25,18 @@ class TestSet001__Common: def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) cfg.SetOptionValue("port", 123) @@ -59,7 +64,12 @@ def test_001( assert isinstance(fileLine2, PgCfg_FileLine) assert len(fileLines) == 2 - assert list(fileLines)[-1].m_FileLineData is fileLine2.m_FileLineData + + fileLines_v = list(fileLines) + lastFileLine = fileLines_v[-1] + assert lastFileLine is not None + assert isinstance(lastFileLine, PgCfg_FileLine_Base) + assert lastFileLine.m_FileLineData is fileLine2.m_FileLineData assert len(fileLine2.m_FileLineData.m_Items) == 0 diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddInclude/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddInclude/test_set001__common.py index b7f1a90..de7eaa7 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddInclude/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddInclude/test_set001__common.py @@ -28,13 +28,18 @@ class TestSet001__Common: def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file1 = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) assert file1 is not None @@ -128,13 +133,18 @@ def test_001( def test_002__include_twice( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file1 = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) assert file1 is not None @@ -172,13 +182,18 @@ def test_002__include_twice( def test_003__empty_file_path( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file1 = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) assert file1 is not None diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddOption/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddOption/test_set001__common.py index 8951422..17efeae 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddOption/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/AddOption/test_set001__common.py @@ -6,9 +6,11 @@ from src.implementation.v00.configuration_base import PostgresConfigurationTopLevelFile_Base as PgCfg_TopLevelFile_Base from src.implementation.v00.configuration_base import PostgresConfigurationOption_Base as PgCfg_Option_Base +from src.implementation.v00.configuration_base import PostgresConfigurationSetOptionValueEventID as PgCfg_SetOptionEventID from src.implementation.v00.configuration_base import PgCfgModel__FileData from src.implementation.v00.configuration_base import PgCfgModel__OptionData +from src.implementation.v00.configuration_base import PgCfgModel__ConfigurationData from src.exceptions import PostgresConfigException # fmt: on @@ -27,13 +29,18 @@ class TestSet001__Common: def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) assert file is not None @@ -67,18 +74,26 @@ def test_001( return # -------------------------------------------------------------------- - def test_002__already_in_this( + def test_002__00A__already_in_this__Strict( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "port" + if pg_conf_strategy == PgCfg_Std.Strategy.Standard: + TestServices.RaiseSkip_NotApplicable() + rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) option = file.AddOption(C_OPT_NAME, 123) @@ -101,20 +116,79 @@ def test_002__already_in_this( return # -------------------------------------------------------------------- - def test_003__already_in_another( + def test_002__00B__already_in_this__Standard( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + C_OPT_NAME = "port" + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) + option1 = file.AddOption(C_OPT_NAME, 123) + option2 = file.AddOption(C_OPT_NAME, 321) + + assert option1.get_Name() == C_OPT_NAME + assert option1.get_Value() == 123 + + assert option2.get_Name() == C_OPT_NAME + assert option2.get_Value() == 321 + + assert option1.m_OptionData is not option2.m_OptionData + + assert C_OPT_NAME in file.m_FileData.m_OptionsByName.keys() + s1 = file.m_FileData.m_OptionsByName[C_OPT_NAME] + assert type(s1) is list + assert len(s1) == 2 + + assert option1.m_OptionData in s1 + assert option2.m_OptionData in s1 + + assert C_OPT_NAME in cfg.m_Data.m_AllOptionsByName.keys() + s2 = cfg.m_Data.m_AllOptionsByName[C_OPT_NAME] + assert type(s2) is list + assert len(s2) == 2 + + assert option1.m_OptionData in s2 + assert option2.m_OptionData in s2 + return + + # -------------------------------------------------------------------- + def test_003__00A__already_in_another__Strict( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "proxima.port" + if pg_conf_strategy == PgCfg_Std.Strategy.Standard: + TestServices.RaiseSkip_NotApplicable() + rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) - file1 = cfg.AddTopLevelFile("postgresql.proxima.conf") + file1 = cfg.AddTopLevelFile("postgresql.auto.conf") option = cfg.SetOptionValue(C_OPT_NAME, 123).Option assert type(option) is PgCfg_Option_Base assert len(file1) == 1 @@ -138,19 +212,74 @@ def test_003__already_in_another( assert cfg.m_Data.m_AllOptionsByName[C_OPT_NAME] is option.m_OptionData return + # -------------------------------------------------------------------- + def test_003__00B__already_in_another__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + C_OPT_NAME = "proxima.port" + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file1 = cfg.AddTopLevelFile("postgresql.auto.conf") + option1 = cfg.SetOptionValue(C_OPT_NAME, 123).Option + assert type(option1) is PgCfg_Option_Base + assert len(file1) == 1 + + file2 = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) + option2 = file2.AddOption(C_OPT_NAME, 321) + + assert option1.get_Name() == C_OPT_NAME + assert option1.get_Value() == 123 + + assert option2.get_Name() == C_OPT_NAME + assert option2.get_Value() == 321 + + assert C_OPT_NAME in file1.m_FileData.m_OptionsByName.keys() + assert file1.m_FileData.m_OptionsByName[C_OPT_NAME] is option1.m_OptionData + + assert C_OPT_NAME in file2.m_FileData.m_OptionsByName.keys() + assert file2.m_FileData.m_OptionsByName[C_OPT_NAME] is option2.m_OptionData + + assert C_OPT_NAME in cfg.m_Data.m_AllOptionsByName.keys() + s2 = cfg.m_Data.m_AllOptionsByName[C_OPT_NAME] + assert type(s2) is list + assert len(s2) == 2 + assert option1.m_OptionData in s2 + assert option2.m_OptionData in s2 + return + # -------------------------------------------------------------------- def test_004__bad_value_type( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "proxima.port" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile("postgresql.proxima.conf") @@ -168,15 +297,20 @@ def test_004__bad_value_type( def test_004__cant_convert_value( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "proxima.port" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile("postgresql.proxima.conf") @@ -194,15 +328,20 @@ def test_004__cant_convert_value( def test_005__None_value( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "proxima.port" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile("postgresql.proxima.conf") @@ -216,13 +355,18 @@ def test_005__None_value( def test_006__None_name( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile("postgresql.proxima.conf") @@ -236,13 +380,18 @@ def test_006__None_name( def test_007__empty_name( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile("postgresql.proxima.conf") @@ -252,5 +401,52 @@ def test_007__empty_name( assert str(x.value) == ErrorMessageBuilder.OptionNameIsEmpty() return + # -------------------------------------------------------------------- + def test_015__set_twice_around_include__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + assert type(cfg.m_Data) is PgCfgModel__ConfigurationData + assert cfg.m_Data.m_DataDir == rootTmpDir + + C_OPT_NAME = "port" + + file1 = cfg.AddTopLevelFile("fil1.conf") + assert file1 is not None + + r1 = file1.SetOptionValue(C_OPT_NAME, 1) + assert r1.EventID == PgCfg_SetOptionEventID.OPTION_WAS_ADDED + assert r1.Option is not None + assert r1.Option.get_Parent().get_Parent().m_FileData is file1.m_FileData + assert r1.Option.get_Value() == 1 + file2 = r1.Option.get_Parent().get_Parent().AddInclude("a.conf") + assert file2 is not None + assert file1.GetOptionValue(C_OPT_NAME) == 1 + assert r1.Option.get_Value() == 1 + r2 = file1.SetOptionValue(C_OPT_NAME, 2) + assert r2.EventID == PgCfg_SetOptionEventID.OPTION_WAS_ADDED + assert r2.Option is not None + assert r2.Option.get_Parent().get_Parent().m_FileData is file1.m_FileData + assert r2.Option.get_Value() == 2 + assert r2.Option.m_OptionData is not r1.Option.m_OptionData + assert r1.Option.get_Value() == 1 + + assert cfg.GetOptionValue(C_OPT_NAME) == 2 + return + # ////////////////////////////////////////////////////////////////////////////// diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/GetOptionValue/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/GetOptionValue/test_set001__common.py index 6b4249d..2fe4f3a 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/GetOptionValue/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/GetOptionValue/test_set001__common.py @@ -22,15 +22,20 @@ class TestSet001__Common: def test_001__no_opt( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -42,15 +47,20 @@ def test_001__no_opt( def test_002( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -69,16 +79,21 @@ def test_002( # -------------------------------------------------------------------- def test_003__opt_with_list__get_None( self, + pg_conf_strategy: PgCfg_Std.Strategy, request: pytest.FixtureRequest, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -91,15 +106,20 @@ def test_003__opt_with_list__get_None( def test_004__opt_with_list__with_data( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) @@ -116,5 +136,132 @@ def test_004__opt_with_list__with_data( continue return + # -------------------------------------------------------------------- + def test_005__mult_opts__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + C_OPT_NAME = "port" + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file1 = cfg.AddTopLevelFile("a.conf") + file2 = cfg.AddTopLevelFile("b.conf") + + assert file1 is not None + assert file2 is not None + assert file1.m_FileData is not file2.m_FileData + + file1.AddOption(C_OPT_NAME, 10) + file1.AddOption(C_OPT_NAME, 11) + file2.AddOption(C_OPT_NAME, 20) + file2.AddOption(C_OPT_NAME, 21) + + v1 = file1.GetOptionValue(C_OPT_NAME) + assert type(v1) is int + assert v1 == 11 + + v2 = file2.GetOptionValue(C_OPT_NAME) + assert type(v2) is int + assert v2 == 21 + + return + + # -------------------------------------------------------------------- + def test_006__include( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + C_OPT_NAME = "port" + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file1 = cfg.AddTopLevelFile("a.conf") + + file2 = file1.AddInclude("b.conf").get_File() + file3 = file2.AddInclude("c.conf").get_File() + + file3.AddOption(C_OPT_NAME, 123) + file3.AddOption("blablabla", True) + file3.AddComment("ohoho") + file1a = file3.AddInclude("a.conf").get_File() + + assert file1.m_FileData is not None + assert file1a.m_FileData is not None + assert file1.m_FileData is file1a.m_FileData + + v = file1.GetOptionValue(C_OPT_NAME) + assert type(v) is int + assert v == 123 + + # -------------------------------------------------------------------- + def test_007__include_and_comment( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + C_OPT_NAME = "port" + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file1 = cfg.AddTopLevelFile("a.conf") + file1_L1 = file1.AddEmptyLine() + + file2 = file1_L1.AddInclude("b.conf", 0).get_File() + file2_L1 = file2.AddEmptyLine() + file1_L1.AddComment("it is a comment in a file 1") + + file3 = file2_L1.AddInclude("c.conf", 0).get_File() + file2_L1.AddComment("it is a comment in a file 2") + + file3_L1 = file3.AddEmptyLine() + file3_L2 = file3.AddEmptyLine() + file3_L1.AddOption(C_OPT_NAME, 123, 0) + file3_L1.AddComment("line1") + file3_L2.AddOption("blablabla", True, 0) + file3_L2.AddComment("line2") + file3.AddComment("ohoho") + file1a = file3.AddInclude("a.conf").get_File() + + assert file1.m_FileData is not None + assert file1a.m_FileData is not None + assert file1.m_FileData is file1a.m_FileData + + v = file1.GetOptionValue(C_OPT_NAME) + assert type(v) is int + assert v == 123 + # ////////////////////////////////////////////////////////////////////////////// diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/SetOptionValueItem/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/SetOptionValueItem/test_set001__common.py index 72b9bef..225cb10 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/SetOptionValueItem/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/SetOptionValueItem/test_set001__common.py @@ -26,15 +26,20 @@ class TestSet001__Common: def test_001__set_None( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) assert file is not None @@ -49,15 +54,20 @@ def test_001__set_None( def test_002__set_value_item_with_bad_type( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) assert file is not None @@ -76,15 +86,20 @@ def test_002__set_value_item_with_bad_type( def test_003( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) assert file is not None @@ -135,18 +150,26 @@ def test_003( return # -------------------------------------------------------------------- - def test_004__already_defined_in_another_file( + def test_004__already_defined_in_another_file__Strict( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Standard: + TestServices.RaiseSkip_NotApplicable() C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file1 = cfg.AddTopLevelFile("a.conf") assert file1 is not None @@ -174,18 +197,26 @@ def test_004__already_defined_in_another_file( return # -------------------------------------------------------------------- - def test_005__opt_is_defined_in_another_file( + def test_005__opt_is_defined_in_another_file__Strict( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Standard: + TestServices.RaiseSkip_NotApplicable() C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file1 = cfg.AddTopLevelFile("a.conf") assert file1 is not None @@ -214,15 +245,20 @@ def test_005__opt_is_defined_in_another_file( def test_006__two_items( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy C_OPT_NAME = "shared_preload_libraries" rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) assert file is not None @@ -243,5 +279,90 @@ def test_006__two_items( assert r1.Option.get_Value() == ["biha", "proxima"] return + # -------------------------------------------------------------------- + def test_006__two_items__around_include__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + C_OPT_NAME = "shared_preload_libraries" + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) + assert file is not None + + r1 = file.SetOptionValueItem(C_OPT_NAME, "biha") + assert r1 is not None + assert type(r1) is PgCfg_SetOptionResult_Base + assert r1.Option is not None + assert r1.Option.get_Value() == ["biha"] + + file.AddInclude("a.conf") + + r2 = file.SetOptionValueItem(C_OPT_NAME, "proxima") + assert r2 is not None + assert type(r2) is PgCfg_SetOptionResult_Base + assert r2.EventID == PgCfg_SetOptionEventID.VALUE_ITEM_WAS_ADDED + assert r2.Option is not None + assert r2.Option.get_Value() == ["biha", "proxima"] + + assert r1.Option.get_Value() == ["biha"] + return + + # -------------------------------------------------------------------- + def test_006__two_items_and_two_files__Standard( + self, + request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, + ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + + if pg_conf_strategy == PgCfg_Std.Strategy.Strict: + TestServices.RaiseSkip_NotApplicable() + + C_OPT_NAME = "shared_preload_libraries" + + rootTmpDir = TestServices.GetRootTmpDir() + assert type(rootTmpDir) is str + + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + + file1 = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_CONF) + assert file1 is not None + + file2 = file1.AddInclude("a.conf").get_File() + assert file2 is not None + + file2_r = file2.SetOptionValueItem(C_OPT_NAME, "biha") + assert file2_r is not None + assert type(file2_r) is PgCfg_SetOptionResult_Base + assert file2_r.Option is not None + assert file2_r.Option.get_Value() == ["biha"] + + file1_r = file1.SetOptionValueItem(C_OPT_NAME, "proxima") + assert file1_r is not None + assert type(file1_r) is PgCfg_SetOptionResult_Base + assert file1_r.EventID == PgCfg_SetOptionEventID.VALUE_ITEM_WAS_ADDED + assert file1_r.Option is not None + assert file1_r.Option.get_Value() == ["biha", "proxima"] + return + # ////////////////////////////////////////////////////////////////////////////// diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/get_Lines/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/get_Lines/test_set001__common.py index 4824116..f8c57e6 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/get_Lines/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationTopLevelFile/get_Lines/test_set001__common.py @@ -30,13 +30,18 @@ class TestSet001__Common: def test_001__Lines( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) cfg.SetOptionValue("port", 123) @@ -80,13 +85,18 @@ def test_001__Lines( def test_001__Lines__iterator( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() assert type(rootTmpDir) is str - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) set_r = cfg.SetOptionValue("port", 123) assert type(set_r) is PgCfg_SetOptionResult_Base diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationWriter_Base/DoWork/test_set001__work.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationWriter_Base/DoWork/test_set001__work.py index cbd694f..54efa78 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationWriter_Base/DoWork/test_set001__work.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationWriter_Base/DoWork/test_set001__work.py @@ -34,7 +34,11 @@ class TestSet001__Common: def test_000__empty( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + rootTmpDir = TestServices.GetCurTestTmpDir(request) os.makedirs(rootTmpDir, exist_ok=True) @@ -42,7 +46,10 @@ def test_000__empty( # --------------- logging.info("File object is building...") - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_AUTO_CONF) assert type(file) is PgCfg_TopLevelFile_Base @@ -92,7 +99,11 @@ def test_000__empty( def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + rootTmpDir = TestServices.GetCurTestTmpDir(request) os.makedirs(rootTmpDir, exist_ok=True) @@ -102,7 +113,10 @@ def test_001( portNumber = 234 - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) cfg.SetOptionValue("port", portNumber) file = cfg.get_AllFiles().GetFileByName(cfg.C_POSTGRESQL_AUTO_CONF) @@ -164,7 +178,11 @@ def test_001( def test_003__two_files( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + rootTmpDir = TestServices.GetCurTestTmpDir(request) os.makedirs(rootTmpDir, exist_ok=True) @@ -178,7 +196,10 @@ def test_003__two_files( # --------------- logging.info("File object is building...") - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file1 = cfg.AddTopLevelFile(C_FILE1_NAME) @@ -186,7 +207,7 @@ def test_003__two_files( portNumber = 321 - cfg.AddOption(C_OPT_NAME, portNumber) + file2.AddOption(C_OPT_NAME, portNumber) assert file2.GetOptionValue(C_OPT_NAME) == portNumber @@ -207,7 +228,7 @@ def test_003__two_files( else: portNumber += 1 logging.info("Port is changed with number {0}".format(portNumber)) - cfg.SetOptionValue(C_OPT_NAME, portNumber) + file2.SetOptionValue(C_OPT_NAME, portNumber) assert file2.GetOptionValue(C_OPT_NAME) == portNumber # --------------- @@ -254,13 +275,21 @@ def test_003__two_files( def test_004__check_truncate( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + rootTmpDir = TestServices.GetCurTestTmpDir(request) os.makedirs(rootTmpDir, exist_ok=True) # --------------- - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) + cfg.SetOptionValue("port", 123) cfg.SetOptionValue("listen_addresses", "*") @@ -308,7 +337,11 @@ def test_004__check_truncate( def test_E01__file_is_exist( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + rootTmpDir = TestServices.GetCurTestTmpDir(request) os.makedirs(rootTmpDir, exist_ok=True) @@ -322,7 +355,10 @@ def test_E01__file_is_exist( # --------------- logging.info("File object is building...") - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file1 = cfg.AddTopLevelFile(C_FILE1_NAME) @@ -374,13 +410,20 @@ def test_E01__file_is_exist( def test_E02__external_modification( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): + assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy + rootTmpDir = TestServices.GetCurTestTmpDir(request) os.makedirs(rootTmpDir, exist_ok=True) # --------------- - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) cfg.SetOptionValue("port", 123) cfg.SetOptionValue("listen_addresses", "*") @@ -440,7 +483,7 @@ def Helper__norm_content(text: str) -> str: assert text is not None assert type(text) is str - r = text.replace("\r\n", "\r") + r = text.replace("\r\n", "\n") assert r is not None assert type(r) is str diff --git a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationWriter_Base/test_set001__common.py b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationWriter_Base/test_set001__common.py index 58e1c03..8826024 100644 --- a/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationWriter_Base/test_set001__common.py +++ b/tests/implementation/v00/configuration_std/Objects/PostgresConfigurationWriter_Base/test_set001__common.py @@ -26,13 +26,18 @@ class TestSet001__Common: def test_001( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, optName: str, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(optName) is str rootTmpDir = TestServices.GetRootTmpDir() - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert len(cfg.m_Data.m_TopLevelFiles) == 0 cfg.SetOptionValue(optName, 234) @@ -52,11 +57,16 @@ def test_001( def test_002__two_opts( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert len(cfg.m_Data.m_TopLevelFiles) == 0 cfg.SetOptionValue("port", 234) @@ -82,11 +92,16 @@ def test_002__two_opts( def test_003__opt1_emptyline_opt2( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert len(cfg.m_Data.m_TopLevelFiles) == 0 cfg.SetOptionValue("port", 234) assert len(cfg.get_AllFiles()) == 1 @@ -115,11 +130,16 @@ def test_003__opt1_emptyline_opt2( def test_004__opt1_comment_opt2( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) assert len(cfg.get_AllFiles()) == 0 cfg.SetOptionValue("port", 234) assert len(cfg.get_AllFiles()) == 1 @@ -148,11 +168,16 @@ def test_004__opt1_comment_opt2( def test_005__opt_with_list( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_AUTO_CONF) C_OPT_NAME = "shared_preload_libraries" @@ -175,11 +200,16 @@ def test_005__opt_with_list( def test_006__opt_with_list__empty( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_AUTO_CONF) C_OPT_NAME = "shared_preload_libraries" @@ -208,11 +238,16 @@ def test_006__opt_with_list__empty( def test_007__opt_with_list__mix( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_AUTO_CONF) C_OPT_NAME = "shared_preload_libraries" @@ -243,11 +278,16 @@ def test_007__opt_with_list__mix( def test_008__include( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy rootTmpDir = TestServices.GetRootTmpDir() - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_AUTO_CONF) C_INCLUDED_FILE_NAME = "postgresql.proxima.conf" @@ -320,13 +360,18 @@ def data009( def test_009__include__mix( self, request: pytest.FixtureRequest, + pg_conf_strategy: PgCfg_Std.Strategy, data009: tagData009, ): assert isinstance(request, pytest.FixtureRequest) + assert type(pg_conf_strategy) is PgCfg_Std.Strategy assert type(data009) is __class__.tagData009 rootTmpDir = TestServices.GetRootTmpDir() - cfg = PgCfg_Std(rootTmpDir) + cfg = PgCfg_Std( + rootTmpDir, + strategy=pg_conf_strategy, + ) file = cfg.AddTopLevelFile(cfg.C_POSTGRESQL_AUTO_CONF) file2 = file.AddInclude(data009.fileName).get_File() diff --git a/tests/implementation/v00/configuration_std/conftest.py b/tests/implementation/v00/configuration_std/conftest.py new file mode 100644 index 0000000..585c359 --- /dev/null +++ b/tests/implementation/v00/configuration_std/conftest.py @@ -0,0 +1,23 @@ +# ////////////////////////////////////////////////////////////////////////////// +# Postgres Pro. PostgreSQL Configuration Python Library. Tests. + +from src.implementation.v00.configuration_std import PostgresConfiguration_Std + +import pytest + +# ////////////////////////////////////////////////////////////////////////////// +# pg_conf_strategy + + +@pytest.fixture( + params=list(PostgresConfiguration_Std.Strategy), +) +def pg_conf_strategy( + request: pytest.FixtureRequest, +) -> PostgresConfiguration_Std.Strategy: + assert isinstance(request, pytest.FixtureRequest) + assert type(request.param) is PostgresConfiguration_Std.Strategy + return request.param + + +# //////////////////////////////////////////////////////////////////////////////