You can use pytest_generate_tests hook for parametrizing with dynamic data.

First create a fixture that can be called by the test function to get the test data.

# in conftest.py
@pytest.fixture()
def test_data(request):
    return request.param

Now you can parametrize it so that it is called for each test data set:

#in conftest.py
def pytest_generate_tests(metafunc):
    testdata = get_test_data('test_data.json')
    metafunc.parametrize('test_data', testdata, indirect=True)

The testdata passed to the parametrize function has to be a list. So you need to modify the input data a bit before passing it. I modified the get_test_data function a bit.

#in conftest.py
def get_test_data(filename):
    folder_path = os.path.abspath(os.path.dirname(__file__))
    folder = os.path.join(folder_path, 'TestData')
    jsonfile = os.path.join(folder, filename)
    with open(jsonfile) as file:
        data = json.load(file)

    valid_data = [(item, 1) for item in data['valid_data']]
    invalid_data = [(item, 0) for item in data['invalid_data']]

    # data below is a list of tuples, with first element in the tuple being the 
    # arguments for the API call and second element specifies if this is a test 
    # from valid_data set or invalid_data. This can be used for putting in the
    # appropriate assert statements for the API response.
    data = valid_data + invalid_data

    return data

And now your test function could look like:

#in test_API.py
def test_(test_data):
    response = database_api.get_user_info(test_data[0])

    # Add appropriate asserts. 
    # test_data[1] == 1 means 200 response should have been received
    # test_data[1] == 0 means 400 response should have been received

Instead of converting the JSON response into Object, I use json.loads() to convert it into a Dictionary, and compare them.

def test_login(self, client):
        res = return client.post('/login',
            data=json.dumps(dict(staff_name='no_such_user', staff_password='password')),
            content_type='application/json',
            follow_redirects=True)
        assert res.status_code == 422
        invalid_password_json = dict(message="Staff name and password pair not match",
                                    errors=dict(
                                        resource="Login",
                                        code="invalid",
                                        field="staff_authentication",
                                        stack_trace=None,),
                                    )
        assert json.loads(res.data) == invalid_password_json

This way, I do not have to worry about whitespace differences in the JSON response, as well as ordering of the JSON structure. Simply let Python's Dictionary comparison function check for equality.

First, your actual function should probably look something like this:

def foo(json_data):
    if json_data["status"]:
        return json_data["name"]
    elif:
        return "Nope"

I don't know what you actually want to do, but the function as is does not make sense. You have to substitute your actual function, of course.

Then your test could look like this:

@pytest.mark.parametrize("data, result", [(json_data_one, "John"), 
                                          (json_data_two, "Nope")])
def test_foo(data, result):
    assert foo(data) == result

Again, your actual result is certainly something else, but I didn't understand what you are trying to do, so you have to adapt this.

Some things you should understand:

1. Your fixture scopes definitely need to match if you want to use one inside of the other
2. Your individual fixtures can access other fixtures if you pass them along

I am not entirely sure if this solves your question, but:

import json

@pytest.fixture(scope="function"):
def output_json_filepath():
    return 'path/to/file'

@pytest.fixture(scope="function"):
def json_data(request):
    return request.param

@pytest.fixture(scope="function"):
def prepared_data(json_data):
    # do something here?
    return prepared_data

# Not sure why you need this...
@pytest.fixture(scope="function"):
def dump_data(prepared_data, output_json_filepath):
    with io.BytesIO(output_json_filepath, 'wb') as stream:
        stream.write(prepared_data)

...

@pytest.mark.unit_test
def some_test(prepared_data):
    # use your prepared_data here in your test.