14645073525

Committed 24 Apr 2025 03:08PM UTC coverage: 89.468% (-0.6%) from 90.109%

Build # 14645073525

Build Type

Pull #56

github

Committed by

web-flow

Commit Message

Merge 0acb0fd56 into 1e6002462

Pull Request Pull Request #56: storage/testsuite: Expand testsuite to cover more scenarios

Run Details

40 of 54 new or added lines in 1 file covered. (74.07%)

790 of 883 relevant lines covered (89.47%)

46.59 hits per line

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

87.5

/pkg/server/storage/testsuite/basic.go

package testsuite

import (
        "fmt"
        "testing"

        "github.com/stretchr/testify/assert"
)

// Runs basic tests for the storage backend.
// It will create a new backend instance for each test case.
func RunStorageBackendTests(t *testing.T, factory StorageBackendFactory) {
        t.Run("AddHost", func(t *testing.T) {
                backend := factory(t, "add-host")

                err := backend.AddHost(testHosts[0].MAC, testHosts[0].Name)
                assert.NoError(t, err, "AddHost failed")
        })

        t.Run("GetHost", func(t *testing.T) {
                backend := factory(t, "get-host")
                addHosts(t, backend)

                host, err := backend.GetHost(testHosts[0].MAC)
                assert.NoError(t, err, "GetHost failed")
                assert.Equal(t, testHosts[0].Name, host, "Failed to retrieve host")
        })

        t.Run("RemoveHost", func(t *testing.T) {
                tMatrix := []struct {
                        name  string
                        index int
                }{
                        {
                                name:  "FirstElement",
                                index: 0,
                        },
                        {
                                name:  "LastElement",
                                index: len(testHosts) - 1,
                        },
                        {
                                name:  "MiddleElement",
                                index: 1,
                        },
                }

                for i, tCase := range tMatrix {
                        t.Run(tCase.name, func(t *testing.T) {
                                backend := factory(t, fmt.Sprintf("remove-host-%d", i))
                                addHosts(t, backend)

                                err := backend.RemoveHost(testHosts[tCase.index].MAC)
                                assert.NoError(t, err, "RemoveHost failed")
                                host, _ := backend.GetHost(testHosts[tCase.index].MAC)
                                assert.Empty(t, host, "Expected empty host")
                        })
                }
        })

        t.Run("RemoveHostNonExistent", func(t *testing.T) {
                backend := factory(t, "remove-host-non-existent")

                err := backend.RemoveHost("00:11:22:33:44:55")
                assert.NoError(t, err, "RemoveHost for non-existent host failed")
        })

        t.Run("GetHosts", func(t *testing.T) {
                backend := factory(t, "get-hosts")
                addHosts(t, backend)

                hosts, err := backend.GetHosts()
                assert.NoError(t, err, "GetHosts failed")
                assert.Equal(t, testHosts, hosts, "Expected result to match testHosts")
        })

        t.Run("CaseInsensitiveMAC", func(t *testing.T) {
                assert := assert.New(t)
                backend := factory(t, "case-insensitive-mac")

                err := backend.AddHost("aa:bb:cc:dd:ee:ff", "LowerCase")

                if !assert.NoError(err, "Should add host") {
                        t.FailNow()
                }

                host, err := backend.GetHost("AA:BB:CC:dd:ee:ff")
                assert.NoError(err, "Should get host regardless of case")
                assert.Equal("LowerCase", host, "Should get correct host name")

                hosts, err := backend.GetHosts()
                assert.NoError(err, "Should get hosts")

                if !assert.Len(hosts, 1, "Should have one host") {
                        t.FailNow()
                }
                assert.Equal("LowerCase", hosts[0].Name, "Should get correct host name")
                assert.Equal("AA:BB:CC:DD:EE:FF", hosts[0].MAC, "Should store MAC in upper case")
        })

        t.Run("AddHostOverwrite", func(t *testing.T) {
                assert := assert.New(t)
                backend := factory(t, "add-host-overwrite")

                err := backend.AddHost(testHosts[0].MAC, testHosts[0].Name)
                if !assert.NoError(err, "Should add host") {
                        t.FailNow()
                }

                err = backend.AddHost(testHosts[0].MAC, "NewName")
                if !assert.NoError(err, "Should overwrite host") {
                        t.FailNow()
                }

                hosts, err := backend.GetHosts()
                assert.NoError(err, "Should get hosts")
                if !assert.Len(hosts, 1, "Should have one host") {
                        t.FailNow()
                }
                assert.Equal("NewName", hosts[0].Name, "Should have new name")
        })

        t.Run("HostOverwriteShouldKeepOrder", func(t *testing.T) {
                assert := assert.New(t)
                backend := factory(t, "host-overwrite-keep-order")
                addHosts(t, backend)

                err := backend.AddHost(testHosts[0].MAC, "NewName")
                if !assert.NoError(err, "Should overwrite host") {
                        t.FailNow()
                }

                hosts, err := backend.GetHosts()
                assert.NoError(err, "Should get hosts")
                if !assert.Len(hosts, len(testHosts), "Should have same number of hosts") {
                        t.FailNow()
                }
                assert.Equal("NewName", hosts[0].Name, "Should have new name")
        })
}

