1686000914

Committed 24 Feb 2025 01:34PM UTC coverage: 76.203%. Remained the same

Build # 1686000914

Build Type

Pull #416

gitlab-ci

Committed by

mzedel

Commit Message

test: added e2e tests for webhook functionality

Ticket: MEN-7926
Signed-off-by: Manuel Zedel <manuel.zedel@northern.tech>

Pull Request Pull Request #416: MEN-7926

Run Details

4 of 8 new or added lines in 2 files covered. (50.0%)

4 existing lines in 2 files now uncovered.

36860 of 48371 relevant lines covered (76.2%)

1.49 hits per line

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

96.49

/backend/services/iot-manager/model/credentials_http.go

// Copyright 2022 Northern.tech AS
//
//    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 model

import (
        "encoding/hex"
        "encoding/json"
        "fmt"
        "net"
        "net/url"

        "github.com/mendersoftware/mender-server/pkg/config"
        dconfig "github.com/mendersoftware/mender-server/services/iot-manager/config"
        "github.com/mendersoftware/mender-server/services/iot-manager/crypto"
        inet "github.com/mendersoftware/mender-server/services/iot-manager/internal/net"

        validation "github.com/go-ozzo/ozzo-validation/v4"
)

type HexSecret crypto.String

func (sec *HexSecret) UnmarshalText(b []byte) error {
        dst := make([]byte, hex.DecodedLen(len(b)))
        n, err := hex.Decode(dst, b)
        if err != nil {
                return fmt.Errorf("value error: '%s' is not a hexadecimal string", string(b))
        }
        *sec = HexSecret(dst[:n])
        return nil
}

func (sec HexSecret) MarshalText() ([]byte, error) {
        return []byte("<omitted>"), nil
}

func (sec HexSecret) MarshalBSON() ([]byte, error) {
        cStr := crypto.String(sec)
        return (&cStr).MarshalBSON()
}

func (sec *HexSecret) UnmarshalBSON(b []byte) error {
        cStr := (*crypto.String)(sec)
        return cStr.UnmarshalBSON(b)
}

type HTTPCredentials struct {
        URL    string     `json:"url,omitempty" bson:"url,omitempty"`
        Secret *HexSecret `json:"secret,omitempty" bson:"secret,omitempty"`

        // private field toggling validation verbosity
        // - only set if unmarshaled from JSON
        validateAddr bool
}

func (cred *HTTPCredentials) UnmarshalJSON(b []byte) error {
        type creds HTTPCredentials
        if err := json.Unmarshal(b, (*creds)(cred)); err != nil {
                return err
        }
        cred.validateAddr = true
        return nil
}

func (cred HTTPCredentials) validateURL(interface{}) error {
        uu, err := url.Parse(cred.URL)
        if err != nil {
                return err
        }
        c := config.Config
        if c.GetBool(dconfig.SettingDomainSkipVerify) {
                return nil
        }
        if !cred.validateAddr {
                return nil
        }
        ips, err := net.LookupIP(uu.Hostname())
        if err != nil {
                return err
        }
        for _, ip := range ips {
                if !inet.IsGlobalUnicast(ip) {
                        return net.InvalidAddrError(
                                "hostname resolves to reserved address",
                        )
                }
        }
        return nil
}

func (cred HTTPCredentials) Validate() error {
        return validation.ValidateStruct(&cred,
                validation.Field(&cred.URL,
                        validation.Required,
                        validation.By(cred.validateURL),
                ),
        )
}

1	// Copyright 2022 Northern.tech AS
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 model
16
17	import (
18	"encoding/hex"
19	"encoding/json"
20	"fmt"
21	"net"
22	"net/url"
23
24	"github.com/mendersoftware/mender-server/pkg/config"
25	dconfig "github.com/mendersoftware/mender-server/services/iot-manager/config"
26	"github.com/mendersoftware/mender-server/services/iot-manager/crypto"
27	inet "github.com/mendersoftware/mender-server/services/iot-manager/internal/net"
28
29	validation "github.com/go-ozzo/ozzo-validation/v4"
30	)
31
32	type HexSecret crypto.String
33
34	func (sec *HexSecret) UnmarshalText(b []byte) error {	2✔
35	dst := make([]byte, hex.DecodedLen(len(b)))	2✔
36	n, err := hex.Decode(dst, b)	2✔
37	if err != nil {	3✔
38	return fmt.Errorf("value error: '%s' is not a hexadecimal string", string(b))	1✔
39	}	1✔
40	*sec = HexSecret(dst[:n])	2✔
41	return nil	2✔
42	}
43
44	func (sec HexSecret) MarshalText() ([]byte, error) {	1✔
45	return []byte("<omitted>"), nil	1✔
46	}	1✔
47
48	func (sec HexSecret) MarshalBSON() ([]byte, error) {	2✔
49	cStr := crypto.String(sec)	2✔
50	return (&cStr).MarshalBSON()	2✔
51	}	2✔
52
53	func (sec *HexSecret) UnmarshalBSON(b []byte) error {	2✔
54	cStr := (*crypto.String)(sec)	2✔
55	return cStr.UnmarshalBSON(b)	2✔
56	}	2✔
57
58	type HTTPCredentials struct {
59	URL string `json:"url,omitempty" bson:"url,omitempty"`
60	Secret *HexSecret `json:"secret,omitempty" bson:"secret,omitempty"`
61
62	// private field toggling validation verbosity
63	// - only set if unmarshaled from JSON
64	validateAddr bool
65	}
66
67	func (cred *HTTPCredentials) UnmarshalJSON(b []byte) error {	3✔
68	type creds HTTPCredentials	3✔
69	if err := json.Unmarshal(b, (*creds)(cred)); err != nil {	4✔
70	return err	1✔
71	}	1✔
72	cred.validateAddr = true	3✔
73	return nil	3✔
74	}
75
76	func (cred HTTPCredentials) validateURL(interface{}) error {	3✔
77	uu, err := url.Parse(cred.URL)	3✔
78	if err != nil {	4✔
79	return err	1✔
80	}	1✔
81	c := config.Config	3✔
82	if c.GetBool(dconfig.SettingDomainSkipVerify) {	3✔
NEW UNCOV 83	return nil	×
NEW UNCOV 84	}	×
85	if !cred.validateAddr {	6✔
86	return nil	3✔
87	}	3✔
88	ips, err := net.LookupIP(uu.Hostname())	3✔
89	if err != nil {	4✔
90	return err	1✔
91	}	1✔
92	for _, ip := range ips {	6✔
93	if !inet.IsGlobalUnicast(ip) {	4✔
94	return net.InvalidAddrError(	1✔
95	"hostname resolves to reserved address",	1✔
96	)	1✔
97	}	1✔
98	}
99	return nil	3✔
100	}
101
102	func (cred HTTPCredentials) Validate() error {	3✔
103	return validation.ValidateStruct(&cred,	3✔
104	validation.Field(&cred.URL,	3✔
105	validation.Required,	3✔
106	validation.By(cred.validateURL),	3✔
107	),	3✔
108	)	3✔
109	}	3✔

mendersoftware / mender-server / 1686000914

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