From 9a4f274f0d4229a8237903aa685d11a1d31441ec Mon Sep 17 00:00:00 2001 From: James DeFelice Date: Mon, 12 Jun 2017 13:12:35 +0000 Subject: [PATCH] rules: unit tests for ErrorList.Error() --- .../executor/callrules/callrules_generated.go | 15 +++++--- .../callrules/callrules_generated_test.go | 20 +++++++++++ .../eventrules/eventrules_generated.go | 15 +++++--- .../eventrules/eventrules_generated_test.go | 20 +++++++++++ api/v1/lib/extras/gen/rules.go | 35 ++++++++++++++++--- .../callrules/callrules_generated.go | 15 +++++--- .../callrules/callrules_generated_test.go | 20 +++++++++++ .../eventrules/eventrules_generated.go | 15 +++++--- .../eventrules/eventrules_generated_test.go | 20 +++++++++++ 9 files changed, 150 insertions(+), 25 deletions(-) diff --git a/api/v1/lib/extras/executor/callrules/callrules_generated.go b/api/v1/lib/extras/executor/callrules/callrules_generated.go index 5b419dc4..aa4b0ed3 100644 --- a/api/v1/lib/extras/executor/callrules/callrules_generated.go +++ b/api/v1/lib/extras/executor/callrules/callrules_generated.go @@ -78,11 +78,15 @@ func (rs Rules) Chain() Chain { // It is the semantic equivalent of Rules{r1, r2, ..., rn}.Rule() and exists purely for convenience. func Concat(rs ...Rule) Rule { return Rules(rs).Eval } +const ( + MsgNoErrors = "no errors" +) + // Error implements error; returns the message of the first error in the list. func (es ErrorList) Error() string { switch len(es) { case 0: - return "no errors" + return MsgNoErrors case 1: return es[0].Error() default: @@ -113,13 +117,14 @@ func Error2(a, b error) error { // Err reduces an empty or singleton error list func (es ErrorList) Err() error { - if len(es) == 0 { + switch len(es) { + case 0: return nil - } - if len(es) == 1 { + case 1: return es[0] + default: + return es } - return es } // IsErrorList returns true if err is a non-nil error list diff --git a/api/v1/lib/extras/executor/callrules/callrules_generated_test.go b/api/v1/lib/extras/executor/callrules/callrules_generated_test.go index 5092caf8..39ef4e4b 100644 --- a/api/v1/lib/extras/executor/callrules/callrules_generated_test.go +++ b/api/v1/lib/extras/executor/callrules/callrules_generated_test.go @@ -129,6 +129,26 @@ func TestRules(t *testing.T) { } } +func TestError(t *testing.T) { + a := errors.New("a") + list := ErrorList{a} + + msg := list.Error() + if msg != a.Error() { + t.Errorf("expected %q instead of %q", a.Error(), msg) + } + + msg = ErrorList{}.Error() + if msg != MsgNoErrors { + t.Errorf("expected %q instead of %q", MsgNoErrors, msg) + } + + msg = ErrorList(nil).Error() + if msg != MsgNoErrors { + t.Errorf("expected %q instead of %q", MsgNoErrors, msg) + } +} + func TestError2(t *testing.T) { var ( a = errors.New("a") diff --git a/api/v1/lib/extras/executor/eventrules/eventrules_generated.go b/api/v1/lib/extras/executor/eventrules/eventrules_generated.go index 0c3f34ff..327d85fe 100644 --- a/api/v1/lib/extras/executor/eventrules/eventrules_generated.go +++ b/api/v1/lib/extras/executor/eventrules/eventrules_generated.go @@ -77,11 +77,15 @@ func (rs Rules) Chain() Chain { // It is the semantic equivalent of Rules{r1, r2, ..., rn}.Rule() and exists purely for convenience. func Concat(rs ...Rule) Rule { return Rules(rs).Eval } +const ( + MsgNoErrors = "no errors" +) + // Error implements error; returns the message of the first error in the list. func (es ErrorList) Error() string { switch len(es) { case 0: - return "no errors" + return MsgNoErrors case 1: return es[0].Error() default: @@ -112,13 +116,14 @@ func Error2(a, b error) error { // Err reduces an empty or singleton error list func (es ErrorList) Err() error { - if len(es) == 0 { + switch len(es) { + case 0: return nil - } - if len(es) == 1 { + case 1: return es[0] + default: + return es } - return es } // IsErrorList returns true if err is a non-nil error list diff --git a/api/v1/lib/extras/executor/eventrules/eventrules_generated_test.go b/api/v1/lib/extras/executor/eventrules/eventrules_generated_test.go index 6b559aaa..3d874d9b 100644 --- a/api/v1/lib/extras/executor/eventrules/eventrules_generated_test.go +++ b/api/v1/lib/extras/executor/eventrules/eventrules_generated_test.go @@ -112,6 +112,26 @@ func TestRules(t *testing.T) { } } +func TestError(t *testing.T) { + a := errors.New("a") + list := ErrorList{a} + + msg := list.Error() + if msg != a.Error() { + t.Errorf("expected %q instead of %q", a.Error(), msg) + } + + msg = ErrorList{}.Error() + if msg != MsgNoErrors { + t.Errorf("expected %q instead of %q", MsgNoErrors, msg) + } + + msg = ErrorList(nil).Error() + if msg != MsgNoErrors { + t.Errorf("expected %q instead of %q", MsgNoErrors, msg) + } +} + func TestError2(t *testing.T) { var ( a = errors.New("a") diff --git a/api/v1/lib/extras/gen/rules.go b/api/v1/lib/extras/gen/rules.go index 3d2f12a4..942f62a8 100644 --- a/api/v1/lib/extras/gen/rules.go +++ b/api/v1/lib/extras/gen/rules.go @@ -94,11 +94,15 @@ func (rs Rules) Chain() Chain { // It is the semantic equivalent of Rules{r1, r2, ..., rn}.Rule() and exists purely for convenience. func Concat(rs ...Rule) Rule { return Rules(rs).Eval } +const ( + MsgNoErrors = "no errors" +) + // Error implements error; returns the message of the first error in the list. func (es ErrorList) Error() string { switch len(es) { case 0: - return "no errors" + return MsgNoErrors case 1: return es[0].Error() default: @@ -129,13 +133,14 @@ func Error2(a, b error) error { // Err reduces an empty or singleton error list func (es ErrorList) Err() error { - if len(es) == 0 { + switch len(es) { + case 0: return nil - } - if len(es) == 1 { + case 1: return es[0] + default: + return es } - return es } // IsErrorList returns true if err is a non-nil error list @@ -551,6 +556,26 @@ func TestRules(t *testing.T) { } } +func TestError(t *testing.T) { + a := errors.New("a") + list := ErrorList{a} + + msg := list.Error() + if msg != a.Error() { + t.Errorf("expected %q instead of %q", a.Error(), msg) + } + + msg = ErrorList{}.Error() + if msg != MsgNoErrors { + t.Errorf("expected %q instead of %q", MsgNoErrors, msg) + } + + msg = ErrorList(nil).Error() + if msg != MsgNoErrors { + t.Errorf("expected %q instead of %q", MsgNoErrors, msg) + } +} + func TestError2(t *testing.T) { var ( a = errors.New("a") diff --git a/api/v1/lib/extras/scheduler/callrules/callrules_generated.go b/api/v1/lib/extras/scheduler/callrules/callrules_generated.go index 5a2cdc02..b50d5070 100644 --- a/api/v1/lib/extras/scheduler/callrules/callrules_generated.go +++ b/api/v1/lib/extras/scheduler/callrules/callrules_generated.go @@ -78,11 +78,15 @@ func (rs Rules) Chain() Chain { // It is the semantic equivalent of Rules{r1, r2, ..., rn}.Rule() and exists purely for convenience. func Concat(rs ...Rule) Rule { return Rules(rs).Eval } +const ( + MsgNoErrors = "no errors" +) + // Error implements error; returns the message of the first error in the list. func (es ErrorList) Error() string { switch len(es) { case 0: - return "no errors" + return MsgNoErrors case 1: return es[0].Error() default: @@ -113,13 +117,14 @@ func Error2(a, b error) error { // Err reduces an empty or singleton error list func (es ErrorList) Err() error { - if len(es) == 0 { + switch len(es) { + case 0: return nil - } - if len(es) == 1 { + case 1: return es[0] + default: + return es } - return es } // IsErrorList returns true if err is a non-nil error list diff --git a/api/v1/lib/extras/scheduler/callrules/callrules_generated_test.go b/api/v1/lib/extras/scheduler/callrules/callrules_generated_test.go index 84608ba5..2bcf3450 100644 --- a/api/v1/lib/extras/scheduler/callrules/callrules_generated_test.go +++ b/api/v1/lib/extras/scheduler/callrules/callrules_generated_test.go @@ -129,6 +129,26 @@ func TestRules(t *testing.T) { } } +func TestError(t *testing.T) { + a := errors.New("a") + list := ErrorList{a} + + msg := list.Error() + if msg != a.Error() { + t.Errorf("expected %q instead of %q", a.Error(), msg) + } + + msg = ErrorList{}.Error() + if msg != MsgNoErrors { + t.Errorf("expected %q instead of %q", MsgNoErrors, msg) + } + + msg = ErrorList(nil).Error() + if msg != MsgNoErrors { + t.Errorf("expected %q instead of %q", MsgNoErrors, msg) + } +} + func TestError2(t *testing.T) { var ( a = errors.New("a") diff --git a/api/v1/lib/extras/scheduler/eventrules/eventrules_generated.go b/api/v1/lib/extras/scheduler/eventrules/eventrules_generated.go index 606bb54d..08f8c794 100644 --- a/api/v1/lib/extras/scheduler/eventrules/eventrules_generated.go +++ b/api/v1/lib/extras/scheduler/eventrules/eventrules_generated.go @@ -77,11 +77,15 @@ func (rs Rules) Chain() Chain { // It is the semantic equivalent of Rules{r1, r2, ..., rn}.Rule() and exists purely for convenience. func Concat(rs ...Rule) Rule { return Rules(rs).Eval } +const ( + MsgNoErrors = "no errors" +) + // Error implements error; returns the message of the first error in the list. func (es ErrorList) Error() string { switch len(es) { case 0: - return "no errors" + return MsgNoErrors case 1: return es[0].Error() default: @@ -112,13 +116,14 @@ func Error2(a, b error) error { // Err reduces an empty or singleton error list func (es ErrorList) Err() error { - if len(es) == 0 { + switch len(es) { + case 0: return nil - } - if len(es) == 1 { + case 1: return es[0] + default: + return es } - return es } // IsErrorList returns true if err is a non-nil error list diff --git a/api/v1/lib/extras/scheduler/eventrules/eventrules_generated_test.go b/api/v1/lib/extras/scheduler/eventrules/eventrules_generated_test.go index 826a9a6a..8b17f3ff 100644 --- a/api/v1/lib/extras/scheduler/eventrules/eventrules_generated_test.go +++ b/api/v1/lib/extras/scheduler/eventrules/eventrules_generated_test.go @@ -112,6 +112,26 @@ func TestRules(t *testing.T) { } } +func TestError(t *testing.T) { + a := errors.New("a") + list := ErrorList{a} + + msg := list.Error() + if msg != a.Error() { + t.Errorf("expected %q instead of %q", a.Error(), msg) + } + + msg = ErrorList{}.Error() + if msg != MsgNoErrors { + t.Errorf("expected %q instead of %q", MsgNoErrors, msg) + } + + msg = ErrorList(nil).Error() + if msg != MsgNoErrors { + t.Errorf("expected %q instead of %q", MsgNoErrors, msg) + } +} + func TestError2(t *testing.T) { var ( a = errors.New("a")