github.com/mendersoftware/go-lib-micro@v0.0.0-20240304135804-e8e39c59b148/mongo/oid/objectid_test.go (about)

     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 oid
    16  
    17  import (
    18  	"encoding/binary"
    19  	"encoding/json"
    20  	"testing"
    21  
    22  	"github.com/google/uuid"
    23  	"github.com/stretchr/testify/assert"
    24  	"go.mongodb.org/mongo-driver/bson"
    25  	"go.mongodb.org/mongo-driver/bson/bsontype"
    26  )
    27  
    28  type s struct {
    29  	ID ObjectID
    30  }
    31  
    32  func TestUUID(t *testing.T) {
    33  	// Test NewSHA1
    34  	uuid5 := NewUUIDv5("foobar")
    35  	assert.Equal(t, uuid5.Type(), TypeUUID)
    36  	uuid5Eq := NewUUIDv5("foobar")
    37  	assert.Equal(t, uuid5, uuid5Eq)
    38  
    39  	// Test FromString
    40  	uuidFromString := FromString(uuid5.String())
    41  	assert.Equal(t, uuid5, uuidFromString)
    42  
    43  	// Test NewRandom
    44  	uRandom := NewUUIDv4()
    45  	assert.NotEqual(t, uuid.Nil, uRandom.id)
    46  	assert.NotEmpty(t, uRandom)
    47  
    48  	// Test marshal/unmarshal bson
    49  	bsonType, b, err := uRandom.MarshalBSONValue()
    50  	assert.NoError(t, err)
    51  	assert.Equal(t, bsontype.Binary, bsonType)
    52  
    53  	// Illegal bsontype
    54  	err = uRandom.UnmarshalBSONValue(bsontype.Undefined, b)
    55  	assert.Error(t, err)
    56  	// OK
    57  	err = uRandom.UnmarshalBSONValue(bsonType, b)
    58  	assert.NoError(t, err)
    59  	// Invalid sub-type
    60  	b[4] = bsontype.BinaryGeneric
    61  	err = uRandom.UnmarshalBSONValue(bsonType, b)
    62  	assert.Error(t, err)
    63  	// Invalid length
    64  	binary.LittleEndian.PutUint32(b, 10)
    65  	err = uRandom.UnmarshalBSONValue(bsonType, b)
    66  	assert.Error(t, err)
    67  
    68  	// Test bson.Marshal / bson.Unmarshal with an embedded UUID
    69  	s1 := s{ID: uRandom}
    70  	var res s
    71  	b, err = bson.Marshal(s1)
    72  	assert.NoError(t, err)
    73  	err = bson.Unmarshal(b, &res)
    74  	assert.NoError(t, err)
    75  	assert.Equal(t, s1, res)
    76  
    77  	// Test Marshal / Unmarshal JSON
    78  	b, err = json.Marshal(s1)
    79  	assert.NoError(t, err)
    80  	err = json.Unmarshal(b, &res)
    81  	assert.NoError(t, err)
    82  	assert.Equal(t, s1, res)
    83  }
    84  
    85  func TestBSONID(t *testing.T) {
    86  	id := NewBSONID()
    87  	assert.NotEmpty(t, id)
    88  	assert.Equal(t, id.Type(), TypeBSONID)
    89  	idEq := FromString(id.String())
    90  	assert.Equal(t, id, idEq)
    91  
    92  	// Test Marshal/Unmarshal BSON
    93  	bsonType, b, err := id.MarshalBSONValue()
    94  	assert.NoError(t, err)
    95  	assert.Equal(t, bsontype.ObjectID, bsonType)
    96  	assert.NotEmpty(t, b)
    97  
    98  	// Unmarshal with wrong bsontype
    99  	tmp := &ObjectID{}
   100  	err = tmp.UnmarshalBSONValue(bsontype.Binary, b)
   101  	assert.Error(t, err)
   102  	// Unmarshal OK
   103  	err = tmp.UnmarshalBSONValue(bsontype.ObjectID, b)
   104  	assert.NoError(t, err)
   105  	assert.Equal(t, id, *tmp)
   106  	// Unmarshal malformed data
   107  	err = tmp.UnmarshalBSONValue(bsontype.ObjectID, []byte{})
   108  	assert.Error(t, err)
   109  
   110  	// Marshal / Unmarshal JSON
   111  	sct := s{ID: id}
   112  	b, err = json.Marshal(sct)
   113  	assert.NoError(t, err)
   114  	var sctParsed s
   115  	err = json.Unmarshal(b, &sctParsed)
   116  	assert.NoError(t, err)
   117  	assert.Equal(t, sct, sctParsed)
   118  }
   119  
   120  func TestString(t *testing.T) {
   121  	str := ObjectID{id: "foobar"}
   122  	assert.Equal(t, str.Type(), TypeString)
   123  	assert.Equal(t, str.String(), "foobar")
   124  
   125  	null := ObjectID{}
   126  	assert.Equal(t, null.Type(), TypeNil)
   127  
   128  	fromStrBSONIDLen := FromString("__ObjectIDLengthString__")
   129  	assert.Equal(t, fromStrBSONIDLen.Type(), TypeString)
   130  	fromStrUUIDLen := FromString("ThisStringHasSameLengthAsAUUIDString")
   131  	assert.Equal(t, fromStrUUIDLen.Type(), TypeString)
   132  
   133  	// Marshal / Unmarshal BSON
   134  	tmp := &ObjectID{}
   135  	bsonType, b, err := str.MarshalBSONValue()
   136  	assert.NoError(t, err)
   137  	assert.Equal(t, bsontype.String, bsonType)
   138  	err = tmp.UnmarshalBSONValue(bsontype.Undefined, b)
   139  	assert.Error(t, err)
   140  	err = tmp.UnmarshalBSONValue(bsonType, b)
   141  	assert.NoError(t, err)
   142  	assert.Equal(t, str, *tmp)
   143  	// corrupt length field
   144  	b[0] = 0xFF
   145  	err = tmp.UnmarshalBSONValue(bsonType, b)
   146  	assert.Error(t, err)
   147  
   148  	// Marshal / Unmarshal BSON as embedded field
   149  	var sctParsed s
   150  	sct := s{ID: str}
   151  	b, err = bson.Marshal(sct)
   152  	assert.NoError(t, err)
   153  	err = bson.Unmarshal(b, &sctParsed)
   154  	assert.NoError(t, err)
   155  	assert.Equal(t, sct, sctParsed)
   156  
   157  	// Marshal / Unmarshal JSON
   158  	b, err = json.Marshal(sct)
   159  	assert.NoError(t, err)
   160  	err = json.Unmarshal(b, &sctParsed)
   161  	assert.NoError(t, err)
   162  	assert.Equal(t, sct, sctParsed)
   163  }
   164  
   165  func TestNull(t *testing.T) {
   166  	null := ObjectID{}
   167  	assert.Equal(t, null.String(), "")
   168  	_, _, err := null.MarshalBSONValue()
   169  	assert.Error(t, err)
   170  }