Vihren Atlas

Atlas › Test

TestTestLogger_Failure_OnExpectedMatch

go.temporal.io/server/common/testing/testlogger/TestTestLogger_Failure_OnExpectedMatch

Package
go.temporal.io/server/common/testing/testlogger
Suite / test hierarchy
TestTestLogger_Failure_OnExpectedMatch
Test
TestTestLogger_Failure_OnExpectedMatch
Introduced at
TestTestLogger_Failure_OnExpectedMatch Test frontier
Covered ranges
99
Covered lines
495
Covered files
15

Covered source

Expand a file to inspect source; the > gutter marks covered lines.

go.temporal.io/server/common/testing/testlogger/testlogger.go 204 covered LOC · 53 ranges

Open complete file

94 }
95
96 > func newMatcher(msg string, tags []tag.Tag, e *Expectation) matcher { testlogger.go
97 > var rgx *regexp.Regexp
98 > if msg != "" {
99 > rgx = regexp.MustCompile(msg) testlogger.go
100 > }
101 > m := matcher{ testlogger.go
102 > expectation: e,
103 > msg: rgx,
104 > tags: map[string]*regexp.Regexp{},
105 > }
106 > for _, t := range tags {
107 > m.tags[t.Key()] = regexp.MustCompile(formatValue(t)) testlogger.go
108 > }
109 > return m testlogger.go
110 }
111
112 > func (m matcher) Matches(msg string, tags []tag.Tag) bool { testlogger.go
113 > // A nil regexp (meaning original string "") means we're only matching based on tags.
114 > if m.msg != nil && !m.msg.MatchString(msg) {
115 return false
116 }
117
118 > if len(m.tags) == 0 { testlogger.go
119 return true
120 }
122 // We need to match all tags specified in the matcher,
123 // not all tags on the message
124 > remainingMatches := len(m.tags) testlogger.go
125 > for _, t := range tags {
126 > pat, ok := m.tags[t.Key()]
127 > if !ok {
128 continue
129 }
130 > if pat.MatchString(formatValue(t)) { testlogger.go
131 > remainingMatches--
132 > }
133 }
134 > return remainingMatches == 0 testlogger.go
135 }
136
235 )
236
237 > func getGlobalFileCore() zapcore.Core { testlogger.go
238 > globalFileCoreOnce.Do(func() {
239 > logFile := os.Getenv(log.TestLogFileEnvVar)
240 > if logFile == "" {
241 return
242 }
243 > if err := os.MkdirAll(filepath.Dir(logFile), 0o755); err != nil { testlogger.go
244 fmt.Fprintf(os.Stderr, "testlogger: failed to create log file dir %s: %v\n", filepath.Dir(logFile), err)
245 return
246 }
247 > f, err := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644) testlogger.go
248 > if err != nil {
249 fmt.Fprintf(os.Stderr, "testlogger: failed to open log file %s: %v\n", logFile, err)
250 return
251 }
252 > format := cmp.Or(os.Getenv(log.TestLogFileFormatEnvVar), "json") testlogger.go
253 > var enc zapcore.Encoder
254 > switch strings.ToLower(format) {
255 case "console":
256 enc = zapcore.NewConsoleEncoder(log.DefaultZapEncoderConfig)
257 > default: // "json" and anything unrecognized testlogger.go
258 > enc = zapcore.NewJSONEncoder(log.DefaultZapEncoderConfig)
259 }
260 > level := zapcore.DebugLevel testlogger.go
261 > if levelV := os.Getenv(log.TestLogFileLevelEnvVar); levelV != "" {
262 level = log.ParseZapLevel(levelV)
263 }
264 > globalFileCore = zapcore.NewCore(enc, zapcore.AddSync(f), level) testlogger.go
265 > fmt.Fprintf(os.Stderr, "testlogger: file logging enabled → %s (format=%s level=%s)\n", logFile, format, level)
266 })
267 > return globalFileCore testlogger.go
268 }
269
270 // NewTestLogger creates a new TestLogger that logs to the provided testing.T.
271 // Mode controls the behavior of the logger for when an expected or unexpected error is encountered.
272 > func NewTestLogger(t TestingT, mode Mode, opts ...LoggerOption) *TestLogger { testlogger.go
273 > tl := &TestLogger{
274 > state: &sharedTestLoggerState{
275 > t: t,
276 > logExpectations: false,
277 > level: zapcore.DebugLevel,
278 > logCaller: true,
279 > mode: mode,
280 > },
281 > }
282 > tl.state.mu.expectations = make(map[Level]*list.List)
283 > tl.state.failOnError.Store(true)
284 > tl.state.failOnDPanic.Store(true)
285 > tl.state.failOnFatal.Store(true)
286 > for _, opt := range opts {
287 opt(tl)
288 }
289 > if tl.wrapped == nil { testlogger.go
290 > writer := zaptest.NewTestingWriter(t)
291 >
292 > // Console core: format and level controlled by TEMPORAL_TEST_LOG_FORMAT / TEMPORAL_TEST_LOG_LEVEL.
293 > var consoleEnc zapcore.Encoder
294 > format := cmp.Or(os.Getenv(log.TestLogFormatEnvVar), "console")
295 > switch strings.ToLower(format) {
296 > case "console":
297 > consoleEnc = zapcore.NewConsoleEncoder(log.DefaultZapEncoderConfig)
298 case "json":
299 consoleEnc = zapcore.NewJSONEncoder(log.DefaultZapEncoderConfig)
301 t.Fatalf("unknown log encoding %q", format)
302 }
303 > consoleLevel := tl.state.level testlogger.go
304 > if levelV := os.Getenv(log.TestLogLevelEnvVar); levelV != "" {
305 consoleLevel = log.ParseZapLevel(levelV)
306 }
307 > core := zapcore.NewTee( testlogger.go
308 > zapcore.NewCore(consoleEnc, writer, consoleLevel),
309 > getGlobalFileCore())
310 >
311 > zapOptions := []zap.Option{
312 > zap.ErrorOutput(writer.WithMarkFailed(true)),
313 > zap.AddStacktrace(zap.ErrorLevel), // only include stack traces for logs with level error and above
314 > zap.WithCaller(tl.state.logCaller),
315 > }
316 >
317 > // Skip(1) skips the TestLogger itself
318 > tl.wrapped = log.NewZapLogger(zap.New(core, zapOptions...)).Skip(1)
319 }
320
321 // Only possible with a *testing.T until *rapid.T supports `Cleanup`
322 > if ct, ok := t.(CleanupCapableT); ok { testlogger.go
323 > // NOTE(tim): We don't care about anything logged after the test completes. Sure, this is racy,
324 > // but it reduces the likelihood that we see stupid errors due to testing.T.Logf race conditions...
325 > ct.Cleanup(tl.Close)
326 > }
327
328 > return tl testlogger.go
329 }
330
333 // the test logger, the expectation either acts as an entry in a blocklist
334 // (FailOnExpectedErrorOnly) or an allowlist (FailOnAnyUnexpectedError).
335 > func (tl *TestLogger) Expect(level Level, msg string, tags ...tag.Tag) *Expectation { testlogger.go
336 > tl.state.mu.Lock()
337 > defer tl.state.mu.Unlock()
338 > if tl.state.logExpectations {
339 tl.wrapped.Info(fmt.Sprintf("(%p) TestLogger::Expecting: '%s'\n", tl, msg))
340 }
341 > e := &Expectation{ testlogger.go
342 > testLogger: tl,
343 > lvl: level,
344 > }
345 > m := newMatcher(msg, tags, e)
346 > expectations, ok := tl.state.mu.expectations[level]
347 > if !ok {
348 > expectations = list.New()
349 > tl.state.mu.expectations[level] = expectations
350 > }
351 > e.e = expectations.PushBack(m)
352 > return e
353 }
354
361 }
362
363 > func (tl *TestLogger) shouldFailTest(level Level, msg string, tags []tag.Tag) bool { testlogger.go
364 > // Only check expectations if they've been registered for this level.
365 > if expectations, found := tl.state.mu.expectations[level]; found {
366 > for e := expectations.Front(); e != nil; e = e.Next() { testlogger.go
367 > m, ok := e.Value.(matcher)
368 > if !ok {
369 tl.state.t.Fatalf("Bug in TestLogger: invalid %T value in matcher list", e.Value)
370 }
371 > if m.Matches(msg, tags) { testlogger.go
372 > return tl.state.mode == FailOnExpectedErrorOnly testlogger.go
373 > }
374 }
375 }
385 // observational: it never affects whether the test fails (that remains the sole
386 // job of shouldFailTest), so it is safe to call for any log at any level.
387 > func (tl *TestLogger) recordExpectationMatches(level Level, msg string, tags []tag.Tag) { testlogger.go
388 > expectations, found := tl.state.mu.expectations[level]
389 > if !found {
390 return
391 }
392 > for e := expectations.Front(); e != nil; e = e.Next() { testlogger.go
393 > m, ok := e.Value.(matcher)
394 > if !ok {
395 tl.state.t.Fatalf("Bug in TestLogger: invalid %T value in matcher list", e.Value)
396 }
397 > if m.Matches(msg, tags) { testlogger.go
398 > m.expectation.matches.Add(1) testlogger.go
399 > }
400 }
401 }
422 // Failure returns the first Failure that shouldFailTest considered a test-failing
423 // log, or nil if no such log has been observed. Sticky: first failure wins.
424 > func (tl *TestLogger) Failure() *Failure { testlogger.go
425 > return tl.state.failure.Load()
426 > }
427
428 // recordFailure stores the first observed failure (first-failure-wins via CAS).
429 // Tags are copied so the recorded value is independent of the caller's slice.
430 > func (tl *TestLogger) recordFailure(level Level, msg string, tags []tag.Tag) { testlogger.go
431 > if tl.state.failure.Load() != nil {
432 // fast-path: already recorded; avoid the copy and the stack capture.
433 return
434 }
435 > tagsCopy := make([]tag.Tag, len(tags)) testlogger.go
436 > copy(tagsCopy, tags)
437 > f := &Failure{
438 > Level: level,
439 > Msg: msg,
440 > Tags: tagsCopy,
441 > Stack: captureStack(3), // skip captureStack, recordFailure, and the log.Logger method that called it
442 > }
443 > tl.state.failure.CompareAndSwap(nil, f)
444 }
445
446 > func (tl *TestLogger) mergeWithLoggerTags(tags []tag.Tag) []tag.Tag { testlogger.go
447 > if len(tl.tags) == 0 {
448 > return tags
449 > }
450 tagMap := make(map[string]tag.Tag, len(tl.tags)+len(tags))
451 // Iterate over the logger's tags first so that explicitly specified tags override them
496
497 // Error implements log.Logger.
498 > func (tl *TestLogger) Error(msg string, tags ...tag.Tag) { testlogger.go
499 > tl.state.mu.RLock()
500 > if tl.state.mu.closed {
501 tl.state.mu.RUnlock()
502 return
503 }
504 > tags = tl.mergeWithLoggerTags(tags) testlogger.go
505 > tl.recordExpectationMatches(Error, msg, tags)
506 > if !tl.shouldFailTest(Error, msg, tags) {
507 tl.wrapped.Error(msg, tags...)
508 tl.state.mu.RUnlock()
509 return
510 }
511 > tl.state.mu.RUnlock() testlogger.go
512 >
513 > if tl.state.failOnError.Load() {
514 > tl.state.t.Helper()
515 > tl.wrapped.Error(msg, tags...)
516 > tl.failTest(Error, msg, tags...)
517 > }
518
519 // Labeling the error as unexpected; so it can easily be identified later.
520 > tl.wrapped.Error(errorMessage(Error, msg), tags...) testlogger.go
521 }
522
588 // failTest fails the test while dumping the stack, allowing us to know where in the code
589 // the failure arose.
590 > func (tl *TestLogger) failTest(level Level, msg string, tags ...tag.Tag) { testlogger.go
591 > tl.state.t.Helper()
592 > tl.recordFailure(level, msg, tags)
593 > // skip captureStack, failTest, and the log.Logger function that called failTest
594 > tl.state.t.Fatalf("%s\n%s", failureMessage(level, msg, tags), captureStack(3))
595 > }
596
597 // captureStack returns a formatted stack trace, skipping the first `skip` frames
598 // (including the captureStack frame itself).
599 > func captureStack(skip int) string { testlogger.go
600 > pcs := make([]uintptr, 128) // 128 is likely larger than we'll ever need.
601 > frameCount := runtime.Callers(skip, pcs)
602 >
603 > // runtime.Callers truncates the recorded stacktrace to fit the provided slice.
604 > // Just keep doubling in size until we have enough space.
605 > for frameCount == len(pcs) {
606 pcs = make([]uintptr, len(pcs)*2)
607 frameCount = runtime.Callers(skip, pcs)
608 }
609
610 > stackFrames := runtime.CallersFrames(pcs[:frameCount]) testlogger.go
611 > var stackTrace strings.Builder
612 > for {
613 > frame, more := stackFrames.Next()
614 > fmt.Fprintf(&stackTrace, "%s:%d %s\n", frame.File, frame.Line, frame.Function)
615 > if !more {
616 > break
617 }
618 }
619 > return stackTrace.String() testlogger.go
620 }
621
635 // Close disallows any further logging, preventing the test framework from complaining about
636 // logging post-test.
637 > func (tl *TestLogger) Close() { testlogger.go
638 > // Taking the write lock ensures all in-progress log calls complete before we close.
639 > // This prevents a race condition after the test has completed.
640 > tl.state.mu.Lock()
641 > tl.state.mu.closed = true
642 > tl.state.mu.Unlock()
643 > }
644
645 func (tl *TestLogger) T() TestingT {
659
660 // Format the log.Logger tags and such into a useful message
661 > func failureMessage(level Level, msg string, tags []tag.Tag) string { testlogger.go
662 > var b strings.Builder
663 > b.WriteString("FAIL: ")
664 > b.WriteString(errorMessage(level, msg))
665 > for _, t := range tags {
666 > b.WriteString(t.Key()) testlogger.go
667 > b.WriteString("=")
668 > b.WriteString(formatValue(t))
669 > b.WriteString(" ")
670 > }
671 > return b.String() testlogger.go
672 }
673
674 > func errorMessage(level Level, msg string) string { testlogger.go
675 > var b strings.Builder
676 > b.WriteString("Unexpected ")
677 > b.WriteString(level.String())
678 > b.WriteString(" log encountered: ")
679 > b.WriteString(msg)
680 > return b.String()
681 > }
682
683 func message(level Level, msg string, tags []tag.Tag) string {
696 }
697
698 > func formatValue(t tag.Tag) string { testlogger.go
699 > switch v := t.Value().(type) {
700 case fmt.Stringer:
701 return v.String()
702 case string:
703 return v
704 > default: testlogger.go
705 > return fmt.Sprintf("%v", v)
706 }
707 }
go.temporal.io/server/common/log/zap_logger.go 38 covered LOC · 10 ranges

Open complete file

82
83 // NewZapLogger returns a new zap based logger from zap.Logger
84 > func NewZapLogger(zl *zap.Logger) *zapLogger { zap_logger.go
85 > return &zapLogger{
86 > zl: zl,
87 > skip: skipForZapLogger,
88 > baseZl: zl,
89 > }
90 > }
91
92 // BuildZapLogger builds and returns a new zap.Logger for this logging configuration
95 }
96
97 > func caller(skip int) string { zap_logger.go
98 > _, path, line, ok := runtime.Caller(skip)
99 > if !ok {
100 return ""
101 }
102 > return path + ":" + strconv.Itoa(line) zap_logger.go
103 }
104
105 > func (l *zapLogger) buildFieldsWithCallAt(tags []tag.Tag) []zap.Field { zap_logger.go
106 > fields := make([]zap.Field, len(tags)+1)
107 > l.fillFields(tags, fields)
108 > fields[len(fields)-1] = zap.String(tag.LoggingCallAtKey, caller(l.skip))
109 > return fields
110 > }
111
112 // fillFields fill fields parameter with fields read from tags. Optimized for performance.
113 > func (l *zapLogger) fillFields(tags []tag.Tag, fields []zap.Field) { zap_logger.go
114 > for i, t := range tags {
115 > if zt, ok := t.(tag.ZapTag); ok { zap_logger.go
116 > fields[i] = zt.Field()
117 > } else {
118 fields[i] = zap.Any(t.Key(), t.Value())
119 }
121 }
122
123 > func setDefaultMsg(msg string) string { zap_logger.go
124 > if msg == "" {
125 return defaultMsgForEmpty
126 }
127 > return msg zap_logger.go
128 }
129
152 }
153
154 > func (l *zapLogger) Error(msg string, tags ...tag.Tag) { zap_logger.go
155 > if l.zl.Core().Enabled(zap.ErrorLevel) {
156 > msg = setDefaultMsg(msg)
157 > fields := l.buildFieldsWithCallAt(tags)
158 > l.zl.Error(msg, fields...)
159 > }
160 }
161
211 }
212
213 > func (l *zapLogger) Skip(extraSkip int) Logger { zap_logger.go
214 > return &zapLogger{
215 > zl: l.zl,
216 > skip: l.skip + extraSkip,
217 > baseZl: l.baseZl,
218 > }
219 > }
220
221 func mergeTags(oldTags, newTags []tag.Tag) (outTags []tag.Tag) {
go.temporal.io/server/common/log/tag/tags.go 27 covered LOC · 9 ranges

Open complete file

70
71 // WorkflowAction returns tag for WorkflowAction
72 > func workflowAction(action string) ZapTag { tags.go
73 > return NewStringTag("wf-action", action)
74 > }
75
76 // WorkflowListFilterType returns tag for WorkflowListFilterType
77 > func workflowListFilterType(listFilterType string) ZapTag { tags.go
78 > return NewStringTag("wf-list-filter-type", listFilterType)
79 > }
80
81 // general
376
377 // Component returns tag for Component
378 > func component(component string) ZapTag { tags.go
379 > return NewStringTag("component", component)
380 > }
381
382 // Lifecycle returns tag for Lifecycle
383 > func lifecycle(lifecycle string) ZapTag { tags.go
384 > return NewStringTag("lifecycle", lifecycle)
385 > }
386
387 // StoreOperation returns tag for StoreOperation
388 > func storeOperation(storeOperation string) ZapTag { tags.go
389 > return NewStringTag("store-operation", storeOperation)
390 > }
391
392 // OperationResult returns tag for OperationResult
393 > func operationResult(operationResult string) ZapTag { tags.go
394 > return NewStringTag("operation-result", operationResult)
395 > }
396
397 // ErrorType returns tag for ErrorType
401
402 // errorType returns tag for ErrorType given a string
403 > func errorType(errorType string) ZapTag { tags.go
404 > return NewStringTag("error-type", errorType)
405 > }
406
407 // Shardupdate returns tag for Shardupdate
408 > func shardupdate(shardupdate string) ZapTag { tags.go
409 > return NewStringTag("shard-update", shardupdate)
410 > }
411
412 // scope returns a tag for scope
413 // Pre-defined scope tags are in values.go.
414 > func scope(scope string) ZapTag { tags.go
415 > return NewStringTag("scope", scope)
416 > }
417
418 // general
go.temporal.io/server/common/log/tag/zap_tag.go 23 covered LOC · 5 ranges

Open complete file

26 }
27
28 > func (t ZapTag) Field() zap.Field { zap_tag.go
29 > return t.field
30 > }
31
32 > func (t ZapTag) Key() string { zap_tag.go
33 > return t.field.Key
34 > }
35
36 > func (t ZapTag) Value() any { zap_tag.go
37 > // Not for production use.
38 > enc := zapcore.NewMapObjectEncoder()
39 > t.field.AddTo(enc)
40 > for _, val := range enc.Fields {
41 > return val
42 > }
43 return nil
44 }
45
46 > func NewStringTag(key string, value string) ZapTag { zap_tag.go
47 > return ZapTag{
48 > field: zap.String(key, value),
49 > }
50 > }
51
52 func NewStringsTag(key string, value []string) ZapTag {
118 }
119
120 > func NewBoolTag(key string, value bool) ZapTag { zap_tag.go
121 > return ZapTag{
122 > field: zap.Bool(key, value),
123 > }
124 > }
125
126 func NewErrorTag(key string, value error) ZapTag {
go.temporal.io/server/api/enums/v1/cluster.pb.go 20 covered LOC · 2 ranges

Open complete file

209 }
210
211 > func init() { file_temporal_server_api_enums_v1_cluster_proto_init() } cluster.pb.go
212 > func file_temporal_server_api_enums_v1_cluster_proto_init() {
213 > if File_temporal_server_api_enums_v1_cluster_proto != nil {
214 return
215 }
216 > type x struct{} cluster.pb.go
217 > out := protoimpl.TypeBuilder{
218 > File: protoimpl.DescBuilder{
219 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
220 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_cluster_proto_rawDesc), len(file_temporal_server_api_enums_v1_cluster_proto_rawDesc)),
221 > NumEnums: 2,
222 > NumMessages: 0,
223 > NumExtensions: 0,
224 > NumServices: 0,
225 > },
226 > GoTypes: file_temporal_server_api_enums_v1_cluster_proto_goTypes,
227 > DependencyIndexes: file_temporal_server_api_enums_v1_cluster_proto_depIdxs,
228 > EnumInfos: file_temporal_server_api_enums_v1_cluster_proto_enumTypes,
229 > }.Build()
230 > File_temporal_server_api_enums_v1_cluster_proto = out.File
231 > file_temporal_server_api_enums_v1_cluster_proto_goTypes = nil
232 > file_temporal_server_api_enums_v1_cluster_proto_depIdxs = nil
233 }
go.temporal.io/server/api/enums/v1/common.pb.go 20 covered LOC · 2 ranges

