15811505851

Committed 22 Jun 2025 10:34PM UTC coverage: 93.768% (+1.0%) from 92.74%

Build # 15811505851

Build Type

push

github

Committed by

byo

Commit Message

Merge branch 'test-improvements'

Run Details

55 of 128 new or added lines in 6 files covered. (42.97%)

3 existing lines in 1 file now uncovered.

3340 of 3562 relevant lines covered (93.77%)

1.05 hits per line

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

0.0

/pkg/datastore/testutils/generate/main.go

/*
Copyright © 2025 Bartłomiej Święcki (byo)

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 main

//go:generate go run .
import (
        "bytes"
        "crypto/sha256"
        _ "embed"
        "fmt"
        "html/template"
        "io"
        "os"

        "github.com/cinode/go/pkg/blobtypes"
        "github.com/cinode/go/pkg/common"
        "github.com/cinode/go/pkg/internal/blobtypes/dynamiclink"
        "github.com/cinode/go/pkg/utilities/golang"
        "github.com/jbenet/go-base58"
)

func errPanic(err error) {
        if err != nil {
                panic(err)
        }
}

type blobData struct {
        Name     string
        Data     string
        Expected string
}

func static(data string) blobData {
        content := []byte(data)
        hash := sha256.Sum256(content)
        n, err := common.BlobNameFromHashAndType(hash[:], blobtypes.Static)
        errPanic(err)

        return blobData{
                Name:     n.String(),
                Data:     base58.Encode(content),
                Expected: base58.Encode(content),
        }
}

func dynamicLink(data string, version uint64, seed int) blobData {
        baseSeed := []byte{
                byte(seed >> 8), byte(seed),
                // That's some random byte sequence, fixed here to ensure we're regenerating the same dataset
                0x7b, 0x7c, 0x99, 0x35, 0x7f, 0xed, 0x93, 0xd3,
        }

        pseudoRandBuffer := []byte{}
        for i := byte(0); i < 5; i++ {
                h := sha256.Sum256(append([]byte{i}, baseSeed...))
                pseudoRandBuffer = append(pseudoRandBuffer, h[:]...)
        }

        dl, err := dynamiclink.Create(bytes.NewReader(pseudoRandBuffer))
        errPanic(err)

        pr, _, err := dl.UpdateLinkData(bytes.NewBufferString(data), version)
        errPanic(err)

        buf, err := io.ReadAll(pr.GetPublicDataReader())
        errPanic(err)

        pr, err = dynamiclink.FromPublicData(dl.BlobName(), bytes.NewReader(buf))
        errPanic(err)

        elink, err := io.ReadAll(pr.GetEncryptedLinkReader())
        errPanic(err)

        return blobData{
                Name:     dl.BlobName().String(),
                Data:     base58.Encode(buf),
                Expected: base58.Encode(elink),
        }
}

//go:embed tesblobs.go.tpl
var templateString string
var tmpl = golang.Must(template.New("testblobs").Parse(templateString))

func main() {
        fl := golang.Must(os.Create("../testblobs.go"))
        defer fl.Close()

        err := tmpl.Execute(fl, map[string]any{
                "TestBlobs": []blobData{
                        static("Test"),
                        static("Test1"),
                        static(""),
                        dynamicLink("Test", 0, 0),
                        dynamicLink("Test1", 1, 1),
                        dynamicLink("", 2, 2),
                },
                "DynamicLinkPropagationData": []blobData{
                        dynamicLink("Test1", 10000, 999),
                        dynamicLink("Test2", 20000, 999),
                        dynamicLink("Test3", 20000, 999),
                },
        })
        errPanic(err)

        fmt.Println("Successfully generated testblobs.go")
}

1	/*
2	Copyright © 2025 Bartłomiej Święcki (byo)
3
4	Licensed under the Apache License, Version 2.0 (the "License");
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	http://www.apache.org/licenses/LICENSE-2.0
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16
17	package main
18
19	//go:generate go run .
20	import (
21	"bytes"
22	"crypto/sha256"
23	_ "embed"
24	"fmt"
25	"html/template"
26	"io"
27	"os"
28
29	"github.com/cinode/go/pkg/blobtypes"
30	"github.com/cinode/go/pkg/common"
31	"github.com/cinode/go/pkg/internal/blobtypes/dynamiclink"
32	"github.com/cinode/go/pkg/utilities/golang"
33	"github.com/jbenet/go-base58"
34	)
35
NEW 36	func errPanic(err error) {	×
NEW 37	if err != nil {	×
NEW 38	panic(err)	×
39	}
40	}
41
42	type blobData struct {
43	Name string
44	Data string
45	Expected string
46	}
47
NEW 48	func static(data string) blobData {	×
NEW 49	content := []byte(data)	×
NEW 50	hash := sha256.Sum256(content)	×
NEW 51	n, err := common.BlobNameFromHashAndType(hash[:], blobtypes.Static)	×
NEW 52	errPanic(err)	×
NEW 53		×
NEW 54	return blobData{	×
NEW 55	Name: n.String(),	×
NEW 56	Data: base58.Encode(content),	×
NEW 57	Expected: base58.Encode(content),	×
NEW 58	}	×
NEW 59	}	×
60
NEW 61	func dynamicLink(data string, version uint64, seed int) blobData {	×
NEW 62	baseSeed := []byte{	×
NEW 63	byte(seed >> 8), byte(seed),	×
NEW 64	// That's some random byte sequence, fixed here to ensure we're regenerating the same dataset	×
NEW 65	0x7b, 0x7c, 0x99, 0x35, 0x7f, 0xed, 0x93, 0xd3,	×
NEW 66	}	×
NEW 67		×
NEW 68	pseudoRandBuffer := []byte{}	×
NEW 69	for i := byte(0); i < 5; i++ {	×
NEW 70	h := sha256.Sum256(append([]byte{i}, baseSeed...))	×
NEW 71	pseudoRandBuffer = append(pseudoRandBuffer, h[:]...)	×
NEW 72	}	×
73
NEW 74	dl, err := dynamiclink.Create(bytes.NewReader(pseudoRandBuffer))	×
NEW 75	errPanic(err)	×
NEW 76		×
NEW 77	pr, _, err := dl.UpdateLinkData(bytes.NewBufferString(data), version)	×
NEW 78	errPanic(err)	×
NEW 79		×
NEW 80	buf, err := io.ReadAll(pr.GetPublicDataReader())	×
NEW 81	errPanic(err)	×
NEW 82		×
NEW 83	pr, err = dynamiclink.FromPublicData(dl.BlobName(), bytes.NewReader(buf))	×
NEW 84	errPanic(err)	×
NEW 85		×
NEW 86	elink, err := io.ReadAll(pr.GetEncryptedLinkReader())	×
NEW 87	errPanic(err)	×
NEW 88		×
NEW 89	return blobData{	×
NEW 90	Name: dl.BlobName().String(),	×
NEW 91	Data: base58.Encode(buf),	×
NEW 92	Expected: base58.Encode(elink),	×
NEW 93	}	×
94	}
95
96	//go:embed tesblobs.go.tpl
97	var templateString string
98	var tmpl = golang.Must(template.New("testblobs").Parse(templateString))
99
NEW 100	func main() {	×
NEW 101	fl := golang.Must(os.Create("../testblobs.go"))	×
NEW 102	defer fl.Close()	×
NEW 103		×
NEW 104	err := tmpl.Execute(fl, map[string]any{	×
NEW 105	"TestBlobs": []blobData{	×
NEW 106	static("Test"),	×
NEW 107	static("Test1"),	×
NEW 108	static(""),	×
NEW 109	dynamicLink("Test", 0, 0),	×
NEW 110	dynamicLink("Test1", 1, 1),	×
NEW 111	dynamicLink("", 2, 2),	×
NEW 112	},	×
NEW 113	"DynamicLinkPropagationData": []blobData{	×
NEW 114	dynamicLink("Test1", 10000, 999),	×
NEW 115	dynamicLink("Test2", 20000, 999),	×
NEW 116	dynamicLink("Test3", 20000, 999),	×
NEW 117	},	×
NEW 118	})	×
NEW 119	errPanic(err)	×
NEW 120		×
NEW 121	fmt.Println("Successfully generated testblobs.go")	×
NEW 122	}	×

cinode / go / 15811505851

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