1978029483

Committed 11 Aug 2025 02:15PM UTC coverage: 65.755% (+0.3%) from 65.495%

Build # 1978029483

Build Type

Pull #860

gitlab-ci

Committed by

kjaskiewiczz

Commit Message

docs(useradm): move API specification to single file

Changelog: Title
Ticket: QA-1094
Signed-off-by: Krzysztof Jaskiewicz <krzysztof.jaskiewicz@northern.tech>

Pull Request Pull Request #860: docs(useradm): move API specification to single file

Run Details

29261 of 44500 relevant lines covered (65.76%)

1.44 hits per line

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

12.5

/backend/pkg/mongo/codec/bson.go

// Copyright 2023 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 codec

import (
        "fmt"
        "reflect"

        "github.com/google/uuid"
        "go.mongodb.org/mongo-driver/bson"
        "go.mongodb.org/mongo-driver/bson/bsoncodec"
        "go.mongodb.org/mongo-driver/bson/bsonrw"
)

var (
        tUUID = reflect.TypeOf(uuid.UUID{})
)

func NewRegistry() *bsoncodec.Registry {
        reg := bson.NewRegistry()
        // Add UUID encoder/decoder for github.com/google/uuid.UUID
        uuidCodec := UUIDCodec{}
        reg.RegisterTypeEncoder(tUUID, uuidCodec)
        reg.RegisterTypeDecoder(tUUID, uuidCodec)
        return reg
}

type UUIDCodec struct{}

func (UUIDCodec) EncodeValue(
        ec bsoncodec.EncodeContext,
        w bsonrw.ValueWriter,
        val reflect.Value,
) error {
        if !val.IsValid() || val.Type() != tUUID {
                return bsoncodec.ValueEncoderError{
                        Name:     "UUIDCodec",
                        Types:    []reflect.Type{tUUID},
                        Received: val,
                }
        }
        uid := val.Interface().(uuid.UUID)
        return w.WriteBinaryWithSubtype(uid[:], bson.TypeBinaryUUID)
}

func (UUIDCodec) DecodeValue(
        ec bsoncodec.DecodeContext,
        r bsonrw.ValueReader,
        val reflect.Value,
) error {
        if !val.CanSet() || val.Type() != tUUID {
                return bsoncodec.ValueDecoderError{
                        Name:     "UUIDCodec",
                        Types:    []reflect.Type{tUUID},
                        Received: val,
                }
        }

        var (
                data    []byte
                err     error
                subtype byte
                uid     uuid.UUID = uuid.Nil
        )
        switch rType := r.Type(); rType {
        case bson.TypeBinary:
                data, subtype, err = r.ReadBinary()
                switch subtype {
                case bson.TypeBinaryGeneric:
                        if len(data) != 16 {
                                return fmt.Errorf(
                                        "cannot decode %v as a UUID: "+
                                                "incorrect length: %d",
                                        data, len(data),
                                )
                        }

                        fallthrough
                case bson.TypeBinaryUUID,
                        bson.TypeBinaryUUIDOld:
                        copy(uid[:], data)

                default:
                        err = fmt.Errorf(
                                "cannot decode %v as a UUID: "+
                                        "incorrect subtype 0x%02x",
                                data, subtype,
                        )
                }

        case bson.TypeUndefined:
                err = r.ReadUndefined()

        case bson.TypeNull:
                err = r.ReadNull()

        default:
                err = fmt.Errorf("cannot decode %v as a UUID", rType)
        }

        if err != nil {
                return err
        }
        val.Set(reflect.ValueOf(uid))
        return nil
}

1	// Copyright 2023 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 codec
16
17	import (
18	"fmt"
19	"reflect"
20
21	"github.com/google/uuid"
22	"go.mongodb.org/mongo-driver/bson"
23	"go.mongodb.org/mongo-driver/bson/bsoncodec"
24	"go.mongodb.org/mongo-driver/bson/bsonrw"
25	)
26
27	var (
28	tUUID = reflect.TypeOf(uuid.UUID{})
29	)
30
31	func NewRegistry() *bsoncodec.Registry {	2✔
32	reg := bson.NewRegistry()	2✔
33	// Add UUID encoder/decoder for github.com/google/uuid.UUID	2✔
34	uuidCodec := UUIDCodec{}	2✔
35	reg.RegisterTypeEncoder(tUUID, uuidCodec)	2✔
36	reg.RegisterTypeDecoder(tUUID, uuidCodec)	2✔
37	return reg	2✔
38	}	2✔
39
40	type UUIDCodec struct{}
41
42	func (UUIDCodec) EncodeValue(
43	ec bsoncodec.EncodeContext,
44	w bsonrw.ValueWriter,
45	val reflect.Value,
46	) error {	×
47	if !val.IsValid() \|\| val.Type() != tUUID {	×
48	return bsoncodec.ValueEncoderError{	×
49	Name: "UUIDCodec",	×
50	Types: []reflect.Type{tUUID},	×
51	Received: val,	×
52	}	×
53	}	×
54	uid := val.Interface().(uuid.UUID)	×
55	return w.WriteBinaryWithSubtype(uid[:], bson.TypeBinaryUUID)	×
56	}
57
58	func (UUIDCodec) DecodeValue(
59	ec bsoncodec.DecodeContext,
60	r bsonrw.ValueReader,
61	val reflect.Value,
62	) error {	×
63	if !val.CanSet() \|\| val.Type() != tUUID {	×
64	return bsoncodec.ValueDecoderError{	×
65	Name: "UUIDCodec",	×
66	Types: []reflect.Type{tUUID},	×
67	Received: val,	×
68	}	×
69	}	×
70
71	var (	×
72	data []byte	×
73	err error	×
74	subtype byte	×
75	uid uuid.UUID = uuid.Nil	×
76	)	×
77	switch rType := r.Type(); rType {	×
78	case bson.TypeBinary:	×
79	data, subtype, err = r.ReadBinary()	×
80	switch subtype {	×
81	case bson.TypeBinaryGeneric:	×
82	if len(data) != 16 {	×
83	return fmt.Errorf(	×
84	"cannot decode %v as a UUID: "+	×
85	"incorrect length: %d",	×
86	data, len(data),	×
87	)	×
88	}	×
89
90	fallthrough	×
91	case bson.TypeBinaryUUID,
92	bson.TypeBinaryUUIDOld:	×
93	copy(uid[:], data)	×
94
95	default:	×
96	err = fmt.Errorf(	×
97	"cannot decode %v as a UUID: "+	×
98	"incorrect subtype 0x%02x",	×
99	data, subtype,	×
100	)	×
101	}
102
103	case bson.TypeUndefined:	×
104	err = r.ReadUndefined()	×
105
106	case bson.TypeNull:	×
107	err = r.ReadNull()	×
108
109	default:	×
110	err = fmt.Errorf("cannot decode %v as a UUID", rType)	×
111	}
112
113	if err != nil {	×
114	return err	×
115	}	×
116	val.Set(reflect.ValueOf(uid))	×
117	return nil	×
118	}

mendersoftware / mender-server / 1978029483

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