Corda - Testing a Contract with 'at least' One Output - corda

Question

I am trying to test a contract command where the rules are:
"Zero input states must be consumed" using (tx.inputs.isEmpty())
"At least one output must be created" using (tx.outputs.isNotEmpty())
How exactly do I test "At least one output must be created"?
If I test with an input, the test fails the first verification (inputs must be zero).
If I test with zero inputs/outputs, the test fails because a transaction must either consume an input, or produce an output.
If I test with a reference state, it seems not to work, suggesting an exception was expected but didn't get one.

Answer 1

If you run a test with no inputs and no outputs you will get an error before your contract code is run:
java.lang.AssertionError: Expected exception containing 'At least one output must be created' but raised exception was 'java.lang.IllegalStateException: A transaction must contain at least one input or output state'
Which is your second point in the question
If I test with zero inputs/outputs, the test fails because a transaction must either consume an input, or produce an output.
This means that you can't actually test this code in a way that checks for your specific message.
e.g. with
this `fails with` "At least one output must be created"
Essentially, your contract code checking for at least one output state is redundant, whilst you have the code that checks for zero input states.
However, you could write the test to expect the IllegalStateException.
This way, if your code changes and inputs subsequently become valid you will have a failing test that will alert you.
An alternative to checking for at least one output state in your contract code is to check for at least one state of a specific type.
e.g.
"Output states must be Demo States." using (tx.outputsOfType<DemoState>().isNotEmpty())
This way you will be able to write a meaningful test.
e.g.
Contract:
class DemoContract : Contract {
companion object {
#JvmStatic
val DEMO_CONTRACT_ID: String = DemoContract::class.java.name
}
interface Commands : CommandData {
class Issue : TypeOnlyCommandData(), Commands
}
override fun verify(tx: LedgerTransaction) {
val command = tx.commands.requireSingleCommand<Commands>()
val signers = command.signers.toSet()
when (command.value) {
is Commands.Issue -> verifyIssue(tx, signers)
else -> throw IllegalArgumentException("Unrecognised command.")
}
}
private fun verifyIssue(tx: LedgerTransaction, signers: Set<PublicKey>) = requireThat {
"No inputs are required when creating a new demo." using (tx.inputStates.isEmpty())
"Output states must be Demo States." using (tx.outputsOfType<DemoState>().isNotEmpty())
}
}
Test:
class DemoContractTests {
private val owner = TestIdentity(CordaX500Name("Series", "London", "GB"))
private val borrower = TestIdentity(CordaX500Name("One", "London", "GB"))
private val mockServices = MockServices(owner)
#Test
fun `Demo issue must have no inputs`() {
mockServices.ledger {
transaction {
input(DEMO_CONTRACT_ID, DummyState())
command(listOf(owner.publicKey, borrower.publicKey), DemoContract.Commands.Issue())
this `fails with` "No inputs are required when creating a new Demo."
}
}
}
#Test
fun `There must only be DemoState outputs`() {
mockServices.ledger {
transaction {
output(DEMO_CONTRACT_ID, DummyState(0))
command(listOf(owner.publicKey, borrower.publicKey), DemoContract.Commands.Issue())
this `fails with` "Output states must be Demo States."
}
}
}
}