Estou tendo problemas para descobrir como simular dois arquivos abertos em uma classe quando ambos usam gerenciadores de contexto. Eu sei como fazer isso para um arquivo gerenciado por contexto usando o módulo simulado como este:

@patch('__builtin__.open')
def test_interface_mapping(self, mock_config):
        m = MagicMock(spec=file)
        handle = m.return_value.__enter__.return_value
        handle.__iter__.return_value = ('aa', 'bb')

Meu problema é como fazer isso quando uma classe abre dois arquivos diferentes na mesma chamada. No meu caso, a turma__init__() pré-carrega os arquivos em dois mapas. Essa classe é usada em outras classes. Desejo simular o carregamento desses dois arquivos para fornecer meus dados de teste, para que as outras classes que usam o objeto IfAddrConfig possam ser testadas no conteúdo do meu arquivo de teste pré-carregado.

Aqui está um exemplo da classe com a qual estou lutando que carrega dois arquivos__init__(), dos quais quero simular carregar o conteúdo do arquivo injetado de teste. getInterfaceMap () é a função que é chamada com freqüência, portanto, não quero que isso carregue e analise os arquivos a cada chamada, portanto, o motivo do pré-carregamento dos mapas em__init__() uma vez.

class IfAddrConfig(object):
    def __init__(self):
        # Initialize the static maps once since they require file operations
        # that we do not want to be calling every time getInterfaceMap() is used
        self.settings_map = self.loadSettings()
        self.config_map = self.loadConfig()

    def loadConfig(self):
        config_map = defaultdict(dict)
        with open(os.path.join('some_path.cfg'), 'r') as stream:
            for line in stream:
                # Parse line and build up config_map entries
        return config_map

    def loadSettings(self):
        settings_map = {}
        with open('another_path.cfg', 'r') as stream:
            for line in stream:
                # Parse line and build up settings_map entries
        return settings_map

    def getInterfaceMap(self, interface):
        # Uses both the settings and config maps to finally create a composite map
        # that is returned to called
        interface_map = {}
        for values in self.config_map.values():
            # Accesss self.settings_map and combine/compare entries with
            # self.config_map values to build new composite mappings that
            # depend on supplied interface value
        return interface_map