Class to unit-test functions, with rudimentary support for testing multi-parameter functions
Since indentation is crucial in Python, you should consistently use four spaces, as specified in PEP 8, the official Python style guide.

Also, don't mix naming styles.  Based on PEP 8, the class should be named UnitTester.



Your test harness neglects to support…


calling functions with no parameters, or with more than 3 parameters.  This is easily solved using the * operator:

function_output = function_to_test(*test_input)

calling functions with keyword parameters.  You could accomplish this using the ** operator.
testing that a function raises an exception as expected.  That is left as an exercise for you.
testing whether a function performs expected side-effects, such as printing certain output.  This is quite tricky to implement, but it's something that doctest can easily handle.

def aloha():
    """
    &gt;&gt;&gt; aloha()
    Hello
    'Goodbye'
    """
    print('Hello')
    return "Goodbye"





This code is an abuse of assertions:


    try:
        assert function_output == expected_output
        print(self.unit_test_response(True, test_input, function_output, expected_output))
    except AssertionError:
        print(self.unit_test_response(False, test_input, function_output, expected_output))



Assertions are a way for you, as a programmer, to state that a certain condition must logically be true, not that you hope for a condition to be true.

Furthermore, assertions can be disabled, in which case every test would succeed!

You should replace that code with:

      result = (function_output == expected_output)
      print(self.unit_test_response(result, test_input, function_output, expected_output))




My biggest complaint about this unit-testing class, though, is that it is unclear how it is meant to be used.  You didn't describe the intended usage in the question, and you didn't write docstrings like you should have.  I'm guessing that this is your intended usage:

Unit_Tester(max, [
    ([3, 1, 4], 4),
    ([-3, -1, -4], -1),
]).run()


But why does the run_unit_tests(…) method exist?  Is this a "valid" way to use your harness?

Unit_Tester(None, None).run_unit_tests(max, [
    ([3, 1, 4], 4),
    ([-3, -1, -4], -1),
])


If it is, then I recommend getting rid of the tests parameter in the constructor.  If it isn't, then I recommend merging run_unit_tests() into run(), so that misuse is impossible.

Alternatively, name your "private" methods with a leading underscore (e.g. _unit_test_response(…) to indicate that a method should not be called directly.