12827718001

Committed 17 Jan 2025 10:57AM UTC coverage: 56.909% (-0.3%) from 57.237%

Build # 12827718001

Build Type

Pull #384

github

Committed by

monstermunchkin

Commit Message

Satisfy linters

Pull Request Pull Request #384: Extend linting

Run Details

478 of 946 new or added lines in 109 files covered. (50.53%)

133 existing lines in 53 files now uncovered.

5667 of 9958 relevant lines covered (56.91%)

21.51 hits per line

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

86.59

/http/jsonapi/runtime/parameters.go

// Copyright © 2018 by PACE Telematics GmbH. All rights reserved.

package runtime

import (
        "fmt"
        "net/http"
        "reflect"
        "strings"
        "time"

        "github.com/shopspring/decimal"

        "github.com/pace/bricks/pkg/isotime"
)

// ScanIn help to avoid missuse using iota for the possible values.
type ScanIn int

const (
        // ScanInPath hints the scanner to scan the input.
        ScanInPath ScanIn = iota
        // ScanInQuery hints the scanner to scan the request url query.
        ScanInQuery
        // ScanInHeader ints the scanner to scan the request header.
        ScanInHeader
)

// ScanParameter configured the ScanParameters function.
type ScanParameter struct {
        // Data contains the reference to the parameter, that should
        // be scanned to
        Data interface{}
        // Where the data can be found for scanning
        Location ScanIn
        // Input must contain the value data if location is in ScanInPath
        Input string
        // Name of the query variable
        Name string
}

// BuildInvalidValueError build a new error, using the passed type and data.
func (p *ScanParameter) BuildInvalidValueError(typ reflect.Type, data string) error {
        return &Error{
                Title:  fmt.Sprintf("invalid value for %s", p.Name),
                Detail: fmt.Sprintf("invalid value, expected %s got: %q", typ, data),
                Source: &map[string]interface{}{
                        "parameter": p.Name,
                },
        }
}

// ScanParameters scans the request using the given path parameter objects
// in case an error is encountered a 400 along with a jsonapi errors object
// is sent to the ResponseWriter and false is returned. Returns true if all
// values were scanned successfully. The used scanning function is fmt.Sscan.
func ScanParameters(w http.ResponseWriter, r *http.Request, parameters ...*ScanParameter) bool {
        for _, param := range parameters {
                var scanData string

                switch param.Location {
                case ScanInPath:
                        // input is filled with path data
                        scanData = param.Input
                case ScanInQuery:
                        // input may not be filled and needs to be parsed from the request
                        input := r.URL.Query()[param.Name]

                        // if parameter is a slice
                        reValue := reflect.ValueOf(param.Data).Elem()
                        if reValue.Kind() == reflect.Slice {
                                size := len(input)
                                array := reflect.MakeSlice(reValue.Type(), size, size)
                                invalid := 0

                                for i := 0; i < size; i++ {
                                        if input[i] == "" {
                                                invalid++
                                                continue
                                        }

                                        arrElem := array.Index(i - invalid)
                                        n, _ := Scan(input[i], arrElem.Addr().Interface())

                                        if n != 1 {
                                                WriteError(w, http.StatusBadRequest, param.BuildInvalidValueError(arrElem.Type(), input[i]))
                                                return false
                                        }
                                }
                                // some of the query parameters where empty, filter them out
                                if invalid > 0 {
                                        array = array.Slice(0, size-invalid)
                                }

                                reValue.Set(array)

                                // skip parsing at the bottom of the loop
                                continue
                        }

                        // single parameter scanning
                        scanData = strings.Join(input, " ")
                case ScanInHeader:
                        scanData = r.Header.Get(param.Name)
                default:
                        panic(fmt.Errorf("impossible scanning location: %d", param.Location))
                }

                n, _ := Scan(scanData, param.Data)
                // only report on non empty data, govalidator will handle the other cases
                if n != 1 && scanData != "" {
                        WriteError(w, http.StatusBadRequest, param.BuildInvalidValueError(reflect.ValueOf(param.Data).Type(), scanData))
                        return false
                }
        }

        return true
}

// Scan works like fmt.Sscan except for strings and decimals, they are directly assigned.
func Scan(str string, data interface{}) (int, error) {
        // handle decimal
        if d, ok := data.(*decimal.Decimal); ok {
                nd, err := decimal.NewFromString(str)
                if err != nil {
                        return 0, err
                }

                *d = nd

                return 1, nil
        }

        // handle time
        if t, ok := data.(*time.Time); ok {
                nt, err := isotime.ParseISO8601(str)
                if err != nil {
                        return 0, err
                }

                *t = nt

                return 1, nil
        }

        // Don't handle plain strings with sscan but directly assign the value
        strPtr, ok := data.(*string)
        if ok {
                *strPtr = str
                return 1, nil
        }

        return fmt.Sscan(str, data)
}