Open complete file

264 }
265
266 > func init() { file_temporal_server_api_enums_v1_common_proto_init() } common.pb.go
267 > func file_temporal_server_api_enums_v1_common_proto_init() {
268 > if File_temporal_server_api_enums_v1_common_proto != nil {
269 return
270 }
271 > type x struct{} common.pb.go
272 > out := protoimpl.TypeBuilder{
273 > File: protoimpl.DescBuilder{
274 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
275 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_common_proto_rawDesc), len(file_temporal_server_api_enums_v1_common_proto_rawDesc)),
276 > NumEnums: 3,
277 > NumMessages: 0,
278 > NumExtensions: 0,
279 > NumServices: 0,
280 > },
281 > GoTypes: file_temporal_server_api_enums_v1_common_proto_goTypes,
282 > DependencyIndexes: file_temporal_server_api_enums_v1_common_proto_depIdxs,
283 > EnumInfos: file_temporal_server_api_enums_v1_common_proto_enumTypes,
284 > }.Build()
285 > File_temporal_server_api_enums_v1_common_proto = out.File
286 > file_temporal_server_api_enums_v1_common_proto_goTypes = nil
287 > file_temporal_server_api_enums_v1_common_proto_depIdxs = nil
288 }
go.temporal.io/server/api/enums/v1/dlq.pb.go 20 covered LOC · 2 ranges

