Skip to content

Commit c755b4d

Browse files
slinkydeveloperslinkydeveloper
committed
Migrate test-services to new reflection api
1 parent 15b921e commit c755b4d

28 files changed

Lines changed: 378 additions & 390 deletions

‎test-services/build.gradle.kts‎

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3,14 +3,11 @@ import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform.getCurr
33
plugins {
44
`java-conventions`
55
`kotlin-conventions`
6-
alias(libs.plugins.ksp)
76
application
87
alias(libs.plugins.jib)
98
}
109

1110
dependencies {
12-
ksp(project(":sdk-api-kotlin-gen"))
13-
1411
implementation(project(":sdk-kotlin-http"))
1512
implementation(project(":sdk-request-identity"))
1613

‎test-services/src/main/kotlin/dev/restate/sdk/testservices/AwakeableHolderImpl.kt‎

Lines changed: 7 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -18,17 +18,16 @@ class AwakeableHolderImpl : AwakeableHolder {
1818
private val ID_KEY: StateKey<String> = stateKey<String>("id")
1919
}
2020

21-
override suspend fun hold(context: ObjectContext, id: String) {
22-
context.set(ID_KEY, id)
21+
override suspend fun hold(id: String) {
22+
state().set(ID_KEY, id)
2323
}
2424

25-
override suspend fun hasAwakeable(context: ObjectContext): Boolean {
26-
return context.get(ID_KEY) != null
25+
override suspend fun hasAwakeable(): Boolean {
26+
return state().get(ID_KEY) != null
2727
}
2828

29-
override suspend fun unlock(context: ObjectContext, payload: String) {
30-
val awakeableId: String =
31-
context.get(ID_KEY) ?: throw TerminalException("No awakeable registered")
32-
context.awakeableHandle(awakeableId).resolve(payload)
29+
override suspend fun unlock(payload: String) {
30+
val awakeableId = state().get(ID_KEY) ?: throw TerminalException("No awakeable registered")
31+
awakeableHandle(awakeableId).resolve(payload)
3332
}
3433
}

‎test-services/src/main/kotlin/dev/restate/sdk/testservices/BlockAndWaitWorkflowImpl.kt‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -20,24 +20,24 @@ class BlockAndWaitWorkflowImpl : BlockAndWaitWorkflow {
2020
private val MY_STATE: StateKey<String> = stateKey("my-state")
2121
}
2222

23-
override suspend fun run(context: WorkflowContext, input: String): String {
24-
context.set(MY_STATE, input)
23+
override suspend fun run(input: String): String {
24+
state().set(MY_STATE, input)
2525

2626
// Wait on unblock
27-
val output: String = context.promise(MY_DURABLE_PROMISE).future().await()
27+
val output: String = promise(MY_DURABLE_PROMISE).future().await()
2828

29-
if (!context.promise(MY_DURABLE_PROMISE).peek().isReady) {
29+
if (!promise(MY_DURABLE_PROMISE).peek().isReady) {
3030
throw TerminalException("Durable promise should be completed")
3131
}
3232

3333
return output
3434
}
3535

36-
override suspend fun unblock(context: SharedWorkflowContext, output: String) {
37-
context.promiseHandle(MY_DURABLE_PROMISE).resolve(output)
36+
override suspend fun unblock(output: String) {
37+
promiseHandle(MY_DURABLE_PROMISE).resolve(output)
3838
}
3939

40-
override suspend fun getState(context: SharedWorkflowContext): String? {
41-
return context.get(MY_STATE)
40+
override suspend fun getState(): String? {
41+
return state().get(MY_STATE)
4242
}
4343
}

‎test-services/src/main/kotlin/dev/restate/sdk/testservices/CancelTestImpl.kt‎

Lines changed: 16 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -11,10 +11,8 @@ package dev.restate.sdk.testservices
1111
import dev.restate.sdk.common.StateKey
1212
import dev.restate.sdk.common.TerminalException
1313
import dev.restate.sdk.kotlin.*
14-
import dev.restate.sdk.testservices.contracts.AwakeableHolderClient
15-
import dev.restate.sdk.testservices.contracts.BlockingOperation
14+
import dev.restate.sdk.testservices.contracts.AwakeableHolder
1615
import dev.restate.sdk.testservices.contracts.CancelTest
17-
import dev.restate.sdk.testservices.contracts.CancelTestBlockingServiceClient
1816
import kotlin.time.Duration.Companion.days
1917

2018
class CancelTestImpl {
@@ -23,45 +21,43 @@ class CancelTestImpl {
2321
private val CANCELED_STATE: StateKey<Boolean> = stateKey("canceled")
2422
}
2523

26-
override suspend fun startTest(context: ObjectContext, operation: BlockingOperation) {
27-
val client = CancelTestBlockingServiceClient.fromContext(context, context.key())
28-
24+
override suspend fun startTest(operation: CancelTest.BlockingOperation) {
2925
try {
30-
client.block(operation).await()
26+
virtualObject<CancelTest.BlockingService>(key()).block(operation)
3127
} catch (e: TerminalException) {
3228
if (e.code == TerminalException.CANCELLED_CODE) {
33-
context.set(CANCELED_STATE, true)
29+
state().set(CANCELED_STATE, true)
3430
} else {
3531
throw e
3632
}
3733
}
3834
}
3935

40-
override suspend fun verifyTest(context: ObjectContext): Boolean {
41-
return context.get(CANCELED_STATE) ?: false
36+
override suspend fun verifyTest(): Boolean {
37+
return state().get(CANCELED_STATE) ?: false
4238
}
4339
}
4440

4541
class BlockingService : CancelTest.BlockingService {
46-
override suspend fun block(context: ObjectContext, operation: BlockingOperation) {
47-
val self = CancelTestBlockingServiceClient.fromContext(context, context.key())
48-
val client = AwakeableHolderClient.fromContext(context, context.key())
42+
override suspend fun block(operation: CancelTest.BlockingOperation) {
43+
val self = virtualObject<CancelTest.BlockingService>(key())
44+
val awakeableHolder = virtualObject<AwakeableHolder>(key())
4945

50-
val awakeable = context.awakeable<String>()
51-
client.hold(awakeable.id).await()
46+
val awakeable = awakeable<String>()
47+
awakeableHolder.hold(awakeable.id)
5248
awakeable.await()
5349

5450
when (operation) {
55-
BlockingOperation.CALL -> self.block(operation).await()
56-
BlockingOperation.SLEEP -> context.sleep(1024.days)
57-
BlockingOperation.AWAKEABLE -> {
58-
val uncompletable: Awakeable<String> = context.awakeable<String>()
51+
CancelTest.BlockingOperation.CALL -> self.block(operation)
52+
CancelTest.BlockingOperation.SLEEP -> sleep(1024.days)
53+
CancelTest.BlockingOperation.AWAKEABLE -> {
54+
val uncompletable: Awakeable<String> = awakeable<String>()
5955
uncompletable.await()
6056
}
6157
}
6258
}
6359

64-
override suspend fun isUnlocked(context: ObjectContext) {
60+
override suspend fun isUnlocked() {
6561
// no-op
6662
}
6763
}

‎test-services/src/main/kotlin/dev/restate/sdk/testservices/CounterImpl.kt‎

Lines changed: 12 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,6 @@ import dev.restate.sdk.common.StateKey
1212
import dev.restate.sdk.common.TerminalException
1313
import dev.restate.sdk.kotlin.*
1414
import dev.restate.sdk.testservices.contracts.Counter
15-
import dev.restate.sdk.testservices.contracts.CounterUpdateResponse
1615
import org.apache.logging.log4j.LogManager
1716
import org.apache.logging.log4j.Logger
1817

@@ -24,37 +23,37 @@ class CounterImpl : Counter {
2423
private val COUNTER_KEY: StateKey<Long> = stateKey<Long>("counter")
2524
}
2625

27-
override suspend fun reset(context: ObjectContext) {
26+
override suspend fun reset() {
2827
logger.info("Counter cleaned up")
29-
context.clear(COUNTER_KEY)
28+
state().clear(COUNTER_KEY)
3029
}
3130

32-
override suspend fun addThenFail(context: ObjectContext, value: Long) {
33-
var counter: Long = context.get(COUNTER_KEY) ?: 0L
31+
override suspend fun addThenFail(value: Long) {
32+
var counter: Long = state().get(COUNTER_KEY) ?: 0L
3433
logger.info("Old counter value: {}", counter)
3534

3635
counter += value
37-
context.set(COUNTER_KEY, counter)
36+
state().set(COUNTER_KEY, counter)
3837

3938
logger.info("New counter value: {}", counter)
4039

41-
throw TerminalException(context.key())
40+
throw TerminalException(key())
4241
}
4342

44-
override suspend fun get(context: SharedObjectContext): Long {
45-
val counter: Long = context.get(COUNTER_KEY) ?: 0L
43+
override suspend fun get(): Long {
44+
val counter: Long = state().get(COUNTER_KEY) ?: 0L
4645
logger.info("Get counter value: {}", counter)
4746
return counter
4847
}
4948

50-
override suspend fun add(context: ObjectContext, value: Long): CounterUpdateResponse {
51-
val oldCount: Long = context.get(COUNTER_KEY) ?: 0L
49+
override suspend fun add(value: Long): Counter.CounterUpdateResponse {
50+
val oldCount: Long = state().get(COUNTER_KEY) ?: 0L
5251
val newCount = oldCount + value
53-
context.set(COUNTER_KEY, newCount)
52+
state().set(COUNTER_KEY, newCount)
5453

5554
logger.info("Old counter value: {}", oldCount)
5655
logger.info("New counter value: {}", newCount)
5756

58-
return CounterUpdateResponse(oldCount, newCount)
57+
return Counter.CounterUpdateResponse(oldCount, newCount)
5958
}
6059
}

‎test-services/src/main/kotlin/dev/restate/sdk/testservices/FailingImpl.kt‎

Lines changed: 8 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -9,11 +9,8 @@
99
package dev.restate.sdk.testservices
1010

1111
import dev.restate.sdk.common.TerminalException
12-
import dev.restate.sdk.kotlin.ObjectContext
13-
import dev.restate.sdk.kotlin.retryPolicy
14-
import dev.restate.sdk.kotlin.runBlock
12+
import dev.restate.sdk.kotlin.*
1513
import dev.restate.sdk.testservices.contracts.Failing
16-
import dev.restate.sdk.testservices.contracts.FailingClient
1714
import java.util.concurrent.atomic.AtomicInteger
1815
import kotlin.time.Duration.Companion.milliseconds
1916
import org.apache.logging.log4j.LogManager
@@ -28,26 +25,23 @@ class FailingImpl : Failing {
2825
private val eventualSuccessSideEffectCalls = AtomicInteger(0)
2926
private val eventualFailureSideEffectCalls = AtomicInteger(0)
3027

31-
override suspend fun terminallyFailingCall(context: ObjectContext, errorMessage: String) {
28+
override suspend fun terminallyFailingCall(errorMessage: String) {
3229
LOG.info("Invoked fail")
3330

3431
throw TerminalException(errorMessage)
3532
}
3633

3734
override suspend fun callTerminallyFailingCall(
38-
context: ObjectContext,
3935
errorMessage: String,
4036
): String {
4137
LOG.info("Invoked failAndHandle")
4238

43-
FailingClient.fromContext(context, context.random().nextUUID().toString())
44-
.terminallyFailingCall(errorMessage)
45-
.await()
39+
virtualObject<Failing>(random().nextUUID().toString()).terminallyFailingCall(errorMessage)
4640

4741
throw IllegalStateException("This should be unreachable")
4842
}
4943

50-
override suspend fun failingCallWithEventualSuccess(context: ObjectContext): Int {
44+
override suspend fun failingCallWithEventualSuccess(): Int {
5145
val currentAttempt = eventualSuccessCalls.incrementAndGet()
5246

5347
if (currentAttempt >= 4) {
@@ -58,17 +52,16 @@ class FailingImpl : Failing {
5852
}
5953
}
6054

61-
override suspend fun terminallyFailingSideEffect(context: ObjectContext, errorMessage: String) {
62-
context.runBlock<Unit> { throw TerminalException(errorMessage) }
55+
override suspend fun terminallyFailingSideEffect(errorMessage: String) {
56+
runBlock<Unit> { throw TerminalException(errorMessage) }
6357

6458
throw IllegalStateException("Should not be reached.")
6559
}
6660

6761
override suspend fun sideEffectSucceedsAfterGivenAttempts(
68-
context: ObjectContext,
6962
minimumAttempts: Int,
7063
): Int =
71-
context.runBlock(
64+
runBlock(
7265
name = "failing_side_effect",
7366
retryPolicy =
7467
retryPolicy {
@@ -86,11 +79,10 @@ class FailingImpl : Failing {
8679
}
8780

8881
override suspend fun sideEffectFailsAfterGivenAttempts(
89-
context: ObjectContext,
9082
retryPolicyMaxRetryCount: Int,
9183
): Int {
9284
try {
93-
context.runBlock<Unit>(
85+
runBlock<Unit>(
9486
name = "failing_side_effect",
9587
retryPolicy =
9688
retryPolicy {

‎test-services/src/main/kotlin/dev/restate/sdk/testservices/KillTestImpl.kt‎

Lines changed: 9 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -8,10 +8,9 @@
88
// https://github.com/restatedev/sdk-java/blob/main/LICENSE
99
package dev.restate.sdk.testservices
1010

11-
import dev.restate.sdk.kotlin.ObjectContext
12-
import dev.restate.sdk.testservices.contracts.AwakeableHolderClient
11+
import dev.restate.sdk.kotlin.*
12+
import dev.restate.sdk.testservices.contracts.AwakeableHolder
1313
import dev.restate.sdk.testservices.contracts.KillTest
14-
import dev.restate.sdk.testservices.contracts.KillTestSingletonClient
1514
import dev.restate.serde.Serde
1615

1716
class KillTestImpl {
@@ -21,22 +20,21 @@ class KillTestImpl {
2120
// This will ensure that we have a call tree that is two calls deep and has a pending invocation
2221
// in the inbox:
2322
// startCallTree --> recursiveCall --> recursiveCall:inboxed
24-
override suspend fun startCallTree(context: ObjectContext) {
25-
KillTestSingletonClient.fromContext(context, context.key()).recursiveCall().await()
23+
override suspend fun startCallTree() {
24+
virtualObject<KillTest.Singleton>(key()).recursiveCall()
2625
}
2726
}
2827

2928
class SingletonImpl : KillTest.Singleton {
30-
override suspend fun recursiveCall(context: ObjectContext) {
31-
val awakeable = context.awakeable(Serde.RAW)
32-
AwakeableHolderClient.fromContext(context, context.key()).send().hold(awakeable.id)
33-
29+
override suspend fun recursiveCall() {
30+
val awakeable = awakeable(Serde.RAW)
31+
toVirtualObject<AwakeableHolder>(key()).request { it.hold(awakeable.id) }.send()
3432
awakeable.await()
3533

36-
KillTestSingletonClient.fromContext(context, context.key()).recursiveCall().await()
34+
virtualObject<KillTest.Singleton>(key()).recursiveCall()
3735
}
3836

39-
override suspend fun isUnlocked(context: ObjectContext) {
37+
override suspend fun isUnlocked() {
4038
// no-op
4139
}
4240
}

‎test-services/src/main/kotlin/dev/restate/sdk/testservices/ListObjectImpl.kt‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -20,18 +20,18 @@ class ListObjectImpl : ListObject {
2020
)
2121
}
2222

23-
override suspend fun append(context: ObjectContext, value: String) {
24-
val list = context.get(LIST_KEY) ?: emptyList()
25-
context.set(LIST_KEY, list + value)
23+
override suspend fun append(value: String) {
24+
val list = state().get(LIST_KEY) ?: emptyList()
25+
state().set(LIST_KEY, list + value)
2626
}
2727

28-
override suspend fun get(context: ObjectContext): List<String> {
29-
return context.get(LIST_KEY) ?: emptyList()
28+
override suspend fun get(): List<String> {
29+
return state().get(LIST_KEY) ?: emptyList()
3030
}
3131

32-
override suspend fun clear(context: ObjectContext): List<String> {
33-
val result = context.get(LIST_KEY) ?: emptyList()
34-
context.clear(LIST_KEY)
32+
override suspend fun clear(): List<String> {
33+
val result = state().get(LIST_KEY) ?: emptyList()
34+
state().clear(LIST_KEY)
3535
return result
3636
}
3737
}

0 commit comments

Comments
 (0)