github.com/Prakhar-Agarwal-byte/moby@v0.0.0-20231027092010-a14e3e8ab87e/profiles/seccomp/kernel_linux_test.go (about)

     1  package seccomp
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  )
     7  
     8  func TestGetKernelVersion(t *testing.T) {
     9  	version, err := getKernelVersion()
    10  	if err != nil {
    11  		t.Fatal(err)
    12  	}
    13  	if version == nil {
    14  		t.Fatal("version is nil")
    15  	}
    16  	if version.Kernel == 0 {
    17  		t.Fatal("no kernel version")
    18  	}
    19  }
    20  
    21  // TestParseRelease tests the ParseRelease() function
    22  func TestParseRelease(t *testing.T) {
    23  	tests := []struct {
    24  		in          string
    25  		out         KernelVersion
    26  		expectedErr error
    27  	}{
    28  		{in: "3.8", out: KernelVersion{Kernel: 3, Major: 8}},
    29  		{in: "3.8.0", out: KernelVersion{Kernel: 3, Major: 8}},
    30  		{in: "3.8.0-19-generic", out: KernelVersion{Kernel: 3, Major: 8}},
    31  		{in: "3.4.54.longterm-1", out: KernelVersion{Kernel: 3, Major: 4}},
    32  		{in: "3.10.0-862.2.3.el7.x86_64", out: KernelVersion{Kernel: 3, Major: 10}},
    33  		{in: "3.12.8tag", out: KernelVersion{Kernel: 3, Major: 12}},
    34  		{in: "3.12-1-amd64", out: KernelVersion{Kernel: 3, Major: 12}},
    35  		{in: "3.12foobar", out: KernelVersion{Kernel: 3, Major: 12}},
    36  		{in: "99.999.999-19-generic", out: KernelVersion{Kernel: 99, Major: 999}},
    37  		{in: "", expectedErr: fmt.Errorf(`failed to parse kernel version "": EOF`)},
    38  		{in: "3", expectedErr: fmt.Errorf(`failed to parse kernel version "3": unexpected EOF`)},
    39  		{in: "3.", expectedErr: fmt.Errorf(`failed to parse kernel version "3.": EOF`)},
    40  		{in: "3a", expectedErr: fmt.Errorf(`failed to parse kernel version "3a": input does not match format`)},
    41  		{in: "3.a", expectedErr: fmt.Errorf(`failed to parse kernel version "3.a": expected integer`)},
    42  		{in: "a", expectedErr: fmt.Errorf(`failed to parse kernel version "a": expected integer`)},
    43  		{in: "a.a", expectedErr: fmt.Errorf(`failed to parse kernel version "a.a": expected integer`)},
    44  		{in: "a.a.a-a", expectedErr: fmt.Errorf(`failed to parse kernel version "a.a.a-a": expected integer`)},
    45  		{in: "-3", expectedErr: fmt.Errorf(`failed to parse kernel version "-3": expected integer`)},
    46  		{in: "-3.", expectedErr: fmt.Errorf(`failed to parse kernel version "-3.": expected integer`)},
    47  		{in: "-3.8", expectedErr: fmt.Errorf(`failed to parse kernel version "-3.8": expected integer`)},
    48  		{in: "-3.-8", expectedErr: fmt.Errorf(`failed to parse kernel version "-3.-8": expected integer`)},
    49  		{in: "3.-8", expectedErr: fmt.Errorf(`failed to parse kernel version "3.-8": expected integer`)},
    50  	}
    51  	for _, tc := range tests {
    52  		tc := tc
    53  		t.Run(tc.in, func(t *testing.T) {
    54  			version, err := parseRelease(tc.in)
    55  			if tc.expectedErr != nil {
    56  				if err == nil {
    57  					t.Fatal("expected an error")
    58  				}
    59  				if err.Error() != tc.expectedErr.Error() {
    60  					t.Fatalf("expected: %s, got: %s", tc.expectedErr, err)
    61  				}
    62  				return
    63  			}
    64  			if err != nil {
    65  				t.Fatal("unexpected error:", err)
    66  			}
    67  			if version == nil {
    68  				t.Fatal("version is nil")
    69  			}
    70  			if version.Kernel != tc.out.Kernel || version.Major != tc.out.Major {
    71  				t.Fatalf("expected: %d.%d, got: %d.%d", tc.out.Kernel, tc.out.Major, version.Kernel, version.Major)
    72  			}
    73  		})
    74  	}
    75  }
    76  
    77  func TestKernelGreaterEqualThan(t *testing.T) {
    78  	// Get the current kernel version, so that we can make test relative to that
    79  	v, err := getKernelVersion()
    80  	if err != nil {
    81  		t.Fatal(err)
    82  	}
    83  
    84  	tests := []struct {
    85  		doc      string
    86  		in       KernelVersion
    87  		expected bool
    88  	}{
    89  		{
    90  			doc:      "same version",
    91  			in:       KernelVersion{v.Kernel, v.Major},
    92  			expected: true,
    93  		},
    94  		{
    95  			doc:      "kernel minus one",
    96  			in:       KernelVersion{v.Kernel - 1, v.Major},
    97  			expected: true,
    98  		},
    99  		{
   100  			doc:      "kernel plus one",
   101  			in:       KernelVersion{v.Kernel + 1, v.Major},
   102  			expected: false,
   103  		},
   104  		{
   105  			doc:      "major plus one",
   106  			in:       KernelVersion{v.Kernel, v.Major + 1},
   107  			expected: false,
   108  		},
   109  	}
   110  	for _, tc := range tests {
   111  		tc := tc
   112  		t.Run(tc.doc+": "+tc.in.String(), func(t *testing.T) {
   113  			ok, err := kernelGreaterEqualThan(tc.in)
   114  			if err != nil {
   115  				t.Fatal("unexpected error:", err)
   116  			}
   117  			if ok != tc.expected {
   118  				t.Fatalf("expected: %v, got: %v", tc.expected, ok)
   119  			}
   120  		})
   121  	}
   122  }