Open complete file

187 }
188
189 > func init() { file_temporal_server_api_enums_v1_dlq_proto_init() } dlq.pb.go
190 > func file_temporal_server_api_enums_v1_dlq_proto_init() {
191 > if File_temporal_server_api_enums_v1_dlq_proto != nil {
192 return
193 }
194 > type x struct{} dlq.pb.go
195 > out := protoimpl.TypeBuilder{
196 > File: protoimpl.DescBuilder{
197 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
198 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_dlq_proto_rawDesc), len(file_temporal_server_api_enums_v1_dlq_proto_rawDesc)),
199 > NumEnums: 2,
200 > NumMessages: 0,
201 > NumExtensions: 0,
202 > NumServices: 0,
203 > },
204 > GoTypes: file_temporal_server_api_enums_v1_dlq_proto_goTypes,
205 > DependencyIndexes: file_temporal_server_api_enums_v1_dlq_proto_depIdxs,
206 > EnumInfos: file_temporal_server_api_enums_v1_dlq_proto_enumTypes,
207 > }.Build()
208 > File_temporal_server_api_enums_v1_dlq_proto = out.File
209 > file_temporal_server_api_enums_v1_dlq_proto_goTypes = nil
210 > file_temporal_server_api_enums_v1_dlq_proto_depIdxs = nil
211 }
go.temporal.io/server/api/enums/v1/fairness_state.pb.go 20 covered LOC · 2 ranges