1	package testsuite
2
3	import (
4	"fmt"
5	"testing"
6
7	"github.com/stretchr/testify/assert"
8	)
9
10	// Runs basic tests for the storage backend.
11	// It will create a new backend instance for each test case.
12	func RunStorageBackendTests(t *testing.T, factory StorageBackendFactory) {	2✔
13	t.Run("AddHost", func(t *testing.T) {	4✔
14	backend := factory(t, "add-host")	2✔
15		2✔
16	err := backend.AddHost(testHosts[0].MAC, testHosts[0].Name)	2✔
17	assert.NoError(t, err, "AddHost failed")	2✔
18	})	2✔
19
20	t.Run("GetHost", func(t *testing.T) {	4✔
21	backend := factory(t, "get-host")	2✔
22	addHosts(t, backend)	2✔
23		2✔
24	host, err := backend.GetHost(testHosts[0].MAC)	2✔
25	assert.NoError(t, err, "GetHost failed")	2✔
26	assert.Equal(t, testHosts[0].Name, host, "Failed to retrieve host")	2✔
27	})	2✔
28
29	t.Run("RemoveHost", func(t *testing.T) {	4✔
30	tMatrix := []struct {	2✔
31	name string	2✔
32	index int	2✔
33	}{	2✔
34	{	2✔
35	name: "FirstElement",	2✔
36	index: 0,	2✔
37	},	2✔
38	{	2✔
39	name: "LastElement",	2✔
40	index: len(testHosts) - 1,	2✔
41	},	2✔
42	{	2✔
43	name: "MiddleElement",	2✔
44	index: 1,	2✔
45	},	2✔
46	}	2✔
47		2✔
48	for i, tCase := range tMatrix {	8✔
49	t.Run(tCase.name, func(t *testing.T) {	12✔
50	backend := factory(t, fmt.Sprintf("remove-host-%d", i))	6✔
51	addHosts(t, backend)	6✔
52		6✔
53	err := backend.RemoveHost(testHosts[tCase.index].MAC)	6✔
54	assert.NoError(t, err, "RemoveHost failed")	6✔
55	host, _ := backend.GetHost(testHosts[tCase.index].MAC)	6✔
56	assert.Empty(t, host, "Expected empty host")	6✔
57	})	6✔
58	}
59	})
60
61	t.Run("RemoveHostNonExistent", func(t *testing.T) {	4✔
62	backend := factory(t, "remove-host-non-existent")	2✔
63		2✔
64	err := backend.RemoveHost("00:11:22:33:44:55")	2✔
65	assert.NoError(t, err, "RemoveHost for non-existent host failed")	2✔
66	})	2✔
67
68	t.Run("GetHosts", func(t *testing.T) {	4✔
69	backend := factory(t, "get-hosts")	2✔
70	addHosts(t, backend)	2✔
71		2✔
72	hosts, err := backend.GetHosts()	2✔
73	assert.NoError(t, err, "GetHosts failed")	2✔
74	assert.Equal(t, testHosts, hosts, "Expected result to match testHosts")	2✔
75	})	2✔
76
77	t.Run("CaseInsensitiveMAC", func(t *testing.T) {	4✔
78	assert := assert.New(t)	2✔
79	backend := factory(t, "case-insensitive-mac")	2✔
80		2✔
81	err := backend.AddHost("aa:bb:cc:dd:ee:ff", "LowerCase")	2✔
82		2✔
83	if !assert.NoError(err, "Should add host") {	2✔
NEW 84	t.FailNow()	×
NEW 85	}	×
86
87	host, err := backend.GetHost("AA:BB:CC:dd:ee:ff")	2✔
88	assert.NoError(err, "Should get host regardless of case")	2✔
89	assert.Equal("LowerCase", host, "Should get correct host name")	2✔
90		2✔
91	hosts, err := backend.GetHosts()	2✔
92	assert.NoError(err, "Should get hosts")	2✔
93		2✔
94	if !assert.Len(hosts, 1, "Should have one host") {	2✔
NEW 95	t.FailNow()	×
NEW 96	}	×
97	assert.Equal("LowerCase", hosts[0].Name, "Should get correct host name")	2✔
98	assert.Equal("AA:BB:CC:DD:EE:FF", hosts[0].MAC, "Should store MAC in upper case")	2✔
99	})
100
101	t.Run("AddHostOverwrite", func(t *testing.T) {	4✔
102	assert := assert.New(t)	2✔
103	backend := factory(t, "add-host-overwrite")	2✔
104		2✔
105	err := backend.AddHost(testHosts[0].MAC, testHosts[0].Name)	2✔
106	if !assert.NoError(err, "Should add host") {	2✔
NEW 107	t.FailNow()	×
NEW 108	}	×
109
110	err = backend.AddHost(testHosts[0].MAC, "NewName")	2✔
111	if !assert.NoError(err, "Should overwrite host") {	2✔
NEW 112	t.FailNow()	×
NEW 113	}	×
114
115	hosts, err := backend.GetHosts()	2✔
116	assert.NoError(err, "Should get hosts")	2✔
117	if !assert.Len(hosts, 1, "Should have one host") {	2✔
NEW 118	t.FailNow()	×
NEW 119	}	×
120	assert.Equal("NewName", hosts[0].Name, "Should have new name")	2✔
121	})
122
123	t.Run("HostOverwriteShouldKeepOrder", func(t *testing.T) {	4✔
124	assert := assert.New(t)	2✔
125	backend := factory(t, "host-overwrite-keep-order")	2✔
126	addHosts(t, backend)	2✔
127		2✔
128	err := backend.AddHost(testHosts[0].MAC, "NewName")	2✔
129	if !assert.NoError(err, "Should overwrite host") {	2✔
NEW 130	t.FailNow()	×
NEW 131	}	×
132
133	hosts, err := backend.GetHosts()	2✔
134	assert.NoError(err, "Should get hosts")	2✔
135	if !assert.Len(hosts, len(testHosts), "Should have same number of hosts") {	2✔
NEW 136	t.FailNow()	×
NEW 137	}	×
138	assert.Equal("NewName", hosts[0].Name, "Should have new name")	2✔
139	})
140	}

heathcliff26 / go-wol / 14645073525

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