10146410757

Committed 29 Jul 2024 02:37PM UTC coverage: 88.478% (-4.2%) from 92.711%

Build # 10146410757

Build Type

Pull #108

github

Committed by

web-flow

Commit Message

Merge 9ad9b6cb1 into b2f0ab5cc

Pull Request Pull Request #108: add introspection interfaces for some fsm errors

Run Details

0 of 21 new or added lines in 1 file covered. (0.0%)

407 of 460 relevant lines covered (88.48%)

13.17 hits per line

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

58.82

/errors.go

// Copyright (c) 2013 - Max Persson <max@looplab.se>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package fsm

import (
        "context"
        "errors"
)

// InvalidEventError is returned by FSM.Event() when the event cannot be called
// in the current state.
type InvalidEventError struct {
        Event string
        State string
}

func (e InvalidEventError) Error() string {
        return "event " + e.Event + " inappropriate in current state " + e.State
}

// UnknownEventError is returned by FSM.Event() when the event is not defined.
type UnknownEventError struct {
        Event string
}

func (e UnknownEventError) Error() string {
        return "event " + e.Event + " does not exist"
}

// InTransitionError is returned by FSM.Event() when an asynchronous transition
// is already in progress.
type InTransitionError struct {
        Event string
}

func (e InTransitionError) Error() string {
        return "event " + e.Event + " inappropriate because previous transition did not complete"
}

// NotInTransitionError is returned by FSM.Transition() when an asynchronous
// transition is not in progress.
type NotInTransitionError struct{}

func (e NotInTransitionError) Error() string {
        return "transition inappropriate because no state change in progress"
}

// NoTransitionError is returned by FSM.Event() when no transition have happened,
// for example if the source and destination states are the same.
type NoTransitionError struct {
        Err error
}

func (e NoTransitionError) Error() string {
        if e.Err != nil {
                return "no transition with error: " + e.Err.Error()
        }
        return "no transition"
}

func (e NoTransitionError) Is(target error) bool {
        _, ok := target.(NoTransitionError)
        return ok || errors.Is(e.Err, target)
}

func (e NoTransitionError) Unwrap() error {
        return e.Err
}

// CanceledError is returned by FSM.Event() when a callback have canceled a
// transition.
type CanceledError struct {
        Err error
}

func (e CanceledError) Error() string {
        if e.Err != nil {
                return "transition canceled with error: " + e.Err.Error()
        }
        return "transition canceled"
}

func (e CanceledError) Is(target error) bool {
        _, ok := target.(CanceledError)
        return ok || errors.Is(e.Err, target)
}

func (e CanceledError) Unwrap() error {
        return e.Err
}

// AsyncError is returned by FSM.Event() when a callback have initiated an
// asynchronous state transition.
type AsyncError struct {
        Err error

        Ctx              context.Context
        CancelTransition func()
}

func (e AsyncError) Error() string {
        if e.Err != nil {
                return "async started with error: " + e.Err.Error()
        }
        return "async started"
}

func (e AsyncError) Is(target error) bool {
        _, ok := target.(AsyncError)
        return ok || errors.Is(e.Err, target)
}

func (e AsyncError) Unwrap() error {
        return e.Err
}

// InternalError is returned by FSM.Event() and should never occur. It is a
// probably because of a bug.
type InternalError struct{}

func (e InternalError) Error() string {
        return "internal error on state transition"
}

1	// Copyright (c) 2013 - Max Persson <max@looplab.se>
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	package fsm
16
17	import (
18	"context"
19	"errors"
20	)
21
22	// InvalidEventError is returned by FSM.Event() when the event cannot be called
23	// in the current state.
24	type InvalidEventError struct {
25	Event string
26	State string
27	}
28
29	func (e InvalidEventError) Error() string {	2✔
30	return "event " + e.Event + " inappropriate in current state " + e.State	2✔
31	}	2✔
32
33	// UnknownEventError is returned by FSM.Event() when the event is not defined.
34	type UnknownEventError struct {
35	Event string
36	}
37
38	func (e UnknownEventError) Error() string {	1✔
39	return "event " + e.Event + " does not exist"	1✔
40	}	1✔
41
42	// InTransitionError is returned by FSM.Event() when an asynchronous transition
43	// is already in progress.
44	type InTransitionError struct {
45	Event string
46	}
47
48	func (e InTransitionError) Error() string {	1✔
49	return "event " + e.Event + " inappropriate because previous transition did not complete"	1✔
50	}	1✔
51
52	// NotInTransitionError is returned by FSM.Transition() when an asynchronous
53	// transition is not in progress.
54	type NotInTransitionError struct{}
55
56	func (e NotInTransitionError) Error() string {	1✔
57	return "transition inappropriate because no state change in progress"	1✔
58	}	1✔
59
60	// NoTransitionError is returned by FSM.Event() when no transition have happened,
61	// for example if the source and destination states are the same.
62	type NoTransitionError struct {
63	Err error
64	}
65
66	func (e NoTransitionError) Error() string {	2✔
67	if e.Err != nil {	3✔
68	return "no transition with error: " + e.Err.Error()	1✔
69	}	1✔
70	return "no transition"	1✔
71	}
72
NEW 73	func (e NoTransitionError) Is(target error) bool {	×
NEW 74	_, ok := target.(NoTransitionError)	×
NEW 75	return ok \|\| errors.Is(e.Err, target)	×
NEW 76	}	×
77
NEW 78	func (e NoTransitionError) Unwrap() error {	×
NEW 79	return e.Err	×
NEW 80	}	×
81
82	// CanceledError is returned by FSM.Event() when a callback have canceled a
83	// transition.
84	type CanceledError struct {
85	Err error
86	}
87
88	func (e CanceledError) Error() string {	2✔
89	if e.Err != nil {	3✔
90	return "transition canceled with error: " + e.Err.Error()	1✔
91	}	1✔
92	return "transition canceled"	1✔
93	}
94
NEW 95	func (e CanceledError) Is(target error) bool {	×
NEW 96	_, ok := target.(CanceledError)	×
NEW 97	return ok \|\| errors.Is(e.Err, target)	×
NEW 98	}	×
99
NEW 100	func (e CanceledError) Unwrap() error {	×
NEW 101	return e.Err	×
NEW 102	}	×
103
104	// AsyncError is returned by FSM.Event() when a callback have initiated an
105	// asynchronous state transition.
106	type AsyncError struct {
107	Err error
108
109	Ctx context.Context
110	CancelTransition func()
111	}
112
113	func (e AsyncError) Error() string {	2✔
114	if e.Err != nil {	3✔
115	return "async started with error: " + e.Err.Error()	1✔
116	}	1✔
117	return "async started"	1✔
118	}
119
NEW 120	func (e AsyncError) Is(target error) bool {	×
NEW 121	_, ok := target.(AsyncError)	×
NEW 122	return ok \|\| errors.Is(e.Err, target)	×
NEW 123	}	×
124
NEW 125	func (e AsyncError) Unwrap() error {	×
NEW 126	return e.Err	×
NEW 127	}	×
128
129	// InternalError is returned by FSM.Event() and should never occur. It is a
130	// probably because of a bug.
131	type InternalError struct{}
132
133	func (e InternalError) Error() string {	1✔
134	return "internal error on state transition"	1✔
135	}	1✔

looplab / fsm / 10146410757

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