12622512440

Committed 05 Jan 2025 07:58PM UTC coverage: 27.495% (-39.9%) from 67.361%

Build # 12622512440

Build Type

Pull #419

github

Committed by

web-flow

Commit Message

Merge b3c17d928 into ac3a97277

Pull Request Pull Request #419: fix(ci): update to up/download-artifact v4

Run Details

1769 of 6434 relevant lines covered (27.49%)

1.41 hits per line

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

0.0

/command_check.go

// Copyright (c) 2014 - The Event Horizon authors.
//
// 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 eventhorizon

import (
        "errors"
        "reflect"
        "time"

        "github.com/looplab/eventhorizon/uuid"
)

var (
        // ErrMissingCommand is when there is no command to be handled.
        ErrMissingCommand = errors.New("missing command")
        // ErrMissingAggregateID is when a command is missing an aggregate ID.
        ErrMissingAggregateID = errors.New("missing aggregate ID")
)

// IsZeroer is used to check if a type is zero-valued, and in that case
// is not allowed to be used in a command. See CheckCommand.
type IsZeroer interface {
        IsZero() bool
}

// CommandFieldError is returned by Dispatch when a field is incorrect.
type CommandFieldError struct {
        Field string
}

// Error implements the Error method of the error interface.
func (c *CommandFieldError) Error() string {
        return "missing field: " + c.Field
}

// CheckCommand checks a command for errors.
func CheckCommand(cmd Command) error {
        if cmd == nil {
                return ErrMissingCommand
        }

        if cmd.AggregateID() == uuid.Nil {
                return ErrMissingAggregateID
        }

        rv := reflect.Indirect(reflect.ValueOf(cmd))
        rt := rv.Type()

        for i := 0; i < rt.NumField(); i++ {
                field := rt.Field(i)
                if field.PkgPath != "" {
                        continue // Skip private field.
                }

                tag := field.Tag.Get("eh")
                if tag == "optional" {
                        continue // Optional field.
                }

                var zero bool
                switch foo := rv.Field(i).Interface().(type) {
                case IsZeroer:
                        zero = foo.IsZero()
                default:
                        zero = isZero(rv.Field(i))
                }

                if zero {
                        return &CommandFieldError{field.Name}
                }
        }

        return nil
}

func isZero(v reflect.Value) bool {
        switch v.Kind() {
        case reflect.Func, reflect.Chan, reflect.Ptr, reflect.UnsafePointer:
                // Types that are not allowed at all.
                // NOTE: Would be better with its own error for this.
                return true
        case reflect.Map, reflect.Slice:
                return v.IsNil()
        case reflect.Array:
                // Special case to check zero values of UUIDs.
                switch obj := v.Interface().(type) {
                case uuid.UUID:
                        return obj == uuid.Nil
                }

                for i := 0; i < v.Len(); i++ {
                        if !isZero(v.Index(i)) {
                                return false
                        }
                }

                return true
        case reflect.Interface, reflect.String:
                z := reflect.Zero(v.Type())

                return v.Interface() == z.Interface()
        case reflect.Struct:
                // Special case to get zero values by method.
                switch obj := v.Interface().(type) {
                case time.Time:
                        return obj.IsZero()
                }

                // Check public fields for zero values.
                z := true

                for i := 0; i < v.NumField(); i++ {
                        if v.Type().Field(i).PkgPath != "" {
                                continue // Skip private fields.
                        }

                        z = z && isZero(v.Field(i))
                }

                return z
        default:
                // Don't check for zero for value types:
                // Bool, Int, Int8, Int16, Int32, Int64, Uint, Uint8, Uint16, Uint32,
                // Uint64, Float32, Float64, Complex64, Complex128
                return false
        }
}

1	// Copyright (c) 2014 - The Event Horizon authors.
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 eventhorizon
16
17	import (
18	"errors"
19	"reflect"
20	"time"
21
22	"github.com/looplab/eventhorizon/uuid"
23	)
24
25	var (
26	// ErrMissingCommand is when there is no command to be handled.
27	ErrMissingCommand = errors.New("missing command")
28	// ErrMissingAggregateID is when a command is missing an aggregate ID.
29	ErrMissingAggregateID = errors.New("missing aggregate ID")
30	)
31
32	// IsZeroer is used to check if a type is zero-valued, and in that case
33	// is not allowed to be used in a command. See CheckCommand.
34	type IsZeroer interface {
35	IsZero() bool
36	}
37
38	// CommandFieldError is returned by Dispatch when a field is incorrect.
39	type CommandFieldError struct {
40	Field string
41	}
42
43	// Error implements the Error method of the error interface.
44	func (c *CommandFieldError) Error() string {	×
45	return "missing field: " + c.Field	×
46	}	×
47
48	// CheckCommand checks a command for errors.
49	func CheckCommand(cmd Command) error {	×
50	if cmd == nil {	×
51	return ErrMissingCommand	×
52	}	×
53
54	if cmd.AggregateID() == uuid.Nil {	×
55	return ErrMissingAggregateID	×
56	}	×
57
58	rv := reflect.Indirect(reflect.ValueOf(cmd))	×
59	rt := rv.Type()	×
60		×
61	for i := 0; i < rt.NumField(); i++ {	×
62	field := rt.Field(i)	×
63	if field.PkgPath != "" {	×
64	continue // Skip private field.	×
65	}
66
67	tag := field.Tag.Get("eh")	×
68	if tag == "optional" {	×
69	continue // Optional field.	×
70	}
71
72	var zero bool	×
73	switch foo := rv.Field(i).Interface().(type) {	×
74	case IsZeroer:	×
75	zero = foo.IsZero()	×
76	default:	×
77	zero = isZero(rv.Field(i))	×
78	}
79
80	if zero {	×
81	return &CommandFieldError{field.Name}	×
82	}	×
83	}
84
85	return nil	×
86	}
87
88	func isZero(v reflect.Value) bool {	×
89	switch v.Kind() {	×
90	case reflect.Func, reflect.Chan, reflect.Ptr, reflect.UnsafePointer:	×
91	// Types that are not allowed at all.	×
92	// NOTE: Would be better with its own error for this.	×
93	return true	×
94	case reflect.Map, reflect.Slice:	×
95	return v.IsNil()	×
96	case reflect.Array:	×
97	// Special case to check zero values of UUIDs.	×
98	switch obj := v.Interface().(type) {	×
99	case uuid.UUID:	×
100	return obj == uuid.Nil	×
101	}
102
103	for i := 0; i < v.Len(); i++ {	×
104	if !isZero(v.Index(i)) {	×
105	return false	×
106	}	×
107	}
108
109	return true	×
110	case reflect.Interface, reflect.String:	×
111	z := reflect.Zero(v.Type())	×
112		×
113	return v.Interface() == z.Interface()	×
114	case reflect.Struct:	×
115	// Special case to get zero values by method.	×
116	switch obj := v.Interface().(type) {	×
117	case time.Time:	×
118	return obj.IsZero()	×
119	}
120
121	// Check public fields for zero values.
122	z := true	×
123		×
124	for i := 0; i < v.NumField(); i++ {	×
125	if v.Type().Field(i).PkgPath != "" {	×
126	continue // Skip private fields.	×
127	}
128
129	z = z && isZero(v.Field(i))	×
130	}
131
132	return z	×
133	default:	×
134	// Don't check for zero for value types:	×
135	// Bool, Int, Int8, Int16, Int32, Int64, Uint, Uint8, Uint16, Uint32,	×
136	// Uint64, Float32, Float64, Complex64, Complex128	×
137	return false	×
138	}
139	}

looplab / eventhorizon / 12622512440

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