ci(coverage): add new tests for increasing coverage rate

Author: pilebones

crawler/device_test.go

@@ -1,8 +1,11 @@
 package crawler
 
 import (
+	"context"
+	"os"
 	"reflect"
 	"testing"
+	"time"
 )
 
 func TestEventFromUEventData(t *testing.T) {
@@ -48,9 +51,59 @@ DEVNAME=vcs3`,
 	}
 
 	for k, tcase := range testcases {
-		evt := getEventFromUEventData([]byte(tcase.got))
+		tmp, err := os.CreateTemp("", "uevent-file")
+		if err != nil {
+			t.Fatalf("Test %d failed, unable to create temp file for uevent data", k)
+		}
+		defer os.Remove(tmp.Name())
+
+		if _, err := tmp.WriteString(tcase.got); err != nil {
+			t.Fatalf("Test %d failed, unable to append uevent data in temp file", k)
+		}
+
+		evt, err := getEventFromUEventFile(tmp.Name())
+		if err != nil {
+			t.Fatalf("Test %d failed, unable to get event dfrom uevent file", k)
+		}
+
+		if !reflect.DeepEqual(evt, getEventFromUEventData([]byte(tcase.got))) {
+			t.Fatalf("Test %d failed, uevent from file or data must be equals", k)
+		}
+
 		if !reflect.DeepEqual(evt, tcase.expected) {
 			t.Fatalf("Test %d failed (got: %v, expected: %v)", k, evt, tcase.expected)
 		}
 	}
 }
+
+func TestExistingDevices(t *testing.T) {
+	queue := make(chan Device)
+	errors := make(chan error)
+	quit := ExistingDevices(queue, errors, nil)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+
+	defer func() {
+		close(quit)
+		close(errors)
+		cancel()
+	}()
+
+	for {
+		select {
+		case <-ctx.Done():
+			t.Fatalf("reach timeout while getting existing devices, err: %v", ctx.Err())
+			quit <- struct{}{}
+		case _, more := <-queue:
+			if !more {
+				t.Log("Finished processing existing devices")
+				quit <- struct{}{}
+				return // without error
+			}
+			// t.Logf("Detect device at %s with env %v", device.KObj, device.Env)
+		case err := <-errors:
+			t.Fatalf("unable to get existing devices, err: %v", err)
+			quit <- struct{}{}
+		}
+	}
+}

netlink/conn.go

@@ -63,7 +63,7 @@ func (c *UEventConn) msgPeek() (int, *[]byte, error) {
 	buf := make([]byte, os.Getpagesize())
 	for {
 		// Just read how many bytes are available in the socket
-		// Warning: syscall.MSG_PEEK is a blocking call
+		// WARNING: syscall.MSG_PEEK is a blocking call (no testable from CI)
 		if n, _, err = syscall.Recvfrom(c.Fd, buf, syscall.MSG_PEEK); err != nil {
 			return n, &buf, err
 		}

netlink/conn_test.go

@@ -1,7 +1,9 @@
 package netlink
 
 import (
+	"context"
 	"testing"
+	"time"
 )
 
 func TestConnect(t *testing.T) {
@@ -13,6 +15,7 @@ func TestConnect(t *testing.T) {
 		_ = conn.Close()
 	}()
 
+	// ensure it is possible to subscribe several times in parallel
 	conn2 := new(UEventConn)
 	if err := conn2.Connect(UdevEvent); err != nil {
 		t.Fatal("unable to subscribe to netlink uevent a second time, err:", err)
@@ -21,3 +24,39 @@ func TestConnect(t *testing.T) {
 		_ = conn2.Close()
 	}()
 }
+
+func TestMonitor(t *testing.T) {
+	conn := new(UEventConn)
+	if err := conn.Connect(UdevEvent); err != nil {
+		t.Fatal("unable to subscribe to netlink uevent, err:", err)
+	}
+	defer func() {
+		_ = conn.Close()
+	}()
+
+	queue := make(chan UEvent)
+	errors := make(chan error)
+	quit := conn.Monitor(queue, errors, nil)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) // Monitor 5s then stop for testing
+	defer func() {
+		close(quit)
+		close(errors)
+		cancel()
+	}()
+
+loop:
+	for {
+		select {
+		case <-ctx.Done():
+			t.Log("Reach timeout while monitoring netlink uevent channel, everything is fine.")
+			quit <- struct{}{}
+			break loop // stop iteration in case of stop signal received
+		case uevent := <-queue:
+			t.Log("Handle", uevent.String())
+		case err := <-errors:
+			quit <- struct{}{}
+			t.Fatalf("unable to get existing devices, err: %v", err)
+		}
+	}
+}

netlink/uevent_test.go

@@ -1,6 +1,7 @@
 package netlink
 
 import (
+	"fmt"
 	"runtime"
 	"testing"
 )
@@ -61,7 +62,6 @@ func TestParseUEvent(testing *testing.T) {
 
 	uevent, err := ParseUEvent(raw)
 	t.FatalfIf(err == nil && uevent != nil, "Event parsed successfully but it should be invalid, err: %s", err.Error())
-
 }
 
 func TestParseUdevEvent(testing *testing.T) {
@@ -124,7 +124,9 @@ func TestParseUdevEvent(testing *testing.T) {
 				"USEC_INITIALIZED":               "75223543693",
 				"ID_PCI_INTERFACE_FROM_DATABASE": "XHCI",
 				"ID_SERIAL_SHORT":                "AH06W0EQ",
-			}}}, {
+			},
+		},
+	}, {
 		Input: []byte("libudev\x00\xfe\xed\xca\xfe(\x00\x00\x00(\x00\x00\x00\xf2\x02\x00\x00\x05w\xc5\xe5'\xf8\xf5\f\x00\x00\x00\x00\x00\x00\x00\x00" +
 			"ACTION=add\x00DEVPATH=/devices/pci0000:00/0000:00:14.0/usb1/1-2\x00SUBSYSTEM=usb\x00DEVNAME=/dev/bus/usb/001/033\x00DEVTYPE=usb_device\x00" +
 			"PRODUCT=10c4/ea60/100\x00TYPE=0/0/0\x00BUSNUM=001\x00DEVNUM=033\x00SEQNUM=4410\x00MAJOR=189\x00MINOR=32\x00USEC_INITIALIZED=77155422759\x00" +
@@ -254,43 +256,67 @@ func TestUEventEquality(testing *testing.T) {
 		},
 	}
 
+	uevent5 := UEvent{
+		Action: REMOVE,
+		KObj:   "/devices/pci0000:00/0000:00:14.0/usb2/2-1/2-1:1.2/0003:04F2:0976.0008/hidraw/hidraw5",
+		Env: map[string]string{
+			"ACTION":    "add",
+			"DEVPATH":   "/devices/pci0000:00/0000:00:14.0/usb2/2-1/2-1:1.2/0003:04F2:0976.0008/hidraw/hidraw4",
+			"SUBSYSTEM": "hidraw",
+			"MAJOR":     "247",
+			"MINOR":     "4",
+			"DEVNAME":   "hidraw4",
+			"SEQNUM":    "2569",
+		},
+	}
+
 	// When
 	testcases := []testcase{
 		{
 			object:    uevent1,
 			object2:   uevent1,
 			mustEqual: true,
 		},
-		{
+		{ // wrong env number
 			object:    uevent1,
 			object2:   uevent2,
 			mustEqual: false,
 		},
-		{
+		{ // wrong env number
 			object:    uevent2,
 			object2:   uevent1,
 			mustEqual: false,
 		},
-		{
+		{ // wrong env value
 			object:    uevent1,
 			object2:   uevent3,
 			mustEqual: false,
 		},
-		{
+		{ // wrong env value
 			object:    uevent3,
 			object2:   uevent1,
 			mustEqual: false,
 		},
-		{
+		{ // wrong action
 			object:    uevent1,
 			object2:   uevent4,
 			mustEqual: false,
 		},
-		{
+		{ // wrong action
 			object:    uevent4,
 			object2:   uevent1,
 			mustEqual: false,
 		},
+		{ // wrong kobj
+			object:    uevent4,
+			object2:   uevent5,
+			mustEqual: false,
+		},
+		{ // wrong kobj
+			object:    uevent5,
+			object2:   uevent4,
+			mustEqual: false,
+		},
 	}
 
 	// Then
@@ -299,3 +325,21 @@ func TestUEventEquality(testing *testing.T) {
 		t.FatalfIf(tc.mustEqual != res, "not expected result (test n°%d, got: %t, expected: %t), err: %v", i, res, tc.mustEqual, err)
 	}
 }
+
+func TestParseKObjAction(t *testing.T) {
+	for _, action := range []KObjAction{ADD, REMOVE, CHANGE, MOVE, ONLINE, OFFLINE, BIND, UNBIND} {
+		a, err := ParseKObjAction(action.String())
+		if err != nil {
+			t.Fatalf("Unable to parse KObjAction %s: %v", action.String(), err)
+		}
+		if a != action {
+			t.Fatalf(`action must be equal got: "%s", expected: "%s"`, a.String(), action.String())
+		}
+	}
+
+	fakeKObjAction := "wrong"
+	expectedError := fmt.Errorf("unknow kobject action (got: %s)", fakeKObjAction)
+	if _, err := ParseKObjAction(fakeKObjAction); err.Error() != expectedError.Error() {
+		t.Fatalf("wrong kobj action must be detected, got: %v", err)
+	}
+}