10814152930

Committed 11 Sep 2024 02:44PM UTC coverage: 75.27%. Remained the same

Build # 10814152930

Build Type

push

github

Committed by

web-flow

Commit Message

Update deps (#305)

* Update k6 to v0.53.0
* Update Go to v1.23.1
* Update deps
* Update Go version in actions
* Pin package to avoid conflicts

Run Details

1534 of 2038 relevant lines covered (75.27%)

13.66 hits per line

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

59.52

/json.go

package kafka

import (
        "encoding/json"
)

type JSONSerde struct {
        Serdes
}

// Serialize serializes a JSON object as map to bytes.
func (*JSONSerde) Serialize(data interface{}, schema *Schema) ([]byte, *Xk6KafkaError) {
        var jsonObject []byte
        if data, ok := data.(map[string]interface{}); ok {
                if encodedData, err := json.Marshal(data); err == nil {
                        jsonObject = encodedData
                } else {
                        return nil, ErrInvalidDataType
                }
        } else {
                return nil, ErrInvalidDataType
        }

        if schema != nil {
                // Validate the JSON object against the schema only if the schema is
                // provided.
                jsonSchema := schema.JsonSchema()
                if jsonSchema != nil {
                        if err := jsonSchema.Validate(data); err != nil {
                                return nil, NewXk6KafkaError(failedValidateJSON,
                                        "Failed to validate JSON against schema",
                                        err)
                        }
                } else {
                        return nil, ErrInvalidSchema
                }
        }

        return jsonObject, nil
}

// Deserialize deserializes a map from bytes to be exported as object to JS.
func (*JSONSerde) Deserialize(data []byte, schema *Schema) (interface{}, *Xk6KafkaError) {
        var jsonObject interface{}
        if err := json.Unmarshal(data, &jsonObject); err != nil {
                return nil, NewXk6KafkaError(failedUnmarshalJSON,
                        "Failed to unmarshal JSON data",
                        err)
        }

        if schema != nil {
                // Validate the JSON object against the schema only if the schema is
                // provided.
                if err := schema.JsonSchema().Validate(jsonObject); err != nil {
                        err := NewXk6KafkaError(failedDecodeJSONFromBinary,
                                "Failed to decode data from JSON",
                                err)
                        return nil, err
                }
        }

        return jsonObject, nil
}

1	package kafka
2
3	import (
4	"encoding/json"
5	)
6
7	type JSONSerde struct {
8	Serdes
9	}
10
11	// Serialize serializes a JSON object as map to bytes.
12	func (JSONSerde) Serialize(data interface{}, schema Schema) ([]byte, *Xk6KafkaError) {	12✔
13	var jsonObject []byte	12✔
14	if data, ok := data.(map[string]interface{}); ok {	22✔
15	if encodedData, err := json.Marshal(data); err == nil {	18✔
16	jsonObject = encodedData	8✔
17	} else {	10✔
18	return nil, ErrInvalidDataType	2✔
19	}	2✔
20	} else {	2✔
21	return nil, ErrInvalidDataType	2✔
22	}	2✔
23
24	if schema != nil {	13✔
25	// Validate the JSON object against the schema only if the schema is	5✔
26	// provided.	5✔
27	jsonSchema := schema.JsonSchema()	5✔
28	if jsonSchema != nil {	8✔
29	if err := jsonSchema.Validate(data); err != nil {	4✔
30	return nil, NewXk6KafkaError(failedValidateJSON,	1✔
31	"Failed to validate JSON against schema",	1✔
32	err)	1✔
33	}	1✔
34	} else {	2✔
35	return nil, ErrInvalidSchema	2✔
36	}	2✔
37	}
38
39	return jsonObject, nil	5✔
40	}
41
42	// Deserialize deserializes a map from bytes to be exported as object to JS.
43	func (JSONSerde) Deserialize(data []byte, schema Schema) (interface{}, *Xk6KafkaError) {	×
44	var jsonObject interface{}	×
45	if err := json.Unmarshal(data, &jsonObject); err != nil {	×
46	return nil, NewXk6KafkaError(failedUnmarshalJSON,	×
47	"Failed to unmarshal JSON data",	×
48	err)	×
49	}	×
50
51	if schema != nil {	×
52	// Validate the JSON object against the schema only if the schema is	×
53	// provided.	×
54	if err := schema.JsonSchema().Validate(jsonObject); err != nil {	×
55	err := NewXk6KafkaError(failedDecodeJSONFromBinary,	×
56	"Failed to decode data from JSON",	×
57	err)	×
58	return nil, err	×
59	}	×
60	}
61
62	return jsonObject, nil	×
63	}

mostafa / xk6-kafka / 10814152930

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