Testing useImperativeHandle with react-test-renderer. Is there a more elegant way than this?

example.js

import { forwardRef, useImperativeHandle } from 'react';

const Example = (_, ref) => {
	useImperativeHandle(
		ref,
		() => ({
			methodFromUseImperativeHandle: () => true
		}),
		[]
	);

	return null;
};

export default forwardRef(Example);

example.test.js

import React, { useRef } from 'react';
import renderer, { act } from 'react-test-renderer';

import Example from './Example';
import unsafeGetTestingRef from './testing-ref';

test('test which calls methods on ref (for useImperativeHandle)', async () => {
	const UsesRef = () => {
		const ref = useRef();

		return <Example ref={ref} />;
	};

	let tree;

	await act(async () => {
		tree = renderer.create(<UsesRef key="root" />);

		return tree;
	});

	const ref = unsafeGetTestingRef(tree, Example);

	expect(ref.current).not.toBeNull();
	expect(ref.current).toMatchObject({
		methodFromUseImperativeHandle: expect.any(Function)
	});

	expect(ref.current.methodFromUseImperativeHandle()).toBe(true);
});

testing-ref.js

const unsafeGetTestingRef = (tree, component) => {
	// Unsafe way to get access to a ref property. Uses internal _fiber property of a ReactTestingInstance since AFAIK react-test-renderer does not expose refs in any other way
	const node = tree.root.findByType(component);

	expect(node).not.toBeNull();
	expect(node._fiber).not.toBeNull();
	expect(node._fiber).not.toBeUndefined();

	const ref = node._fiber.ref;

	expect(ref).not.toBeNull();
	expect(ref).not.toBeUndefined();

	return ref;
};

export default unsafeGetTestingRef;