1	// Copyright © 2018 by PACE Telematics GmbH. All rights reserved.
2
3	package runtime
4
5	import (
6	"fmt"
7	"net/http"
8	"reflect"
9	"strings"
10	"time"
11
12	"github.com/shopspring/decimal"
13
14	"github.com/pace/bricks/pkg/isotime"
15	)
16
17	// ScanIn help to avoid missuse using iota for the possible values.
18	type ScanIn int
19
20	const (
21	// ScanInPath hints the scanner to scan the input.
22	ScanInPath ScanIn = iota
23	// ScanInQuery hints the scanner to scan the request url query.
24	ScanInQuery
25	// ScanInHeader ints the scanner to scan the request header.
26	ScanInHeader
27	)
28
29	// ScanParameter configured the ScanParameters function.
30	type ScanParameter struct {
31	// Data contains the reference to the parameter, that should
32	// be scanned to
33	Data interface{}
34	// Where the data can be found for scanning
35	Location ScanIn
36	// Input must contain the value data if location is in ScanInPath
37	Input string
38	// Name of the query variable
39	Name string
40	}
41
42	// BuildInvalidValueError build a new error, using the passed type and data.
43	func (p *ScanParameter) BuildInvalidValueError(typ reflect.Type, data string) error {	2✔
44	return &Error{	2✔
45	Title: fmt.Sprintf("invalid value for %s", p.Name),	2✔
46	Detail: fmt.Sprintf("invalid value, expected %s got: %q", typ, data),	2✔
47	Source: &map[string]interface{}{	2✔
48	"parameter": p.Name,	2✔
49	},	2✔
50	}	2✔
51	}	2✔
52
53	// ScanParameters scans the request using the given path parameter objects
54	// in case an error is encountered a 400 along with a jsonapi errors object
55	// is sent to the ResponseWriter and false is returned. Returns true if all
56	// values were scanned successfully. The used scanning function is fmt.Sscan.
57	func ScanParameters(w http.ResponseWriter, r http.Request, parameters ...ScanParameter) bool {	25✔
58	for _, param := range parameters {	70✔
59	var scanData string	45✔
60		45✔
61	switch param.Location {	45✔
62	case ScanInPath:	12✔
63	// input is filled with path data	12✔
64	scanData = param.Input	12✔
65	case ScanInQuery:	32✔
66	// input may not be filled and needs to be parsed from the request	32✔
67	input := r.URL.Query()[param.Name]	32✔
68		32✔
69	// if parameter is a slice	32✔
70	reValue := reflect.ValueOf(param.Data).Elem()	32✔
71	if reValue.Kind() == reflect.Slice {	34✔
72	size := len(input)	2✔
73	array := reflect.MakeSlice(reValue.Type(), size, size)	2✔
74	invalid := 0	2✔
75		2✔
76	for i := 0; i < size; i++ {	7✔
77	if input[i] == "" {	6✔
78	invalid++	1✔
79	continue	1✔
80	}
81
82	arrElem := array.Index(i - invalid)	4✔
83	n, _ := Scan(input[i], arrElem.Addr().Interface())	4✔
84		4✔
85	if n != 1 {	5✔
86	WriteError(w, http.StatusBadRequest, param.BuildInvalidValueError(arrElem.Type(), input[i]))	1✔
87	return false	1✔
88	}	1✔
89	}
90	// some of the query parameters where empty, filter them out
91	if invalid > 0 {	2✔
92	array = array.Slice(0, size-invalid)	1✔
93	}	1✔
94
95	reValue.Set(array)	1✔
96		1✔
97	// skip parsing at the bottom of the loop	1✔
98	continue	1✔
99	}
100
101	// single parameter scanning
102	scanData = strings.Join(input, " ")	30✔
103	case ScanInHeader:	1✔
104	scanData = r.Header.Get(param.Name)	1✔
105	default:	×
106	panic(fmt.Errorf("impossible scanning location: %d", param.Location))	×
107	}
108
109	n, _ := Scan(scanData, param.Data)	43✔
110	// only report on non empty data, govalidator will handle the other cases	43✔
111	if n != 1 && scanData != "" {	44✔
112	WriteError(w, http.StatusBadRequest, param.BuildInvalidValueError(reflect.ValueOf(param.Data).Type(), scanData))	1✔
113	return false	1✔
114	}	1✔
115	}
116
117	return true	23✔
118	}
119
120	// Scan works like fmt.Sscan except for strings and decimals, they are directly assigned.
121	func Scan(str string, data interface{}) (int, error) {	47✔
122	// handle decimal	47✔
123	if d, ok := data.(*decimal.Decimal); ok {	47✔
124	nd, err := decimal.NewFromString(str)	×
125	if err != nil {	×
126	return 0, err	×
127	}	×
128
129	*d = nd	×
NEW 130		×
UNCOV 131	return 1, nil	×
132	}
133
134	// handle time
135	if t, ok := data.(*time.Time); ok {	53✔
136	nt, err := isotime.ParseISO8601(str)	6✔
137	if err != nil {	6✔
138	return 0, err	×
139	}	×
140
141	*t = nt	6✔
142		6✔
143	return 1, nil	6✔
144	}
145
146	// Don't handle plain strings with sscan but directly assign the value
147	strPtr, ok := data.(*string)	41✔
148	if ok {	45✔
149	*strPtr = str	4✔
150	return 1, nil	4✔
151	}	4✔
152
153	return fmt.Sscan(str, data)	37✔
154	}

pace / bricks / 12827718001

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