#347

Committed 31 Jul 2026 06:59PM UTC coverage: 68.148% (-0.03%) from 68.181%

Build # #347

Build Type

push

github

Committed by

web-flow

Commit Message

NEXUS-485: Support Workflow Update as a Nexus Operation (#2945)

* NEXUS-485: Support Workflow Update as a Nexus Operation

* address comments, change signatures to newer

* address comments 2: add all workflow exec overloads

* address comments: log failed

Coverage Stats

7166 of 12554 branches covered (57.08%)

Branch coverage included in aggregate %.

118 of 296 new or added lines in 11 files covered. (39.86%)

28 existing lines in 7 files now uncovered.

29722 of 41575 relevant lines covered (71.49%)

0.71 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

50.0

/temporal-sdk/src/main/java/io/temporal/internal/activity/LocalActivityExecutionContextImpl.java

package io.temporal.internal.activity;

import com.uber.m3.tally.Scope;
import io.temporal.activity.ActivityInfo;
import io.temporal.activity.ManualActivityCompletionClient;
import io.temporal.client.ActivityCanceledException;
import io.temporal.client.ActivityCompletionException;
import io.temporal.client.WorkflowClient;
import io.temporal.common.CancellationToken;
import java.lang.reflect.Type;
import java.util.Optional;

class LocalActivityExecutionContextImpl implements InternalActivityExecutionContext {
  private final WorkflowClient client;
  private final Object activity;
  private final ActivityInfo info;
  private final Scope metricsScope;

  LocalActivityExecutionContextImpl(
      WorkflowClient client, Object activity, ActivityInfo info, Scope metricsScope) {
    this.client = client;
    this.activity = activity;
    this.info = info;
    this.metricsScope = metricsScope;
  }

  @Override
  public ActivityInfo getInfo() {
    return info;
  }

  @Override
  public <V> void heartbeat(V details) throws ActivityCompletionException {
    // Ignored
  }

  @Override
  public <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass) {
    return Optional.empty();
  }

  @Override
  public <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass, Type detailsGenericType) {
    return Optional.empty();
  }

  @Override
  public <V> Optional<V> getLastHeartbeatDetails(Class<V> detailsClass) {
    return Optional.empty();
  }

  @Override
  public <V> Optional<V> getLastHeartbeatDetails(Class<V> detailsClass, Type detailsGenericType) {
    return Optional.empty();
  }

  @Override
  public byte[] getTaskToken() {
    throw new UnsupportedOperationException("getTaskToken is not supported for local activities");
  }

  @Override
  public CancellationToken<ActivityCanceledException> getCancellationToken() {
    return CancellationToken.none();
  }

  @Override
  public void doNotCompleteOnReturn() {
    throw new UnsupportedOperationException(
        "doNotCompleteOnReturn is not supported for local activities");
  }

  @Override
  public boolean isDoNotCompleteOnReturn() {
    return false;
  }

  @Override
  public boolean isUseLocalManualCompletion() {
    return false;
  }

  @Override
  public ManualActivityCompletionClient useLocalManualCompletion() {
    throw new UnsupportedOperationException(
        "getManualCompletionClient is not supported for local activities");
  }

  @Override
  public Scope getMetricsScope() {
    return metricsScope;
  }

  @Override
  public Object getLastHeartbeatValue() {
    return null;
  }

  @Override
  public void asyncCompletionStarted() {
    // Ignored
  }

  @Override
  public void cancelOutstandingHeartbeat() {
    // Ignored
  }

  @Override
  public WorkflowClient getWorkflowClient() {
    return client;
  }

  @Override
  public Object getInstance() {
    return activity;
  }
}

1	package io.temporal.internal.activity;
2
3	import com.uber.m3.tally.Scope;
4	import io.temporal.activity.ActivityInfo;
5	import io.temporal.activity.ManualActivityCompletionClient;
6	import io.temporal.client.ActivityCanceledException;
7	import io.temporal.client.ActivityCompletionException;
8	import io.temporal.client.WorkflowClient;
9	import io.temporal.common.CancellationToken;
10	import java.lang.reflect.Type;
11	import java.util.Optional;
12
13	class LocalActivityExecutionContextImpl implements InternalActivityExecutionContext {
14	private final WorkflowClient client;
15	private final Object activity;
16	private final ActivityInfo info;
17	private final Scope metricsScope;
18
19	LocalActivityExecutionContextImpl(
20	WorkflowClient client, Object activity, ActivityInfo info, Scope metricsScope) {	1✔
21	this.client = client;	1✔
22	this.activity = activity;	1✔
23	this.info = info;	1✔
24	this.metricsScope = metricsScope;	1✔
25	}	1✔
26
27	@Override
28	public ActivityInfo getInfo() {
29	return info;	1✔
30	}
31
32	@Override
33	public <V> void heartbeat(V details) throws ActivityCompletionException {
34	// Ignored
UNCOV 35	}	×
36
37	@Override
38	public <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass) {
UNCOV 39	return Optional.empty();	×
40	}
41
42	@Override
43	public <V> Optional<V> getHeartbeatDetails(Class<V> detailsClass, Type detailsGenericType) {
UNCOV 44	return Optional.empty();	×
45	}
46
47	@Override
48	public <V> Optional<V> getLastHeartbeatDetails(Class<V> detailsClass) {
UNCOV 49	return Optional.empty();	×
50	}
51
52	@Override
53	public <V> Optional<V> getLastHeartbeatDetails(Class<V> detailsClass, Type detailsGenericType) {
UNCOV 54	return Optional.empty();	×
55	}
56
57	@Override
58	public byte[] getTaskToken() {
UNCOV 59	throw new UnsupportedOperationException("getTaskToken is not supported for local activities");	×
60	}
61
62	@Override
63	public CancellationToken<ActivityCanceledException> getCancellationToken() {
UNCOV 64	return CancellationToken.none();	×
65	}
66
67	@Override
68	public void doNotCompleteOnReturn() {
UNCOV 69	throw new UnsupportedOperationException(	×
70	"doNotCompleteOnReturn is not supported for local activities");
71	}
72
73	@Override
74	public boolean isDoNotCompleteOnReturn() {
75	return false;	1✔
76	}
77
78	@Override
79	public boolean isUseLocalManualCompletion() {
UNCOV 80	return false;	×
81	}
82
83	@Override
84	public ManualActivityCompletionClient useLocalManualCompletion() {
UNCOV 85	throw new UnsupportedOperationException(	×
86	"getManualCompletionClient is not supported for local activities");
87	}
88
89	@Override
90	public Scope getMetricsScope() {
UNCOV 91	return metricsScope;	×
92	}
93
94	@Override
95	public Object getLastHeartbeatValue() {
96	return null;	1✔
97	}
98
99	@Override
100	public void asyncCompletionStarted() {
101	// Ignored
UNCOV 102	}	×
103
104	@Override
105	public void cancelOutstandingHeartbeat() {
106	// Ignored
107	}	1✔
108
109	@Override
110	public WorkflowClient getWorkflowClient() {
111	return client;	1✔
112	}
113
114	@Override
115	public Object getInstance() {
116	return activity;	1✔
117	}
118	}

temporalio / sdk-java / #347

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous