Calling different class objects using python
I think you've over-engineered the code a bit. If I were to write this code I wouldn't have used a class at all. Looking at what your code does I understand that:

you have multiple proxies files
you randomly choose one of them and perform whatever actions based on that

Why not just doing something along the following lines:
import random
import time

from proxymanager import ProxyManager


PROXY_FILES = (
    './test.txt',
    './test2.txt',
    './test3.txt',
    './test4.txt',
)
DELAY = 10


def get_random_proxy():
    &quot;&quot;&quot;
    Return a random proxy dict from a random file.
    &quot;&quot;&quot;
    random_file = random.choice(PROXY_FILES)
    return ProxyManager(random_file).random_proxy().get_dict()


def main():
    while True:
        proxy = get_random_proxy()
        print(f'Do something with {proxy[&quot;http&quot;]}\n')
        time.sleep(DELAY)


if __name__ == '__main__':
    main()

This approach will save you a lot of development time since you:

won't have to add a new method to your ProxyServer each time you have a new proxy file.
won't have to keep track of random_list (which is not quite random since it has to match the attributes of the class)
you won't need a Testing() class anymore

Notice that with this version is really easy to figure out what you're doing.
Recommendations (PEP8):

use appropriate naming for your variables (snake_case naming convention for methods/functions, UPPER_CASE naming convention for constants);
use docstrings to help your readers understand the code;


If you're really tied to use classes, I'd mix your solution with mine and do something along these lines:
import random
import time

import requests

from proxymanager import ProxyManager


PROXY_FILES = (
    './test.txt',
    './test2.txt',
    './test3.txt',
    './test4.txt',
)
DELAY = 10


class ProxyServer:
    def __init__(self, random_proxy_file):
        self.proxy_manager = ProxyManager(random_proxy_file)

    def get_proxy(self):
        &quot;&quot;&quot;
        Return a random proxy dict.
        &quot;&quot;&quot;
        return self.proxy_manager.random_proxy().get_dict()


class Scrapper:
    def __init__(self, base_url):
        self.base_url = base_url

    @staticmethod
    def _get_random_proxy():
        random_proxy_file = random.choice(PROXY_FILES)
        return ProxyServer(random_proxy_file).get_proxy()

    def get_url_data(self):
        proxy = self._get_random_proxy()
        data = requests.get(self.base_url, proxies={'http': proxy['http']})
        return data

    def do_something_with_data(self, data):
        return data


def main():
    scrapper = Scrapper('http://scrapeme.not/')
    
    while True:
        data = scrapper.get_url_data()
        scrapper.do_something_with_data(data)
        time.sleep(DELAY)


if __name__ == '__main__':
    main()

But notice how this has become a lot more complex than it should've been. Some advantages that this has over your solution:

it uses better naming;
it avoids creating multiple ProxyManager() instances;
it avoids mapping the getattr() to a value from a list you'd have to maintain all the time as complexity of the scrapper increases;


And to answer your question: no, it's not wrong to use getattr() like that but in this specific case I don't think it's necessary due to the above listed reasons.