Open complete file

123 }
124
125 > func init() { file_temporal_server_api_enums_v1_fairness_state_proto_init() } fairness_state.pb.go
126 > func file_temporal_server_api_enums_v1_fairness_state_proto_init() {
127 > if File_temporal_server_api_enums_v1_fairness_state_proto != nil {
128 return
129 }
130 > type x struct{} fairness_state.pb.go
131 > out := protoimpl.TypeBuilder{
132 > File: protoimpl.DescBuilder{
133 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
134 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_fairness_state_proto_rawDesc), len(file_temporal_server_api_enums_v1_fairness_state_proto_rawDesc)),
135 > NumEnums: 1,
136 > NumMessages: 0,
137 > NumExtensions: 0,
138 > NumServices: 0,
139 > },
140 > GoTypes: file_temporal_server_api_enums_v1_fairness_state_proto_goTypes,
141 > DependencyIndexes: file_temporal_server_api_enums_v1_fairness_state_proto_depIdxs,
142 > EnumInfos: file_temporal_server_api_enums_v1_fairness_state_proto_enumTypes,
143 > }.Build()
144 > File_temporal_server_api_enums_v1_fairness_state_proto = out.File
145 > file_temporal_server_api_enums_v1_fairness_state_proto_goTypes = nil
146 > file_temporal_server_api_enums_v1_fairness_state_proto_depIdxs = nil
147 }
go.temporal.io/server/api/enums/v1/nexus.pb.go 20 covered LOC · 2 ranges

