Prepared Transaction Mock

[jonmchan]

The prepared transaction is extremely complex. The fact that many of the objects are serialized instead of embedded directly makes it hard to trace down the hierarchy without having to refer to the protos constantly. I had to create my own mocked prepared transaction messages for testing, thought I'd leave this here if anyone found them useful. Unfortunately, it is in ruby, but it shouldn't be too hard to convert it to your language of choice.

Gateway::PreparedTransaction.new(
  transaction_id: 'some_id',
  envelope: Common::Envelope.new(
    payload: Common::Payload.new(
      header: Common::Header.new(
        channel_header: Common::ChannelHeader.new(
          channel_id: 'channel_id'
        ).to_proto
      ),
      data: Protos::Transaction.new(actions:
        [
          Protos::TransactionAction.new(
            payload: Protos::ChaincodeActionPayload.new(
              action: Protos::ChaincodeEndorsedAction.new(
                proposal_response_payload: Protos::ProposalResponsePayload.new(
                  extension: Protos::ChaincodeAction.new(
                    response: Protos::Response.new(
                      status: 200,
                      message: '',
                      payload: 'first'
                    )
                  ).to_proto
                ).to_proto
              )
            ).to_proto
          )
        ]).to_proto
    ).to_proto,
    signature: 'signature'
  )
)

[bestbeforetoday]

Some of the protobuf structures certainly are very complex -- maybe overly complex -- particularly where there are multiple nested layers of serialized protobuf messages. Unfortunately this is now a difficult thing to change.

For reference, there are similar mock messages generated in Go, Node and Java unit tests:

• fabric-gateway/pkg/client/submit_test.go

  Lines 32 to 61 in 1e4a926

  	func AssertNewEndorseResponse(t *testing.T, result string, channelName string) *gateway.EndorseResponse {
  	return &gateway.EndorseResponse{
  	PreparedTransaction: &common.Envelope{
  	Payload: AssertMarshal(t, &common.Payload{
  	Header: &common.Header{
  	ChannelHeader: AssertMarshal(t, &common.ChannelHeader{
  	ChannelId: channelName,
  	}),
  	},
  	Data: AssertMarshal(t, &peer.Transaction{
  	Actions: []*peer.TransactionAction{
  	{
  	Payload: AssertMarshal(t, &peer.ChaincodeActionPayload{
  	Action: &peer.ChaincodeEndorsedAction{
  	ProposalResponsePayload: AssertMarshal(t, &peer.ProposalResponsePayload{
  	Extension: AssertMarshal(t, &peer.ChaincodeAction{
  	Response: &peer.Response{
  	Payload: []byte(result),
  	},
  	}),
  	}),
  	},
  	}),
  	},
  	},
  	}),
  	}),
  	},
  	}
  	}

• fabric-gateway/node/src/client.test.ts

  Lines 176 to 219 in 1e4a926

  	export function newEndorseResponse(options: {
  	result: Uint8Array,
  	channelName?: string,
  	}): EndorseResponse {
  	const chaincodeResponse = new Response();
  	chaincodeResponse.setPayload(options.result);
  	const chaincodeAction = new ChaincodeAction();
  	chaincodeAction.setResponse(chaincodeResponse);
  	const responsePayload = new ProposalResponsePayload();
  	responsePayload.setExtension$(chaincodeAction.serializeBinary());
  	const endorsedAction = new ChaincodeEndorsedAction();
  	endorsedAction.setProposalResponsePayload(responsePayload.serializeBinary());
  	const actionPayload = new ChaincodeActionPayload();
  	actionPayload.setAction(endorsedAction);
  	const transactionAction = new TransactionAction();
  	transactionAction.setPayload(actionPayload.serializeBinary());
  	const transaction = new Transaction();
  	transaction.setActionsList([transactionAction]);
  	const payload = new Payload();
  	payload.setData(transaction.serializeBinary());
  	const channelHeader = new ChannelHeader();
  	channelHeader.setChannelId(options.channelName ?? 'network');
  	const header = new Header();
  	header.setChannelHeader(channelHeader.serializeBinary());
  	payload.setHeader(header);
  	const envelope = new Envelope();
  	envelope.setPayload(payload.serializeBinary());
  	const endorseResponse = new EndorseResponse();
  	endorseResponse.setPreparedTransaction(envelope);
  	return endorseResponse;
  	}

• fabric-gateway/java/src/test/java/org/hyperledger/fabric/client/TestUtils.java

  Lines 106 to 146 in 1e4a926

  	public PreparedTransaction newPreparedTransaction(String result, String channelName) {
  	Common.ChannelHeader channelHeader = Common.ChannelHeader.newBuilder()
  	.setChannelId(channelName)
  	.build();
  	Common.Header header = Common.Header.newBuilder()
  	.setChannelHeader(channelHeader.toByteString())
  	.build();
  	ProposalPackage.ChaincodeAction chaincodeAction = ProposalPackage.ChaincodeAction.newBuilder()
  	.setResponse(newResponse(result))
  	.build();
  	ProposalResponsePackage.ProposalResponsePayload responsePayload = ProposalResponsePackage.ProposalResponsePayload.newBuilder()
  	.setExtension(chaincodeAction.toByteString())
  	.build();
  	TransactionPackage.ChaincodeEndorsedAction endorsedAction = TransactionPackage.ChaincodeEndorsedAction.newBuilder()
  	.setProposalResponsePayload(responsePayload.toByteString())
  	.build();
  	TransactionPackage.ChaincodeActionPayload actionPayload = TransactionPackage.ChaincodeActionPayload.newBuilder()
  	.setAction(endorsedAction)
  	.build();
  	TransactionPackage.TransactionAction transactionAction = TransactionPackage.TransactionAction.newBuilder()
  	.setPayload(actionPayload.toByteString())
  	.build();
  	TransactionPackage.Transaction transaction = TransactionPackage.Transaction.newBuilder()
  	.addActions(transactionAction)
  	.build();
  	Common.Payload payload = Common.Payload.newBuilder()
  	.setHeader(header)
  	.setData(transaction.toByteString())
  	.build();
  	Common.Envelope envelope = Common.Envelope.newBuilder()
  	.setPayload(payload.toByteString())
  	.build();
  	return PreparedTransaction.newBuilder()
  	.setTransactionId(newFakeTransactionId())
  	.setEnvelope(envelope)
  	.build();
  	}

[jonmchan]

Thanks for pointing that out. The 12 indents 8 spaces per tab of the go test makes me want to cry. 😅 😂

[bestbeforetoday]

Welcome to the wonderful world of Go code formatting! In fairness, the Go indentation is all tabs so you can set your editor to render them as whatever number of spaces makes you happy.