Is there any way to catch an event fired within another contract which is called by low level 'call' opcode from main contract in solidity - solidity

Question

I have a Multisig contract that when reaches the minimum quorum, it can execute a low level call Transaction which may be held on another contract.
function _execute(Transaction storage transaction) internal {
//some code
// solhint-disable-next-line
(bool success, ) = transaction.target.call{value: transaction.value}(callData); // FIRES AN EVENT IN OTHER CONTRACT
if (success) {
emit TransactionExecuted( // FIRES SECOND
//some code
);
} else {
emit TransactionFailed(
//some code
);
//some code
}
}
My execute function fires an event after execution of the Transaction (call) whether it was successful or not, in the meanwhile if call function request has an event to fire, I can catch the event fired by the contract, but event parameters are not there, The second contract which is called by _execute() is written as follows:
function _addMember(
address memberAddress,
bytes32 memberName,
Membership _membership
)
internal
{
//some code
// Fire an event
emit MembershipChanged(memberAddress, true, _membership); // FIRES FIRST
}
The following is the test written in typescript, I can get the event fired on called contract, but there is no data in it
it("should contain two events from previous transaction, adding a new core member and running a Transaction by multisig", async () => {
//r is the receipt of the caller (multisig) contract
expect(r.events!.length).to.be.eq(2); // MembershipChanged, TransactionExecuted
//NOTE: r.events![0].address === memberReg.address // memReg is the callee contract
/*THE FOLLOWING DOESN'T CONTAIN EVENT DATA NOR TOPICS OF memReg CONTRACT*/
expect(r.events![0].event).to.be.eq("MembershipChanged"); //faild
expect(r.events![0].args!.member).to.be.eq(coreCandidateAddr) //faild
expect(r.events![0].args!.isMember).to.be.true; //fails
expect(r.events![0].args!.membership).to.be.eq(Membership.Core); //faild
/* THE FOLLOWING WORKS WELL */
expect(r.events![1].event).to.be.eq("TransactionExecuted"); //passed
//some code
})
I guess it would be possible to catch those events in production easily by listening to that deployed contract, but I don't know how to do this in test environment

Answer 1

Ok, Thanks to #bbbbbbbbb here is the simple solution, it should listen on before the transaction call
memberReg.once("MembershipChanged", (member, isMember, membership, event) => {
expect(event.event).to.be.eq("MembershipChanged"); //passed
expect(member).to.be.eq(coreCandidateAddr); //passed
expect(isMember).to.be.true; //passed
expect(membership).to.be.eq(Membership.Core); //passed
});
r = await awaitTx(multisig.execute(id)); // execution happens here

Answer 2

Your functions _execute and _addMember are marked as internal, it should be mark as external or public to be called in testing environment, or create a public function that call it.
If you are using hardhat the easy way is using the testing pattern for events suggested by hardhat documentation, this also works for low level calls.
const tx = await YourContract.execute(foo);
//Check that the event fired by a low level call is correct
//withArgs receive the expected values for the event
expect(tx).to.emit(YourContract, "MembershipChanged").withArgs(foo, bar...);
For more info check the implementation for hardhat docs: https://hardhat.org/tutorial/testing-contracts#full-coverage