Open complete file

158 }
159
160 > func init() { file_temporal_server_api_enums_v1_nexus_proto_init() } nexus.pb.go
161 > func file_temporal_server_api_enums_v1_nexus_proto_init() {
162 > if File_temporal_server_api_enums_v1_nexus_proto != nil {
163 return
164 }
165 > type x struct{} nexus.pb.go
166 > out := protoimpl.TypeBuilder{
167 > File: protoimpl.DescBuilder{
168 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
169 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_nexus_proto_rawDesc), len(file_temporal_server_api_enums_v1_nexus_proto_rawDesc)),
170 > NumEnums: 1,
171 > NumMessages: 0,
172 > NumExtensions: 0,
173 > NumServices: 0,
174 > },
175 > GoTypes: file_temporal_server_api_enums_v1_nexus_proto_goTypes,
176 > DependencyIndexes: file_temporal_server_api_enums_v1_nexus_proto_depIdxs,
177 > EnumInfos: file_temporal_server_api_enums_v1_nexus_proto_enumTypes,
178 > }.Build()
179 > File_temporal_server_api_enums_v1_nexus_proto = out.File
180 > file_temporal_server_api_enums_v1_nexus_proto_goTypes = nil
181 > file_temporal_server_api_enums_v1_nexus_proto_depIdxs = nil
182 }
go.temporal.io/server/api/enums/v1/predicate.pb.go 20 covered LOC · 2 ranges

