mirror of
https://github.com/corda/corda.git
synced 2025-04-06 10:57:18 +00:00
core: Remove binding of State type in test dsl
This commit is contained in:
Andras Slemmer
parent
4a89be8785
commit
9b36df607e
@ -1,18 +1,21 @@
|
||||
package com.r3corda.core.testing
|
||||
|
||||
import com.r3corda.core.contracts.Attachment
|
||||
import com.r3corda.core.contracts.ContractState
|
||||
import com.r3corda.core.contracts.*
|
||||
import com.r3corda.core.crypto.SecureHash
|
||||
import com.r3corda.core.node.services.IdentityService
|
||||
import com.r3corda.core.node.services.StorageService
|
||||
import com.r3corda.core.node.services.testing.MockStorageService
|
||||
|
||||
interface LedgerDslInterpreter<State: ContractState, out TransactionInterpreter: TransactionDslInterpreter<State>> {
|
||||
fun transaction(dsl: TransactionDsl<State, TransactionInterpreter>.() -> Unit): Unit
|
||||
fun nonVerifiedTransaction(dsl: TransactionDsl<State, TransactionInterpreter>.() -> Unit): Unit
|
||||
fun tweak(dsl: LedgerDsl<State, TransactionInterpreter, LedgerDslInterpreter<State, TransactionInterpreter>>.() -> Unit)
|
||||
interface OutputStateLookup {
|
||||
fun <State: ContractState> retrieveOutputStateAndRef(clazz: Class<State>, label: String): StateAndRef<State>
|
||||
}
|
||||
|
||||
|
||||
|
||||
interface LedgerDslInterpreter<out TransactionInterpreter: TransactionDslInterpreter> :
|
||||
OutputStateLookup {
|
||||
fun transaction(transactionLabel: String?, dsl: TransactionDsl<TransactionInterpreter>.() -> Unit): WireTransaction
|
||||
fun nonVerifiedTransaction(transactionLabel: String?, dsl: TransactionDsl<TransactionInterpreter>.() -> Unit): WireTransaction
|
||||
fun tweak(dsl: LedgerDsl<TransactionInterpreter, LedgerDslInterpreter<TransactionInterpreter>>.() -> Unit)
|
||||
fun attachment(attachment: Attachment): SecureHash
|
||||
fun _verifies(identityService: IdentityService, storageService: StorageService)
|
||||
fun verifies()
|
||||
}
|
||||
|
||||
/**
|
||||
@ -21,15 +24,18 @@ interface LedgerDslInterpreter<State: ContractState, out TransactionInterpreter:
|
||||
* covariance of the TransactionInterpreter parameter
|
||||
*/
|
||||
class LedgerDsl<
|
||||
State: ContractState,
|
||||
out TransactionInterpreter: TransactionDslInterpreter<State>,
|
||||
out LedgerInterpreter: LedgerDslInterpreter<State, TransactionInterpreter>
|
||||
out TransactionInterpreter: TransactionDslInterpreter,
|
||||
out LedgerInterpreter: LedgerDslInterpreter<TransactionInterpreter>
|
||||
> (val interpreter: LedgerInterpreter)
|
||||
: LedgerDslInterpreter<State, TransactionDslInterpreter<State>> by interpreter {
|
||||
: LedgerDslInterpreter<TransactionDslInterpreter> by interpreter {
|
||||
|
||||
@JvmOverloads
|
||||
fun verifies(
|
||||
identityService: IdentityService = MOCK_IDENTITY_SERVICE,
|
||||
storageService: StorageService = MockStorageService()
|
||||
) = _verifies(identityService, storageService)
|
||||
fun transaction(dsl: TransactionDsl<TransactionDslInterpreter>.() -> Unit) = transaction(null, dsl)
|
||||
fun nonVerifiedTransaction(dsl: TransactionDsl<TransactionDslInterpreter>.() -> Unit) =
|
||||
nonVerifiedTransaction(null, dsl)
|
||||
|
||||
inline fun <reified State: ContractState> String.outputStateAndRef(): StateAndRef<State> =
|
||||
retrieveOutputStateAndRef(State::class.java, this)
|
||||
inline fun <reified State: ContractState> String.output(): TransactionState<State> =
|
||||
outputStateAndRef<State>().state
|
||||
fun String.outputRef(): StateRef = outputStateAndRef<ContractState>().ref
|
||||
}
|
||||
|
||||
@ -1,23 +1,34 @@
|
||||
package com.r3corda.core.testing
|
||||
|
||||
import com.r3corda.core.contracts.*
|
||||
import com.r3corda.core.crypto.DigitalSignature
|
||||
import com.r3corda.core.crypto.Party
|
||||
import com.r3corda.core.crypto.SecureHash
|
||||
import com.r3corda.core.crypto.signWithECDSA
|
||||
import com.r3corda.core.node.services.IdentityService
|
||||
import com.r3corda.core.node.services.StorageService
|
||||
import com.r3corda.core.node.services.testing.MockStorageService
|
||||
import com.r3corda.core.serialization.serialize
|
||||
import java.security.KeyPair
|
||||
import java.security.PublicKey
|
||||
import java.util.*
|
||||
|
||||
inline fun <reified State: ContractState> ledger(
|
||||
dsl: LedgerDsl<State, TestTransactionDslInterpreter<State>, TestLedgerDslInterpreter<State>>.() -> Unit) =
|
||||
dsl(LedgerDsl(TestLedgerDslInterpreter.create()))
|
||||
inline fun ledger(
|
||||
identityService: IdentityService = MOCK_IDENTITY_SERVICE,
|
||||
storageService: StorageService = MockStorageService(),
|
||||
dsl: LedgerDsl<TestTransactionDslInterpreter, TestLedgerDslInterpreter>.() -> Unit
|
||||
): LedgerDsl<TestTransactionDslInterpreter, TestLedgerDslInterpreter> {
|
||||
val ledgerDsl = LedgerDsl(TestLedgerDslInterpreter(identityService, storageService))
|
||||
dsl(ledgerDsl)
|
||||
return ledgerDsl
|
||||
}
|
||||
|
||||
@Deprecated(
|
||||
message = "ledger doesn't nest, use tweak",
|
||||
replaceWith = ReplaceWith("tweak"),
|
||||
level = DeprecationLevel.ERROR)
|
||||
fun <State: ContractState> TransactionDslInterpreter<State>.ledger(
|
||||
dsl: LedgerDsl<State, TestTransactionDslInterpreter<State>, TestLedgerDslInterpreter<State>>.() -> Unit) {
|
||||
fun TransactionDslInterpreter.ledger(
|
||||
dsl: LedgerDsl<TestTransactionDslInterpreter, TestLedgerDslInterpreter>.() -> Unit) {
|
||||
this.toString()
|
||||
dsl.toString()
|
||||
}
|
||||
@ -26,8 +37,8 @@ fun <State: ContractState> TransactionDslInterpreter<State>.ledger(
|
||||
message = "ledger doesn't nest, use tweak",
|
||||
replaceWith = ReplaceWith("tweak"),
|
||||
level = DeprecationLevel.ERROR)
|
||||
fun <State: ContractState> LedgerDslInterpreter<State, TransactionDslInterpreter<State>>.ledger(
|
||||
dsl: LedgerDsl<State, TestTransactionDslInterpreter<State>, TestLedgerDslInterpreter<State>>.() -> Unit) {
|
||||
fun LedgerDslInterpreter<TransactionDslInterpreter>.ledger(
|
||||
dsl: LedgerDsl<TestTransactionDslInterpreter, TestLedgerDslInterpreter>.() -> Unit) {
|
||||
this.toString()
|
||||
dsl.toString()
|
||||
}
|
||||
@ -36,17 +47,16 @@ fun <State: ContractState> LedgerDslInterpreter<State, TransactionDslInterpreter
|
||||
* This interpreter builds a transaction, and [TransactionDsl.verifies] that the resolved transaction is correct. Note
|
||||
* that transactions corresponding to input states are not verified. Use [LedgerDsl.verifies] for that.
|
||||
*/
|
||||
data class TestTransactionDslInterpreter<State: ContractState>(
|
||||
private val ledgerInterpreter: TestLedgerDslInterpreter<State>,
|
||||
data class TestTransactionDslInterpreter(
|
||||
private val ledgerInterpreter: TestLedgerDslInterpreter,
|
||||
private val inputStateRefs: ArrayList<StateRef> = arrayListOf(),
|
||||
internal val outputStates: ArrayList<LabeledOutput> = arrayListOf(),
|
||||
private val attachments: ArrayList<SecureHash> = arrayListOf(),
|
||||
private val commands: ArrayList<Command> = arrayListOf(),
|
||||
private val signers: LinkedHashSet<PublicKey> = LinkedHashSet(),
|
||||
private val transactionType: TransactionType = TransactionType.General()
|
||||
) : TransactionDslInterpreter<State> {
|
||||
|
||||
private fun copy(): TestTransactionDslInterpreter<State> =
|
||||
) : TransactionDslInterpreter, OutputStateLookup {
|
||||
private fun copy(): TestTransactionDslInterpreter =
|
||||
TestTransactionDslInterpreter(
|
||||
ledgerInterpreter = ledgerInterpreter.copy(),
|
||||
inputStateRefs = ArrayList(inputStateRefs),
|
||||
@ -68,18 +78,18 @@ data class TestTransactionDslInterpreter<State: ContractState>(
|
||||
)
|
||||
|
||||
override fun input(stateLabel: String) {
|
||||
val notary = stateLabel.output.notary.owningKey
|
||||
signers.add(notary)
|
||||
inputStateRefs.add(stateLabel.outputRef)
|
||||
val stateAndRef = retrieveOutputStateAndRef(ContractState::class.java, stateLabel)
|
||||
signers.add(stateAndRef.state.notary.owningKey)
|
||||
inputStateRefs.add(stateAndRef.ref)
|
||||
}
|
||||
|
||||
override fun input(stateRef: StateRef) {
|
||||
val notary = ledgerInterpreter.resolveStateRef(stateRef).notary
|
||||
val notary = ledgerInterpreter.resolveStateRef<ContractState>(stateRef).notary
|
||||
signers.add(notary.owningKey)
|
||||
inputStateRefs.add(stateRef)
|
||||
}
|
||||
|
||||
override fun output(label: String?, notary: Party, contractState: State) {
|
||||
override fun output(label: String?, notary: Party, contractState: ContractState) {
|
||||
outputStates.add(LabeledOutput(label, TransactionState(contractState, notary)))
|
||||
}
|
||||
|
||||
@ -92,14 +102,14 @@ data class TestTransactionDslInterpreter<State: ContractState>(
|
||||
commands.add(Command(commandData, signers))
|
||||
}
|
||||
|
||||
override fun _verifies(identityService: IdentityService) {
|
||||
val resolvedTransaction = ledgerInterpreter.resolveWireTransaction(toWireTransaction(), identityService)
|
||||
override fun verifies() {
|
||||
val resolvedTransaction = ledgerInterpreter.resolveWireTransaction(toWireTransaction())
|
||||
resolvedTransaction.verify()
|
||||
}
|
||||
|
||||
override fun failsWith(expectedMessage: String?, identityService: IdentityService) {
|
||||
override fun failsWith(expectedMessage: String?) {
|
||||
val exceptionThrown = try {
|
||||
_verifies(identityService)
|
||||
verifies()
|
||||
false
|
||||
} catch (exception: Exception) {
|
||||
if (expectedMessage != null) {
|
||||
@ -110,7 +120,7 @@ data class TestTransactionDslInterpreter<State: ContractState>(
|
||||
)
|
||||
} else if (!exceptionMessage.toLowerCase().contains(expectedMessage.toLowerCase())) {
|
||||
throw AssertionError(
|
||||
"Expected exception containing '$expectedMessage' but raised exception was '$exceptionMessage'"
|
||||
"Expected exception containing '$expectedMessage' but raised exception was '$exception'"
|
||||
)
|
||||
}
|
||||
}
|
||||
@ -122,58 +132,60 @@ data class TestTransactionDslInterpreter<State: ContractState>(
|
||||
}
|
||||
}
|
||||
|
||||
override fun tweak(dsl: TransactionDsl<State, TransactionDslInterpreter<State>>.() -> Unit) =
|
||||
override fun tweak(dsl: TransactionDsl<TransactionDslInterpreter>.() -> Unit) =
|
||||
dsl(TransactionDsl(copy()))
|
||||
|
||||
override fun retrieveOutputStateAndRef(label: String): StateAndRef<State>? =
|
||||
ledgerInterpreter.labelToOutputStateAndRefs[label]
|
||||
override fun <State: ContractState> retrieveOutputStateAndRef(clazz: Class<State>, label: String) = ledgerInterpreter.retrieveOutputStateAndRef(clazz, label)
|
||||
}
|
||||
|
||||
class AttachmentResolutionException(val attachmentId: SecureHash) :
|
||||
class AttachmentResolutionException(attachmentId: SecureHash) :
|
||||
Exception("Attachment with id $attachmentId not found")
|
||||
|
||||
data class TestLedgerDslInterpreter<State: ContractState> private constructor (
|
||||
internal val stateClazz: Class<State>,
|
||||
internal val labelToOutputStateAndRefs: HashMap<String, StateAndRef<State>> = HashMap(),
|
||||
data class TestLedgerDslInterpreter private constructor (
|
||||
private val identityService: IdentityService,
|
||||
private val storageService: StorageService,
|
||||
internal val labelToOutputStateAndRefs: HashMap<String, StateAndRef<ContractState>> = HashMap(),
|
||||
private val transactionWithLocations: HashMap<SecureHash, WireTransactionWithLocation> = HashMap(),
|
||||
private val nonVerifiedTransactionWithLocations: HashMap<SecureHash, WireTransactionWithLocation> = HashMap(),
|
||||
private val attachments: HashMap<SecureHash, Attachment> = HashMap()
|
||||
) : LedgerDslInterpreter<State, TestTransactionDslInterpreter<State>> {
|
||||
private val nonVerifiedTransactionWithLocations: HashMap<SecureHash, WireTransactionWithLocation> = HashMap()
|
||||
) : LedgerDslInterpreter<TestTransactionDslInterpreter> {
|
||||
|
||||
// We specify [labelToOutputStateAndRefs] just so that Kotlin picks the primary constructor instead of cycling
|
||||
constructor(stateClazz: Class<State>) : this(stateClazz, labelToOutputStateAndRefs = HashMap())
|
||||
constructor(identityService: IdentityService, storageService: StorageService) : this(
|
||||
identityService, storageService, labelToOutputStateAndRefs = HashMap()
|
||||
)
|
||||
|
||||
companion object {
|
||||
/**
|
||||
* Convenience factory to avoid having to pass in the Class
|
||||
*/
|
||||
inline fun <reified State: ContractState> create() = TestLedgerDslInterpreter(State::class.java)
|
||||
|
||||
private fun getCallerLocation(offset: Int): String {
|
||||
val stackTraceElement = Thread.currentThread().stackTrace[3 + offset]
|
||||
return stackTraceElement.toString()
|
||||
}
|
||||
}
|
||||
|
||||
private data class WireTransactionWithLocation(val transaction: WireTransaction, val location: String)
|
||||
private class VerifiesFailed(transactionLocation: String, cause: Throwable) :
|
||||
internal data class WireTransactionWithLocation(
|
||||
val label: String?,
|
||||
val transaction: WireTransaction,
|
||||
val location: String
|
||||
)
|
||||
class VerifiesFailed(transactionLocation: String, cause: Throwable) :
|
||||
Exception("Transaction defined at ($transactionLocation) didn't verify: $cause", cause)
|
||||
class TypeMismatch(requested: Class<*>, actual: Class<*>) :
|
||||
Exception("Actual type $actual is not a subtype of requested type $requested")
|
||||
|
||||
internal fun copy(): TestLedgerDslInterpreter<State> =
|
||||
internal fun copy(): TestLedgerDslInterpreter =
|
||||
TestLedgerDslInterpreter(
|
||||
stateClazz = stateClazz,
|
||||
identityService,
|
||||
storageService,
|
||||
labelToOutputStateAndRefs = HashMap(labelToOutputStateAndRefs),
|
||||
transactionWithLocations = HashMap(transactionWithLocations),
|
||||
nonVerifiedTransactionWithLocations = HashMap(nonVerifiedTransactionWithLocations),
|
||||
attachments = HashMap(attachments)
|
||||
nonVerifiedTransactionWithLocations = HashMap(nonVerifiedTransactionWithLocations)
|
||||
)
|
||||
|
||||
fun resolveWireTransaction(wireTransaction: WireTransaction, identityService: IdentityService): TransactionForVerification {
|
||||
internal fun resolveWireTransaction(wireTransaction: WireTransaction): TransactionForVerification {
|
||||
return wireTransaction.run {
|
||||
val authenticatedCommands = commands.map {
|
||||
AuthenticatedObject(it.signers, it.signers.mapNotNull { identityService.partyFromKey(it) }, it.value)
|
||||
}
|
||||
val resolvedInputStates = inputs.map { resolveStateRef(it) }
|
||||
val resolvedInputStates = inputs.map { resolveStateRef<ContractState>(it) }
|
||||
val resolvedAttachments = attachments.map { resolveAttachment(it) }
|
||||
TransactionForVerification(
|
||||
inputs = resolvedInputStates,
|
||||
@ -188,30 +200,30 @@ data class TestLedgerDslInterpreter<State: ContractState> private constructor (
|
||||
}
|
||||
}
|
||||
|
||||
fun resolveStateRef(stateRef: StateRef): TransactionState<State> {
|
||||
internal inline fun <reified State: ContractState> resolveStateRef(stateRef: StateRef): TransactionState<State> {
|
||||
val transactionWithLocation =
|
||||
transactionWithLocations[stateRef.txhash] ?:
|
||||
nonVerifiedTransactionWithLocations[stateRef.txhash] ?:
|
||||
throw TransactionResolutionException(stateRef.txhash)
|
||||
val output = transactionWithLocation.transaction.outputs[stateRef.index]
|
||||
return if (stateClazz.isInstance(output.data)) @Suppress("UNCHECKED_CAST") {
|
||||
return if (State::class.java.isAssignableFrom(output.data.javaClass)) @Suppress("UNCHECKED_CAST") {
|
||||
output as TransactionState<State>
|
||||
} else {
|
||||
throw IllegalArgumentException("Referenced state is of another type than requested")
|
||||
throw TypeMismatch(requested = State::class.java, actual = output.data.javaClass)
|
||||
}
|
||||
}
|
||||
|
||||
fun resolveAttachment(attachmentId: SecureHash): Attachment =
|
||||
attachments[attachmentId] ?: throw AttachmentResolutionException(attachmentId)
|
||||
internal fun resolveAttachment(attachmentId: SecureHash): Attachment =
|
||||
storageService.attachments.openAttachment(attachmentId) ?: throw AttachmentResolutionException(attachmentId)
|
||||
|
||||
private fun interpretTransactionDsl(dsl: TransactionDsl<State, TestTransactionDslInterpreter<State>>.() -> Unit):
|
||||
TestTransactionDslInterpreter<State> {
|
||||
private fun interpretTransactionDsl(dsl: TransactionDsl<TestTransactionDslInterpreter>.() -> Unit):
|
||||
TestTransactionDslInterpreter {
|
||||
val transactionInterpreter = TestTransactionDslInterpreter(this)
|
||||
dsl(TransactionDsl(transactionInterpreter))
|
||||
return transactionInterpreter
|
||||
}
|
||||
|
||||
private fun toTransactionGroup(identityService: IdentityService, storageService: StorageService): TransactionGroup {
|
||||
fun toTransactionGroup(): TransactionGroup {
|
||||
val ledgerTransactions = transactionWithLocations.map {
|
||||
it.value.transaction.toLedgerTransaction(identityService, storageService.attachments)
|
||||
}
|
||||
@ -221,10 +233,23 @@ data class TestLedgerDslInterpreter<State: ContractState> private constructor (
|
||||
return TransactionGroup(ledgerTransactions.toSet(), nonVerifiedLedgerTransactions.toSet())
|
||||
}
|
||||
|
||||
fun transactionName(transactionHash: SecureHash): String? {
|
||||
val transactionWithLocation = transactionWithLocations[transactionHash]
|
||||
return if (transactionWithLocation != null) {
|
||||
transactionWithLocation.label ?: "TX[${transactionWithLocation.location}]"
|
||||
} else {
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
fun outputToLabel(state: ContractState): String? =
|
||||
labelToOutputStateAndRefs.filter { it.value.state.data == state }.keys.firstOrNull()
|
||||
|
||||
private fun recordTransactionWithTransactionMap(
|
||||
dsl: TransactionDsl<State, TestTransactionDslInterpreter<State>>.() -> Unit,
|
||||
transactionLabel: String?,
|
||||
dsl: TransactionDsl<TestTransactionDslInterpreter>.() -> Unit,
|
||||
transactionMap: HashMap<SecureHash, WireTransactionWithLocation> = HashMap()
|
||||
) {
|
||||
): WireTransaction {
|
||||
val transactionLocation = getCallerLocation(3)
|
||||
val transactionInterpreter = interpretTransactionDsl(dsl)
|
||||
// Create the WireTransaction
|
||||
@ -237,38 +262,67 @@ data class TestLedgerDslInterpreter<State: ContractState> private constructor (
|
||||
}
|
||||
|
||||
transactionMap[wireTransaction.serialized.hash] =
|
||||
WireTransactionWithLocation(wireTransaction, transactionLocation)
|
||||
WireTransactionWithLocation(transactionLabel, wireTransaction, transactionLocation)
|
||||
|
||||
return wireTransaction
|
||||
}
|
||||
|
||||
override fun transaction(dsl: TransactionDsl<State, TestTransactionDslInterpreter<State>>.() -> Unit) =
|
||||
recordTransactionWithTransactionMap(dsl, transactionWithLocations)
|
||||
override fun transaction(transactionLabel: String?, dsl: TransactionDsl<TestTransactionDslInterpreter>.() -> Unit) =
|
||||
recordTransactionWithTransactionMap(transactionLabel, dsl, transactionWithLocations)
|
||||
|
||||
override fun nonVerifiedTransaction(dsl: TransactionDsl<State, TestTransactionDslInterpreter<State>>.() -> Unit) =
|
||||
recordTransactionWithTransactionMap(dsl, nonVerifiedTransactionWithLocations)
|
||||
override fun nonVerifiedTransaction(transactionLabel: String?, dsl: TransactionDsl<TestTransactionDslInterpreter>.() -> Unit) =
|
||||
recordTransactionWithTransactionMap(transactionLabel, dsl, nonVerifiedTransactionWithLocations)
|
||||
|
||||
override fun tweak(
|
||||
dsl: LedgerDsl<State, TestTransactionDslInterpreter<State>,
|
||||
LedgerDslInterpreter<State, TestTransactionDslInterpreter<State>>>.() -> Unit) =
|
||||
dsl: LedgerDsl<TestTransactionDslInterpreter,
|
||||
LedgerDslInterpreter<TestTransactionDslInterpreter>>.() -> Unit) =
|
||||
dsl(LedgerDsl(copy()))
|
||||
|
||||
override fun attachment(attachment: Attachment): SecureHash {
|
||||
attachments[attachment.id] = attachment
|
||||
storageService.attachments.importAttachment(attachment.open())
|
||||
return attachment.id
|
||||
}
|
||||
|
||||
override fun _verifies(identityService: IdentityService, storageService: StorageService) {
|
||||
val transactionGroup = toTransactionGroup(identityService, storageService)
|
||||
override fun verifies() {
|
||||
val transactionGroup = toTransactionGroup()
|
||||
try {
|
||||
transactionGroup.verify()
|
||||
} catch (exception: TransactionVerificationException) {
|
||||
throw VerifiesFailed(transactionWithLocations[exception.tx.origHash]?.location ?: "<unknown>", exception)
|
||||
}
|
||||
}
|
||||
|
||||
override fun <State: ContractState> retrieveOutputStateAndRef(clazz: Class<State>, label: String): StateAndRef<State> {
|
||||
val stateAndRef = labelToOutputStateAndRefs[label]
|
||||
if (stateAndRef == null) {
|
||||
throw IllegalArgumentException("State with label '$label' was not found")
|
||||
} else if (!clazz.isAssignableFrom(stateAndRef.state.data.javaClass)) {
|
||||
throw TypeMismatch(requested = clazz, actual = stateAndRef.state.data.javaClass)
|
||||
} else {
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
return stateAndRef as StateAndRef<State>
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun signAll(transactionsToSign: List<WireTransaction>, vararg extraKeys: KeyPair): List<SignedTransaction> {
|
||||
return transactionsToSign.map { wtx ->
|
||||
val allPubKeys = wtx.signers.toMutableSet()
|
||||
val bits = wtx.serialize()
|
||||
require(bits == wtx.serialized)
|
||||
val signatures = ArrayList<DigitalSignature.WithKey>()
|
||||
for (key in ALL_TEST_KEYS + extraKeys) {
|
||||
if (allPubKeys.contains(key.public)) {
|
||||
signatures += key.signWithECDSA(bits)
|
||||
allPubKeys -= key.public
|
||||
}
|
||||
}
|
||||
SignedTransaction(bits, signatures)
|
||||
}
|
||||
}
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
ledger<ContractState> {
|
||||
ledger {
|
||||
nonVerifiedTransaction {
|
||||
output("hello") { DummyLinearState() }
|
||||
}
|
||||
|
||||
@ -6,7 +6,6 @@ import com.google.common.base.Throwables
|
||||
import com.google.common.net.HostAndPort
|
||||
import com.r3corda.core.contracts.*
|
||||
import com.r3corda.core.crypto.*
|
||||
import com.r3corda.core.node.services.IdentityService
|
||||
import com.r3corda.core.node.services.testing.MockIdentityService
|
||||
import com.r3corda.core.node.services.testing.MockStorageService
|
||||
import com.r3corda.core.seconds
|
||||
@ -219,22 +218,21 @@ open class TransactionForTest : AbstractTransactionForTest() {
|
||||
}
|
||||
fun input(s: ContractState) = input { s }
|
||||
|
||||
protected fun runCommandsAndVerify(time: Instant) {
|
||||
protected fun runCommandsAndVerify() {
|
||||
val cmds = commandsToAuthenticatedObjects()
|
||||
val tx = TransactionForVerification(inStates, outStates.map { it.state }, emptyList(), cmds, SecureHash.Companion.randomSHA256(), signers.toList(), type)
|
||||
tx.verify()
|
||||
}
|
||||
|
||||
@JvmOverloads
|
||||
fun accepts(time: Instant = TEST_TX_TIME): LastLineShouldTestForAcceptOrFailure {
|
||||
runCommandsAndVerify(time)
|
||||
fun accepts(): LastLineShouldTestForAcceptOrFailure {
|
||||
runCommandsAndVerify()
|
||||
return LastLineShouldTestForAcceptOrFailure.Token
|
||||
}
|
||||
|
||||
@JvmOverloads
|
||||
fun rejects(withMessage: String? = null, time: Instant = TEST_TX_TIME): LastLineShouldTestForAcceptOrFailure {
|
||||
fun rejects(withMessage: String? = null): LastLineShouldTestForAcceptOrFailure {
|
||||
val r = try {
|
||||
runCommandsAndVerify(time)
|
||||
runCommandsAndVerify()
|
||||
false
|
||||
} catch (e: Exception) {
|
||||
val m = e.message
|
||||
@ -300,7 +298,7 @@ open class TransactionForTest : AbstractTransactionForTest() {
|
||||
}
|
||||
}
|
||||
|
||||
class TransactionGroupDSL<T : ContractState>(private val stateType: Class<T>) {
|
||||
class TransactionGroupDSL<out T : ContractState>(private val stateType: Class<T>) {
|
||||
open inner class WireTransactionDSL : AbstractTransactionForTest() {
|
||||
private val inStates = ArrayList<StateRef>()
|
||||
|
||||
|
||||
@ -15,50 +15,39 @@ import java.time.Instant
|
||||
* TODO: Move the [State] binding to the primitives' level to allow different State types, use reflection to check types
|
||||
* dynamically, come up with a substitute for primitives relying on early bind
|
||||
*/
|
||||
interface TransactionDslInterpreter<State: ContractState> {
|
||||
interface TransactionDslInterpreter : OutputStateLookup {
|
||||
fun input(stateLabel: String)
|
||||
fun input(stateRef: StateRef)
|
||||
fun output(label: String?, notary: Party, contractState: State)
|
||||
fun output(label: String?, notary: Party, contractState: ContractState)
|
||||
fun attachment(attachmentId: SecureHash)
|
||||
fun _command(signers: List<PublicKey>, commandData: CommandData)
|
||||
fun _verifies(identityService: IdentityService)
|
||||
fun failsWith(expectedMessage: String?, identityService: IdentityService)
|
||||
fun tweak(dsl: TransactionDsl<State, TransactionDslInterpreter<State>>.() -> Unit)
|
||||
fun retrieveOutputStateAndRef(label: String): StateAndRef<State>?
|
||||
|
||||
val String.outputStateAndRef: StateAndRef<State>
|
||||
get() = retrieveOutputStateAndRef(this) ?: throw IllegalArgumentException("State with label '$this' was not found")
|
||||
val String.output: TransactionState<State>
|
||||
get() = outputStateAndRef.state
|
||||
val String.outputRef: StateRef
|
||||
get() = outputStateAndRef.ref
|
||||
fun verifies()
|
||||
fun failsWith(expectedMessage: String?)
|
||||
fun tweak(dsl: TransactionDsl<TransactionDslInterpreter>.() -> Unit)
|
||||
}
|
||||
|
||||
|
||||
class TransactionDsl<
|
||||
State: ContractState,
|
||||
out TransactionInterpreter: TransactionDslInterpreter<State>
|
||||
out TransactionInterpreter: TransactionDslInterpreter
|
||||
> (val interpreter: TransactionInterpreter)
|
||||
: TransactionDslInterpreter<State> by interpreter {
|
||||
: TransactionDslInterpreter by interpreter {
|
||||
|
||||
// Convenience functions
|
||||
fun output(label: String? = null, notary: Party = DUMMY_NOTARY, contractStateClosure: () -> State) =
|
||||
fun output(label: String? = null, notary: Party = DUMMY_NOTARY, contractStateClosure: () -> ContractState) =
|
||||
output(label, notary, contractStateClosure())
|
||||
@JvmOverloads
|
||||
fun output(label: String? = null, contractState: State) = output(label, DUMMY_NOTARY, contractState)
|
||||
fun output(label: String? = null, contractState: ContractState) = output(label, DUMMY_NOTARY, contractState)
|
||||
|
||||
fun command(vararg signers: PublicKey, commandDataClosure: () -> CommandData) =
|
||||
_command(listOf(*signers), commandDataClosure())
|
||||
fun command(signer: PublicKey, commandData: CommandData) = _command(listOf(signer), commandData)
|
||||
|
||||
fun verifies(identityService: IdentityService = MOCK_IDENTITY_SERVICE) = _verifies(identityService)
|
||||
|
||||
@JvmOverloads
|
||||
fun timestamp(time: Instant, notary: PublicKey = DUMMY_NOTARY.owningKey) =
|
||||
timestamp(TimestampCommand(time, 30.seconds), notary)
|
||||
@JvmOverloads
|
||||
fun timestamp(data: TimestampCommand, notary: PublicKey = DUMMY_NOTARY.owningKey) = command(notary, data)
|
||||
|
||||
fun fails(identityService: IdentityService = MOCK_IDENTITY_SERVICE) = failsWith(null, identityService)
|
||||
infix fun `fails with`(msg: String) = failsWith(msg, MOCK_IDENTITY_SERVICE)
|
||||
fun fails() = failsWith(null)
|
||||
infix fun `fails with`(msg: String) = failsWith(msg)
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user