Open complete file

170 }
171
172 > func init() { file_temporal_server_api_enums_v1_predicate_proto_init() } predicate.pb.go
173 > func file_temporal_server_api_enums_v1_predicate_proto_init() {
174 > if File_temporal_server_api_enums_v1_predicate_proto != nil {
175 return
176 }
177 > type x struct{} predicate.pb.go
178 > out := protoimpl.TypeBuilder{
179 > File: protoimpl.DescBuilder{
180 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
181 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_predicate_proto_rawDesc), len(file_temporal_server_api_enums_v1_predicate_proto_rawDesc)),
182 > NumEnums: 1,
183 > NumMessages: 0,
184 > NumExtensions: 0,
185 > NumServices: 0,
186 > },
187 > GoTypes: file_temporal_server_api_enums_v1_predicate_proto_goTypes,
188 > DependencyIndexes: file_temporal_server_api_enums_v1_predicate_proto_depIdxs,
189 > EnumInfos: file_temporal_server_api_enums_v1_predicate_proto_enumTypes,
190 > }.Build()
191 > File_temporal_server_api_enums_v1_predicate_proto = out.File
192 > file_temporal_server_api_enums_v1_predicate_proto_goTypes = nil
193 > file_temporal_server_api_enums_v1_predicate_proto_depIdxs = nil
194 }
go.temporal.io/server/api/enums/v1/replication.pb.go 20 covered LOC · 2 ranges

Open complete file

314 }
315
316 > func init() { file_temporal_server_api_enums_v1_replication_proto_init() } replication.pb.go
317 > func file_temporal_server_api_enums_v1_replication_proto_init() {
318 > if File_temporal_server_api_enums_v1_replication_proto != nil {
319 return
320 }
321 > type x struct{} replication.pb.go
322 > out := protoimpl.TypeBuilder{
323 > File: protoimpl.DescBuilder{
324 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
325 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_replication_proto_rawDesc), len(file_temporal_server_api_enums_v1_replication_proto_rawDesc)),
326 > NumEnums: 3,
327 > NumMessages: 0,
328 > NumExtensions: 0,
329 > NumServices: 0,
330 > },
331 > GoTypes: file_temporal_server_api_enums_v1_replication_proto_goTypes,
332 > DependencyIndexes: file_temporal_server_api_enums_v1_replication_proto_depIdxs,
333 > EnumInfos: file_temporal_server_api_enums_v1_replication_proto_enumTypes,
334 > }.Build()
335 > File_temporal_server_api_enums_v1_replication_proto = out.File
336 > file_temporal_server_api_enums_v1_replication_proto_goTypes = nil
337 > file_temporal_server_api_enums_v1_replication_proto_depIdxs = nil
338 }
go.temporal.io/server/api/enums/v1/task.pb.go 20 covered LOC · 2 ranges

Open complete file

456 }
457
458 > func init() { file_temporal_server_api_enums_v1_task_proto_init() } task.pb.go
459 > func file_temporal_server_api_enums_v1_task_proto_init() {
460 > if File_temporal_server_api_enums_v1_task_proto != nil {
461 return
462 }
463 > type x struct{} task.pb.go
464 > out := protoimpl.TypeBuilder{
465 > File: protoimpl.DescBuilder{
466 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
467 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_task_proto_rawDesc), len(file_temporal_server_api_enums_v1_task_proto_rawDesc)),
468 > NumEnums: 3,
469 > NumMessages: 0,
470 > NumExtensions: 0,
471 > NumServices: 0,
472 > },
473 > GoTypes: file_temporal_server_api_enums_v1_task_proto_goTypes,
474 > DependencyIndexes: file_temporal_server_api_enums_v1_task_proto_depIdxs,
475 > EnumInfos: file_temporal_server_api_enums_v1_task_proto_enumTypes,
476 > }.Build()
477 > File_temporal_server_api_enums_v1_task_proto = out.File
478 > file_temporal_server_api_enums_v1_task_proto_goTypes = nil
479 > file_temporal_server_api_enums_v1_task_proto_depIdxs = nil
480 }
go.temporal.io/server/api/enums/v1/workflow.pb.go 20 covered LOC · 2 ranges

Open complete file

275 }
276
277 > func init() { file_temporal_server_api_enums_v1_workflow_proto_init() } workflow.pb.go
278 > func file_temporal_server_api_enums_v1_workflow_proto_init() {
279 > if File_temporal_server_api_enums_v1_workflow_proto != nil {
280 return
281 }
282 > type x struct{} workflow.pb.go
283 > out := protoimpl.TypeBuilder{
284 > File: protoimpl.DescBuilder{
285 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
286 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_proto_rawDesc)),
287 > NumEnums: 3,
288 > NumMessages: 0,
289 > NumExtensions: 0,
290 > NumServices: 0,
291 > },
292 > GoTypes: file_temporal_server_api_enums_v1_workflow_proto_goTypes,
293 > DependencyIndexes: file_temporal_server_api_enums_v1_workflow_proto_depIdxs,
294 > EnumInfos: file_temporal_server_api_enums_v1_workflow_proto_enumTypes,
295 > }.Build()
296 > File_temporal_server_api_enums_v1_workflow_proto = out.File
297 > file_temporal_server_api_enums_v1_workflow_proto_goTypes = nil
298 > file_temporal_server_api_enums_v1_workflow_proto_depIdxs = nil
299 }
go.temporal.io/server/api/enums/v1/workflow_task_type.pb.go 20 covered LOC · 2 ranges

Open complete file

124 }
125
126 > func init() { file_temporal_server_api_enums_v1_workflow_task_type_proto_init() } workflow_task_type.pb.go
127 > func file_temporal_server_api_enums_v1_workflow_task_type_proto_init() {
128 > if File_temporal_server_api_enums_v1_workflow_task_type_proto != nil {
129 return
130 }
131 > type x struct{} workflow_task_type.pb.go
132 > out := protoimpl.TypeBuilder{
133 > File: protoimpl.DescBuilder{
134 > GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
135 > RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc), len(file_temporal_server_api_enums_v1_workflow_task_type_proto_rawDesc)),
136 > NumEnums: 1,
137 > NumMessages: 0,
138 > NumExtensions: 0,
139 > NumServices: 0,
140 > },
141 > GoTypes: file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes,
142 > DependencyIndexes: file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs,
143 > EnumInfos: file_temporal_server_api_enums_v1_workflow_task_type_proto_enumTypes,
144 > }.Build()
145 > File_temporal_server_api_enums_v1_workflow_task_type_proto = out.File
146 > file_temporal_server_api_enums_v1_workflow_task_type_proto_goTypes = nil
147 > file_temporal_server_api_enums_v1_workflow_task_type_proto_depIdxs = nil
148 }
go.temporal.io/server/common/testing/testlogger/testlogger.gen.go 3 covered LOC · 2 ranges

Open complete file

22 var _Level_index = [...]uint8{0, 5, 9, 13, 18, 23, 29, 34}
23
24 > func (i Level) String() string { testlogger.gen.go
25 > if i < 0 || i >= Level(len(_Level_index)-1) {
26 return "Level(" + strconv.FormatInt(int64(i), 10) + ")"
27 }
28 > return _Level_name[_Level_index[i]:_Level_index[i+1]] testlogger.gen.go
29 }