go.mondoo.com/cnquery@v0.0.0-20231005093811-59568235f6ea/_motor/platform/detector/detector_test.go (about)

     1  // Copyright (c) Mondoo, Inc.
     2  // SPDX-License-Identifier: BUSL-1.1
     3  
     4  package detector_test
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  	"go.mondoo.com/cnquery/motor/platform"
    12  	"go.mondoo.com/cnquery/motor/platform/detector"
    13  	"go.mondoo.com/cnquery/motor/providers/mock"
    14  )
    15  
    16  func newDetector(filepath string) (*detector.Detector, error) {
    17  	mock, err := mock.NewFromTomlFile(filepath)
    18  	if err != nil {
    19  		return nil, err
    20  	}
    21  	detector := detector.New(mock)
    22  	return detector, nil
    23  }
    24  
    25  func TestRhel6OSDetector(t *testing.T) {
    26  	detector, err := newDetector("./testdata/detect-rhel-6.toml")
    27  	assert.Nil(t, err, "was able to create the provider")
    28  	di, err := detector.Platform()
    29  	require.NoError(t, err)
    30  
    31  	assert.Equal(t, "redhat", di.Name, "os name should be identified")
    32  	assert.Equal(t, "Red Hat Linux", di.Title, "os title should be identified")
    33  	assert.Equal(t, "6.2", di.Version, "os version should be identified")
    34  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
    35  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
    36  }
    37  
    38  func TestRhel7OSDetector(t *testing.T) {
    39  	detector, err := newDetector("./testdata/detect-rhel-7.toml")
    40  	assert.Nil(t, err, "was able to create the provider")
    41  	di, err := detector.Platform()
    42  	require.NoError(t, err)
    43  
    44  	assert.Equal(t, "redhat", di.Name, "os name should be identified")
    45  	assert.Equal(t, "Red Hat Enterprise Linux Server 7.2 (Maipo)", di.Title, "os title should be identified")
    46  	assert.Equal(t, "7.2", di.Version, "os version should be identified")
    47  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
    48  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
    49  }
    50  
    51  func TestRhel7SLESOSDetector(t *testing.T) {
    52  	detector, err := newDetector("./testdata/detect-rhel-7-sles.toml")
    53  	assert.Nil(t, err, "was able to create the provider")
    54  	di, err := detector.Platform()
    55  	require.NoError(t, err)
    56  
    57  	assert.Equal(t, "redhat", di.Name, "os name should be identified")
    58  	assert.Equal(t, "Red Hat Enterprise Linux Server 7.4", di.Title, "os title should be identified")
    59  	assert.Equal(t, "7.4", di.Version, "os version should be identified")
    60  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
    61  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
    62  }
    63  
    64  func TestRhel8OSDetector(t *testing.T) {
    65  	detector, err := newDetector("./testdata/detect-rhel-8.toml")
    66  	assert.Nil(t, err, "was able to create the provider")
    67  	di, err := detector.Platform()
    68  	require.NoError(t, err)
    69  
    70  	assert.Equal(t, "redhat", di.Name, "os name should be identified")
    71  	assert.Equal(t, "Red Hat Enterprise Linux 8.0 (Ootpa)", di.Title, "os title should be identified")
    72  	assert.Equal(t, "8.0", di.Version, "os version should be identified")
    73  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
    74  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
    75  }
    76  
    77  func TestRhel9OSDetector(t *testing.T) {
    78  	detector, err := newDetector("./testdata/detect-rhel-9.toml")
    79  	assert.Nil(t, err, "was able to create the provider")
    80  	di, err := detector.Platform()
    81  	require.NoError(t, err)
    82  
    83  	assert.Equal(t, "redhat", di.Name, "os name should be identified")
    84  	assert.Equal(t, "Red Hat Enterprise Linux 9.0 (Plow)", di.Title, "os title should be identified")
    85  	assert.Equal(t, "9.0", di.Version, "os version should be identified")
    86  	assert.Equal(t, "aarch64", di.Arch, "os arch should be identified")
    87  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
    88  }
    89  
    90  func TestFedora29OSDetector(t *testing.T) {
    91  	detector, err := newDetector("./testdata/detect-fedora29.toml")
    92  	assert.Nil(t, err, "was able to create the provider")
    93  	di, err := detector.Platform()
    94  	require.NoError(t, err)
    95  
    96  	assert.Equal(t, "fedora", di.Name, "os name should be identified")
    97  	assert.Equal(t, "Fedora 29 (Container Image)", di.Title, "os title should be identified")
    98  	assert.Equal(t, "29", di.Version, "os version should be identified")
    99  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   100  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   101  }
   102  
   103  func TestFedoraCoreOSDetector(t *testing.T) {
   104  	detector, err := newDetector("./testdata/detect-coreos-fedora.toml")
   105  	assert.Nil(t, err, "was able to create the provider")
   106  	di, err := detector.Platform()
   107  	require.NoError(t, err)
   108  
   109  	assert.Equal(t, "fedora", di.Name, "os name should be identified")
   110  	assert.Equal(t, "Fedora CoreOS 31.20200310.3.0", di.Title, "os title should be identified")
   111  	assert.Equal(t, "31", di.Version, "os version should be identified")
   112  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   113  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   114  }
   115  
   116  func TestCoreOSDetector(t *testing.T) {
   117  	detector, err := newDetector("./testdata/detect-coreos.toml")
   118  	assert.Nil(t, err, "was able to create the provider")
   119  	di, err := detector.Platform()
   120  	require.NoError(t, err)
   121  
   122  	assert.Equal(t, "flatcar", di.Name, "os name should be identified")
   123  	assert.Equal(t, "Flatcar Container Linux by Kinvolk 2430.0.0 (Rhyolite)", di.Title, "os title should be identified")
   124  	assert.Equal(t, "2430.0.0", di.Version, "os version should be identified")
   125  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   126  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   127  }
   128  
   129  func TestCentos5Detector(t *testing.T) {
   130  	detector, err := newDetector("./testdata/detect-centos-5.toml")
   131  	assert.Nil(t, err, "was able to create the provider")
   132  	di, err := detector.Platform()
   133  	require.NoError(t, err)
   134  
   135  	assert.Equal(t, "centos", di.Name, "os name should be identified")
   136  	assert.Equal(t, "CentOS", di.Title, "os title should be identified")
   137  	assert.Equal(t, "5.11", di.Version, "os version should be identified")
   138  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   139  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   140  }
   141  
   142  func TestCentos6Detector(t *testing.T) {
   143  	detector, err := newDetector("./testdata/detect-centos-6.toml")
   144  	assert.Nil(t, err, "was able to create the provider")
   145  	di, err := detector.Platform()
   146  	require.NoError(t, err)
   147  
   148  	assert.Equal(t, "centos", di.Name, "os name should be identified")
   149  	assert.Equal(t, "CentOS", di.Title, "os title should be identified")
   150  	assert.Equal(t, "6.9", di.Version, "os version should be identified")
   151  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   152  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   153  }
   154  
   155  func TestCentos7OSDetector(t *testing.T) {
   156  	detector, err := newDetector("./testdata/detect-centos-7.toml")
   157  	assert.Nil(t, err, "was able to create the provider")
   158  	di, err := detector.Platform()
   159  	require.NoError(t, err)
   160  
   161  	assert.Equal(t, "centos", di.Name, "os name should be identified")
   162  	assert.Equal(t, "CentOS Linux 7 (Core)", di.Title, "os title should be identified")
   163  	assert.Equal(t, "7.5.1804", di.Version, "os version should be identified")
   164  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   165  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   166  }
   167  
   168  func TestCentos8OSDetector(t *testing.T) {
   169  	detector, err := newDetector("./testdata/detect-centos-8.toml")
   170  	assert.Nil(t, err, "was able to create the provider")
   171  	di, err := detector.Platform()
   172  	require.NoError(t, err)
   173  
   174  	assert.Equal(t, "centos", di.Name, "os name should be identified")
   175  	assert.Equal(t, "CentOS Linux 8 (Core)", di.Title, "os title should be identified")
   176  	assert.Equal(t, "8.2.2004", di.Version, "os version should be identified")
   177  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   178  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   179  }
   180  
   181  func TestCentos8StreamOSDetector(t *testing.T) {
   182  	detector, err := newDetector("./testdata/detect-centos-8-stream.toml")
   183  	assert.Nil(t, err, "was able to create the provider")
   184  	di, err := detector.Platform()
   185  	require.NoError(t, err)
   186  
   187  	assert.Equal(t, "centos", di.Name, "os name should be identified")
   188  	assert.Equal(t, "CentOS Stream 8", di.Title, "os title should be identified")
   189  	assert.Equal(t, "8", di.Version, "os version should be identified")
   190  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   191  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   192  }
   193  
   194  func TestCentos9StreamOSDetector(t *testing.T) {
   195  	detector, err := newDetector("./testdata/detect-centos-9-stream.toml")
   196  	assert.Nil(t, err, "was able to create the provider")
   197  	di, err := detector.Platform()
   198  	require.NoError(t, err)
   199  
   200  	assert.Equal(t, "centos", di.Name, "os name should be identified")
   201  	assert.Equal(t, "CentOS Stream 9", di.Title, "os title should be identified")
   202  	assert.Equal(t, "9", di.Version, "os version should be identified")
   203  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   204  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   205  }
   206  
   207  func TestAlmaLinux8OSDetector(t *testing.T) {
   208  	detector, err := newDetector("./testdata/detect-almalinux-8.toml")
   209  	assert.Nil(t, err, "was able to create the provider")
   210  	di, err := detector.Platform()
   211  	require.NoError(t, err)
   212  
   213  	assert.Equal(t, "almalinux", di.Name, "os name should be identified")
   214  	assert.Equal(t, "AlmaLinux 8.3 Beta (Purple Manul)", di.Title, "os title should be identified")
   215  	assert.Equal(t, "8.3", di.Version, "os version should be identified")
   216  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   217  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   218  }
   219  
   220  func TestAlmaLinux9OSDetector(t *testing.T) {
   221  	detector, err := newDetector("./testdata/detect-almalinux-9.toml")
   222  	assert.Nil(t, err, "was able to create the provider")
   223  	di, err := detector.Platform()
   224  	require.NoError(t, err)
   225  
   226  	assert.Equal(t, "almalinux", di.Name, "os name should be identified")
   227  	assert.Equal(t, "AlmaLinux 9.0 Beta (Emerald Puma)", di.Title, "os title should be identified")
   228  	assert.Equal(t, "9.0", di.Version, "os version should be identified")
   229  	assert.Equal(t, "aarch64", di.Arch, "os arch should be identified")
   230  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   231  }
   232  
   233  func TestRockyLinux8OSDetector(t *testing.T) {
   234  	detector, err := newDetector("./testdata/detect-rocky-linux-8.toml")
   235  	assert.Nil(t, err, "was able to create the provider")
   236  	di, err := detector.Platform()
   237  	require.NoError(t, err)
   238  
   239  	assert.Equal(t, "rockylinux", di.Name, "os name should be identified")
   240  	assert.Equal(t, "Rocky Linux 8.5 (Green Obsidian)", di.Title, "os title should be identified")
   241  	assert.Equal(t, "8.5", di.Version, "os version should be identified")
   242  	assert.Equal(t, "aarch64", di.Arch, "os arch should be identified")
   243  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   244  }
   245  
   246  func TestRockyLinux9OSDetector(t *testing.T) {
   247  	detector, err := newDetector("./testdata/detect-rocky-linux-9.toml")
   248  	assert.Nil(t, err, "was able to create the provider")
   249  	di, err := detector.Platform()
   250  	require.NoError(t, err)
   251  
   252  	assert.Equal(t, "rockylinux", di.Name, "os name should be identified")
   253  	assert.Equal(t, "Rocky Linux 9.0 (Blue Onyx)", di.Title, "os title should be identified")
   254  	assert.Equal(t, "9.0", di.Version, "os version should be identified")
   255  	assert.Equal(t, "aarch64", di.Arch, "os arch should be identified")
   256  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   257  }
   258  
   259  func TestEuroLinux7OSDetector(t *testing.T) {
   260  	detector, err := newDetector("./testdata/detect-eurolinux-7.toml")
   261  	assert.Nil(t, err, "was able to create the provider")
   262  	di, err := detector.Platform()
   263  	require.NoError(t, err)
   264  
   265  	assert.Equal(t, "eurolinux", di.Name, "os name should be identified")
   266  	assert.Equal(t, "EuroLinux 7.9 (Minsk)", di.Title, "os title should be identified")
   267  	assert.Equal(t, "7.9", di.Version, "os version should be identified")
   268  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   269  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   270  }
   271  
   272  func TestEuroLinux8OSDetector(t *testing.T) {
   273  	detector, err := newDetector("./testdata/detect-eurolinux-8.toml")
   274  	assert.Nil(t, err, "was able to create the provider")
   275  	di, err := detector.Platform()
   276  	require.NoError(t, err)
   277  
   278  	assert.Equal(t, "eurolinux", di.Name, "os name should be identified")
   279  	assert.Equal(t, "EuroLinux 8.7 (Brussels)", di.Title, "os title should be identified")
   280  	assert.Equal(t, "8.7", di.Version, "os version should be identified")
   281  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   282  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   283  }
   284  
   285  func TestEuroLinux9OSDetector(t *testing.T) {
   286  	detector, err := newDetector("./testdata/detect-eurolinux-9.toml")
   287  	assert.Nil(t, err, "was able to create the provider")
   288  	di, err := detector.Platform()
   289  	require.NoError(t, err)
   290  
   291  	assert.Equal(t, "eurolinux", di.Name, "os name should be identified")
   292  	assert.Equal(t, "EuroLinux 9.1 (Stockholm)", di.Title, "os title should be identified")
   293  	assert.Equal(t, "9.1", di.Version, "os version should be identified")
   294  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   295  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   296  }
   297  
   298  func TestUbuntu1204Detector(t *testing.T) {
   299  	detector, err := newDetector("./testdata/detect-ubuntu1204.toml")
   300  	assert.Nil(t, err, "was able to create the provider")
   301  	di, err := detector.Platform()
   302  	require.NoError(t, err)
   303  
   304  	assert.Equal(t, "ubuntu", di.Name, "os name should be identified")
   305  	assert.Equal(t, "Ubuntu precise (12.04.5 LTS)", di.Title, "os title should be identified")
   306  	assert.Equal(t, "12.04", di.Version, "os version should be identified")
   307  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   308  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   309  }
   310  
   311  func TestUbuntu1404Detector(t *testing.T) {
   312  	detector, err := newDetector("./testdata/detect-ubuntu1404.toml")
   313  	assert.Nil(t, err, "was able to create the provider")
   314  	di, err := detector.Platform()
   315  	require.NoError(t, err)
   316  
   317  	assert.Equal(t, "ubuntu", di.Name, "os name should be identified")
   318  	assert.Equal(t, "Ubuntu 14.04.6 LTS", di.Title, "os title should be identified")
   319  	assert.Equal(t, "14.04", di.Version, "os version should be identified")
   320  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   321  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   322  }
   323  
   324  func TestUbuntu1604Detector(t *testing.T) {
   325  	detector, err := newDetector("./testdata/detect-ubuntu1604.toml")
   326  	assert.Nil(t, err, "was able to create the provider")
   327  	di, err := detector.Platform()
   328  	require.NoError(t, err)
   329  
   330  	assert.Equal(t, "ubuntu", di.Name, "os name should be identified")
   331  	assert.Equal(t, "Ubuntu 16.04.4 LTS", di.Title, "os title should be identified")
   332  	assert.Equal(t, "16.04", di.Version, "os version should be identified")
   333  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   334  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   335  }
   336  
   337  func TestUbuntu1804Detector(t *testing.T) {
   338  	detector, err := newDetector("./testdata/detect-ubuntu1804.toml")
   339  	assert.Nil(t, err, "was able to create the provider")
   340  	di, err := detector.Platform()
   341  	require.NoError(t, err)
   342  
   343  	assert.Equal(t, "ubuntu", di.Name, "os name should be identified")
   344  	assert.Equal(t, "Ubuntu 18.04.3 LTS", di.Title, "os title should be identified")
   345  	assert.Equal(t, "18.04", di.Version, "os version should be identified")
   346  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   347  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   348  }
   349  
   350  func TestUbuntu2004Detector(t *testing.T) {
   351  	detector, err := newDetector("./testdata/detect-ubuntu2004.toml")
   352  	assert.Nil(t, err, "was able to create the provider")
   353  	di, err := detector.Platform()
   354  	require.NoError(t, err)
   355  
   356  	assert.Equal(t, "ubuntu", di.Name, "os name should be identified")
   357  	assert.Equal(t, "Ubuntu Focal Fossa (development branch)", di.Title, "os title should be identified")
   358  	assert.Equal(t, "20.04", di.Version, "os version should be identified")
   359  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   360  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   361  }
   362  
   363  func TestUbuntu2204Detector(t *testing.T) {
   364  	detector, err := newDetector("./testdata/detect-ubuntu2204.toml")
   365  	assert.Nil(t, err, "was able to create the provider")
   366  	di, err := detector.Platform()
   367  	require.NoError(t, err)
   368  
   369  	assert.Equal(t, "ubuntu", di.Name, "os name should be identified")
   370  	assert.Equal(t, "Ubuntu Jammy Jellyfish (development branch)", di.Title, "os title should be identified")
   371  	assert.Equal(t, "22.04", di.Version, "os version should be identified")
   372  	assert.Equal(t, "aarch64", di.Arch, "os arch should be identified")
   373  }
   374  
   375  func TestPoposDetector(t *testing.T) {
   376  	detector, err := newDetector("./testdata/detect-popos.toml")
   377  	assert.Nil(t, err, "was able to create the provider")
   378  	di, err := detector.Platform()
   379  	require.NoError(t, err)
   380  
   381  	assert.Equal(t, "pop", di.Name, "os name should be identified")
   382  	assert.Equal(t, "Pop!_OS 20.04 LTS", di.Title, "os title should be identified")
   383  	assert.Equal(t, "20.04", di.Version, "os version should be identified")
   384  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   385  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   386  }
   387  
   388  func TestWindriver7Detector(t *testing.T) {
   389  	detector, err := newDetector("./testdata/detect-windriver7.toml")
   390  	assert.Nil(t, err, "was able to create the provider")
   391  	di, err := detector.Platform()
   392  	require.NoError(t, err)
   393  
   394  	assert.Equal(t, "wrlinux", di.Name, "os name should be identified")
   395  	assert.Equal(t, "Wind River Linux 7.0.0.2", di.Title, "os title should be identified")
   396  	assert.Equal(t, "7.0.0.2", di.Version, "os version should be identified")
   397  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   398  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   399  }
   400  
   401  func TestOpenWrtDetector(t *testing.T) {
   402  	detector, err := newDetector("./testdata/detect-openwrt.toml")
   403  	assert.Nil(t, err, "was able to create the provider")
   404  	di, err := detector.Platform()
   405  	require.NoError(t, err)
   406  
   407  	assert.Equal(t, "openwrt", di.Name, "os name should be identified")
   408  	assert.Equal(t, "OpenWrt", di.Title, "os title should be identified")
   409  	assert.Equal(t, "Bleeding Edge", di.Version, "os version should be identified")
   410  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   411  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   412  }
   413  
   414  func TestDebian7Detector(t *testing.T) {
   415  	detector, err := newDetector("./testdata/detect-debian7.toml")
   416  	assert.Nil(t, err, "was able to create the provider")
   417  	di, err := detector.Platform()
   418  	require.NoError(t, err)
   419  
   420  	assert.Equal(t, "debian", di.Name, "os name should be identified")
   421  	assert.Equal(t, "Debian GNU/Linux 7 (wheezy)", di.Title, "os title should be identified")
   422  	assert.Equal(t, "7.11", di.Version, "os version should be identified")
   423  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   424  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   425  }
   426  
   427  func TestDebian8Detector(t *testing.T) {
   428  	detector, err := newDetector("./testdata/detect-debian8.toml")
   429  	assert.Nil(t, err, "was able to create the provider")
   430  	di, err := detector.Platform()
   431  	require.NoError(t, err)
   432  
   433  	assert.Equal(t, "debian", di.Name, "os name should be identified")
   434  	assert.Equal(t, "Debian GNU/Linux 8 (jessie)", di.Title, "os title should be identified")
   435  	assert.Equal(t, "8.11", di.Version, "os version should be identified")
   436  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   437  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   438  }
   439  
   440  func TestDebian9Detector(t *testing.T) {
   441  	detector, err := newDetector("./testdata/detect-debian9.toml")
   442  	assert.Nil(t, err, "was able to create the provider")
   443  	di, err := detector.Platform()
   444  	require.NoError(t, err)
   445  
   446  	assert.Equal(t, "debian", di.Name, "os name should be identified")
   447  	assert.Equal(t, "Debian GNU/Linux 9 (stretch)", di.Title, "os title should be identified")
   448  	assert.Equal(t, "9.4", di.Version, "os version should be identified")
   449  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   450  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   451  }
   452  
   453  func TestDebian10Detector(t *testing.T) {
   454  	detector, err := newDetector("./testdata/detect-debian10.toml")
   455  	assert.Nil(t, err, "was able to create the provider")
   456  	di, err := detector.Platform()
   457  	require.NoError(t, err)
   458  
   459  	assert.Equal(t, "debian", di.Name, "os name should be identified")
   460  	assert.Equal(t, "Debian GNU/Linux 10 (buster)", di.Title, "os title should be identified")
   461  	assert.Equal(t, "10.0", di.Version, "os version should be identified")
   462  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   463  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   464  }
   465  
   466  func TestRaspian10Detector(t *testing.T) {
   467  	detector, err := newDetector("./testdata/detect-raspbian.toml")
   468  	assert.Nil(t, err, "was able to create the provider")
   469  	di, err := detector.Platform()
   470  	require.NoError(t, err)
   471  
   472  	assert.Equal(t, "raspbian", di.Name, "os name should be identified")
   473  	assert.Equal(t, "Raspbian GNU/Linux 10 (buster)", di.Title, "os title should be identified")
   474  	assert.Equal(t, "10", di.Version, "os version should be identified")
   475  	assert.Equal(t, "armv7l", di.Arch, "os arch should be identified")
   476  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   477  }
   478  
   479  func TestKaliRollingDetector(t *testing.T) {
   480  	detector, err := newDetector("./testdata/detect-kalirolling.toml")
   481  	assert.Nil(t, err, "was able to create the provider")
   482  	di, err := detector.Platform()
   483  	require.NoError(t, err)
   484  
   485  	assert.Equal(t, "kali", di.Name, "os name should be identified")
   486  	assert.Equal(t, "Kali GNU/Linux Rolling", di.Title, "os title should be identified")
   487  	assert.Equal(t, "2019.4", di.Version, "os version should be identified")
   488  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   489  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   490  }
   491  
   492  func TestOpenSuse13Detector(t *testing.T) {
   493  	detector, err := newDetector("./testdata/detect-opensuse-13.toml")
   494  	assert.Nil(t, err, "was able to create the provider")
   495  	di, err := detector.Platform()
   496  	require.NoError(t, err)
   497  
   498  	assert.Equal(t, "opensuse", di.Name, "os name should be identified")
   499  	assert.Equal(t, "openSUSE 13.2 (Harlequin) (x86_64)", di.Title, "os title should be identified")
   500  	assert.Equal(t, "13.2", di.Version, "os version should be identified")
   501  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   502  	assert.Equal(t, []string{"suse", "linux", "unix", "os"}, di.Family)
   503  }
   504  
   505  func TestOpenSuseLeap42Detector(t *testing.T) {
   506  	detector, err := newDetector("./testdata/detect-opensuse-leap-42.3.toml")
   507  	assert.Nil(t, err, "was able to create the provider")
   508  	di, err := detector.Platform()
   509  	require.NoError(t, err)
   510  
   511  	assert.Equal(t, "opensuse", di.Name, "os name should be identified")
   512  	assert.Equal(t, "openSUSE Leap 42.3", di.Title, "os title should be identified")
   513  	assert.Equal(t, "42.3", di.Version, "os version should be identified")
   514  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   515  	assert.Equal(t, []string{"suse", "linux", "unix", "os"}, di.Family)
   516  }
   517  
   518  func TestOpenSuseLeap15Detector(t *testing.T) {
   519  	detector, err := newDetector("./testdata/detect-opensuse-leap-15.toml")
   520  	assert.Nil(t, err, "was able to create the provider")
   521  	di, err := detector.Platform()
   522  	require.NoError(t, err)
   523  
   524  	assert.Equal(t, "opensuse-leap", di.Name, "os name should be identified")
   525  	assert.Equal(t, "openSUSE Leap 15.0", di.Title, "os title should be identified")
   526  	assert.Equal(t, "15.0", di.Version, "os version should be identified")
   527  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   528  	assert.Equal(t, []string{"suse", "linux", "unix", "os"}, di.Family)
   529  }
   530  
   531  func TestOpenSuseTumbleweedDetector(t *testing.T) {
   532  	detector, err := newDetector("./testdata/detect-opensuse-tumbleweed.toml")
   533  	assert.Nil(t, err, "was able to create the provider")
   534  	di, err := detector.Platform()
   535  	require.NoError(t, err)
   536  
   537  	assert.Equal(t, "opensuse-tumbleweed", di.Name, "os name should be identified")
   538  	assert.Equal(t, "openSUSE Tumbleweed", di.Title, "os title should be identified")
   539  	assert.Equal(t, "20200305", di.Version, "os version should be identified")
   540  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   541  	assert.Equal(t, []string{"suse", "linux", "unix", "os"}, di.Family)
   542  }
   543  
   544  func TestSuse12Detector(t *testing.T) {
   545  	detector, err := newDetector("./testdata/detect-suse-sles-12.toml")
   546  	assert.Nil(t, err, "was able to create the provider")
   547  	di, err := detector.Platform()
   548  	require.NoError(t, err)
   549  
   550  	assert.Equal(t, "sles", di.Name, "os name should be identified")
   551  	assert.Equal(t, "SUSE Linux Enterprise Server 12 SP3", di.Title, "os title should be identified")
   552  	assert.Equal(t, "12.3", di.Version, "os version should be identified")
   553  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   554  	assert.Equal(t, []string{"suse", "linux", "unix", "os"}, di.Family)
   555  }
   556  
   557  func TestSuse125Detector(t *testing.T) {
   558  	detector, err := newDetector("./testdata/detect-suse-sles-12.5.toml")
   559  	assert.Nil(t, err, "was able to create the provider")
   560  	di, err := detector.Platform()
   561  	require.NoError(t, err)
   562  
   563  	assert.Equal(t, "sles", di.Name, "os name should be identified")
   564  	assert.Equal(t, "SUSE Linux Enterprise Server 12 SP5", di.Title, "os title should be identified")
   565  	assert.Equal(t, "12.5", di.Version, "os version should be identified")
   566  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   567  	assert.Equal(t, []string{"suse", "linux", "unix", "os"}, di.Family)
   568  }
   569  
   570  func TestSuse15Detector(t *testing.T) {
   571  	detector, err := newDetector("./testdata/detect-suse-sles-15.toml")
   572  	assert.Nil(t, err, "was able to create the provider")
   573  	di, err := detector.Platform()
   574  	require.NoError(t, err)
   575  
   576  	assert.Equal(t, "sles", di.Name, "os name should be identified")
   577  	assert.Equal(t, "SUSE Linux Enterprise Server 15 SP1", di.Title, "os title should be identified")
   578  	assert.Equal(t, "15.1", di.Version, "os version should be identified")
   579  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   580  	assert.Equal(t, []string{"suse", "linux", "unix", "os"}, di.Family)
   581  }
   582  
   583  func TestSuse5MicroDetector(t *testing.T) {
   584  	detector, err := newDetector("./testdata/detect-suse-micro-5.toml")
   585  	assert.Nil(t, err, "was able to create the provider")
   586  	di, err := detector.Platform()
   587  	require.NoError(t, err)
   588  
   589  	assert.Equal(t, "suse-microos", di.Name, "os name should be identified")
   590  	assert.Equal(t, "SUSE Linux Enterprise Micro 5.1", di.Title, "os title should be identified")
   591  	assert.Equal(t, "5.1", di.Version, "os version should be identified")
   592  	assert.Equal(t, "aarch64", di.Arch, "os arch should be identified")
   593  	assert.Equal(t, []string{"suse", "linux", "unix", "os"}, di.Family)
   594  }
   595  
   596  func TestAmazon1LinuxDetector(t *testing.T) {
   597  	detector, err := newDetector("./testdata/detect-amazonlinux-2017.09.toml")
   598  	assert.Nil(t, err, "was able to create the provider")
   599  	di, err := detector.Platform()
   600  	require.NoError(t, err)
   601  
   602  	assert.Equal(t, "amazonlinux", di.Name, "os name should be identified")
   603  	assert.Equal(t, "Amazon Linux AMI 2017.09", di.Title, "os title should be identified")
   604  	assert.Equal(t, "2017.09", di.Version, "os version should be identified")
   605  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   606  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   607  }
   608  
   609  func TestAmazon2LinuxDetector(t *testing.T) {
   610  	detector, err := newDetector("./testdata/detect-amzn-2.toml")
   611  	assert.Nil(t, err, "was able to create the provider")
   612  	di, err := detector.Platform()
   613  	require.NoError(t, err)
   614  
   615  	assert.Equal(t, "amazonlinux", di.Name, "os name should be identified")
   616  	assert.Equal(t, "Amazon Linux 2", di.Title, "os title should be identified")
   617  	assert.Equal(t, "2", di.Version, "os version should be identified")
   618  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   619  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   620  }
   621  
   622  func TestAmazon2022LinuxDetector(t *testing.T) {
   623  	detector, err := newDetector("./testdata/detect-amzn-2022.toml")
   624  	assert.Nil(t, err, "was able to create the provider")
   625  	di, err := detector.Platform()
   626  	require.NoError(t, err)
   627  
   628  	assert.Equal(t, "amazonlinux", di.Name, "os name should be identified")
   629  	assert.Equal(t, "Amazon Linux 2022", di.Title, "os title should be identified")
   630  	assert.Equal(t, "2022", di.Version, "os version should be identified")
   631  	assert.Equal(t, "aarch64", di.Arch, "os arch should be identified")
   632  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   633  }
   634  
   635  func TestScientificLinuxDetector(t *testing.T) {
   636  	detector, err := newDetector("./testdata/detect-scientific.toml")
   637  	assert.Nil(t, err, "was able to create the provider")
   638  	di, err := detector.Platform()
   639  	require.NoError(t, err)
   640  
   641  	assert.Equal(t, "scientific", di.Name, "os name should be identified")
   642  	assert.Equal(t, "Scientific Linux CERN SLC", di.Title, "os title should be identified")
   643  	assert.Equal(t, "6.9", di.Version, "os version should be identified")
   644  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   645  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   646  }
   647  
   648  func TestArchLinuxVmDetector(t *testing.T) {
   649  	detector, err := newDetector("./testdata/detect-arch-vm.toml")
   650  	assert.Nil(t, err, "was able to create the provider")
   651  	di, err := detector.Platform()
   652  	require.NoError(t, err)
   653  
   654  	assert.Equal(t, "arch", di.Name, "os name should be identified")
   655  	assert.Equal(t, "Arch Linux", di.Title, "os title should be identified")
   656  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   657  	assert.Equal(t, []string{"arch", "linux", "unix", "os"}, di.Family)
   658  }
   659  
   660  func TestArchLinuxContainerDetector(t *testing.T) {
   661  	detector, err := newDetector("./testdata/detect-arch-container.toml")
   662  	assert.Nil(t, err, "was able to create the provider")
   663  	di, err := detector.Platform()
   664  	require.NoError(t, err)
   665  
   666  	assert.Equal(t, "arch", di.Name, "os name should be identified")
   667  	assert.Equal(t, "Arch Linux", di.Title, "os title should be identified")
   668  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   669  	assert.Equal(t, []string{"arch", "linux", "unix", "os"}, di.Family)
   670  }
   671  
   672  func TestManjaroLinuxContainerDetector(t *testing.T) {
   673  	detector, err := newDetector("./testdata/detect-manjaro.toml")
   674  	assert.Nil(t, err, "was able to create the provider")
   675  	di, err := detector.Platform()
   676  	require.NoError(t, err)
   677  
   678  	assert.Equal(t, "manjaro", di.Name, "os name should be identified")
   679  	assert.Equal(t, "Manjaro Linux", di.Title, "os title should be identified")
   680  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   681  	assert.Equal(t, []string{"arch", "linux", "unix", "os"}, di.Family)
   682  }
   683  
   684  func TestOracleLinux6Detector(t *testing.T) {
   685  	detector, err := newDetector("./testdata/detect-oracle6.toml")
   686  	assert.Nil(t, err, "was able to create the provider")
   687  	di, err := detector.Platform()
   688  	require.NoError(t, err)
   689  
   690  	assert.Equal(t, "oraclelinux", di.Name, "os name should be identified")
   691  	assert.Equal(t, "Oracle Linux Server 6.9", di.Title, "os title should be identified")
   692  	assert.Equal(t, "6.9", di.Version, "os version should be identified")
   693  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   694  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   695  }
   696  
   697  func TestOracleLinux7Detector(t *testing.T) {
   698  	detector, err := newDetector("./testdata/detect-oracle7.toml")
   699  	assert.Nil(t, err, "was able to create the provider")
   700  	di, err := detector.Platform()
   701  	require.NoError(t, err)
   702  
   703  	assert.Equal(t, "oraclelinux", di.Name, "os name should be identified")
   704  	assert.Equal(t, "Oracle Linux Server 7.5", di.Title, "os title should be identified")
   705  	assert.Equal(t, "7.5", di.Version, "os version should be identified")
   706  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   707  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   708  }
   709  
   710  func TestOracleLinux8Detector(t *testing.T) {
   711  	detector, err := newDetector("./testdata/detect-oracle8.toml")
   712  	assert.Nil(t, err, "was able to create the provider")
   713  	di, err := detector.Platform()
   714  	require.NoError(t, err)
   715  
   716  	assert.Equal(t, "oraclelinux", di.Name, "os name should be identified")
   717  	assert.Equal(t, "Oracle Linux Server 8.0", di.Title, "os title should be identified")
   718  	assert.Equal(t, "8.0", di.Version, "os version should be identified")
   719  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   720  	assert.Equal(t, []string{"redhat", "linux", "unix", "os"}, di.Family)
   721  }
   722  
   723  func TestGentooLinuxDetector(t *testing.T) {
   724  	detector, err := newDetector("./testdata/detect-gentoo.toml")
   725  	assert.Nil(t, err, "was able to create the provider")
   726  	di, err := detector.Platform()
   727  	require.NoError(t, err)
   728  
   729  	assert.Equal(t, "gentoo", di.Name, "os name should be identified")
   730  	assert.Equal(t, "Gentoo/Linux", di.Title, "os title should be identified")
   731  	assert.Equal(t, "2.4.1", di.Version, "os version should be identified")
   732  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   733  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   734  }
   735  
   736  func TestAlpineLinuxDetector(t *testing.T) {
   737  	detector, err := newDetector("./testdata/detect-alpine.toml")
   738  	assert.Nil(t, err, "was able to create the provider")
   739  	di, err := detector.Platform()
   740  	require.NoError(t, err)
   741  
   742  	assert.Equal(t, "alpine", di.Name, "os name should be identified")
   743  	assert.Equal(t, "Alpine Linux v3.7", di.Title, "os title should be identified")
   744  	assert.Equal(t, "3.7.0", di.Version, "os version should be identified")
   745  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   746  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   747  }
   748  
   749  func TestAlpineEdgeLinuxDetector(t *testing.T) {
   750  	detector, err := newDetector("./testdata/detect-alpine-edge.toml")
   751  	assert.Nil(t, err, "was able to create the provider")
   752  	di, err := detector.Platform()
   753  	require.NoError(t, err)
   754  
   755  	assert.Equal(t, "alpine", di.Name, "os name should be identified")
   756  	assert.Equal(t, "Alpine Linux edge", di.Title, "os title should be identified")
   757  	assert.Equal(t, "edge", di.Version, "os version should be identified")
   758  	assert.Equal(t, "3.13.0_alpha20201218", di.Build, "os build should be identified")
   759  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   760  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   761  }
   762  
   763  func TestBusyboxLinuxDetector(t *testing.T) {
   764  	detector, err := newDetector("./testdata/detect-busybox.toml")
   765  	assert.Nil(t, err, "was able to create the provider")
   766  	di, err := detector.Platform()
   767  	require.NoError(t, err)
   768  
   769  	assert.Equal(t, "busybox", di.Name, "os name should be identified")
   770  	assert.Equal(t, "BusyBox", di.Title, "os title should be identified")
   771  	assert.Equal(t, "v1.34.1", di.Version, "os version should be identified")
   772  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   773  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   774  }
   775  
   776  func TestPlcNextLinuxDetector(t *testing.T) {
   777  	detector, err := newDetector("./testdata/detect-plcnext.toml")
   778  	assert.Nil(t, err, "was able to create the provider")
   779  	di, err := detector.Platform()
   780  	require.NoError(t, err)
   781  
   782  	assert.Equal(t, "plcnext", di.Name, "os name should be identified")
   783  	assert.Equal(t, "PLCnext", di.Title, "os title should be identified")
   784  	assert.Equal(t, "23.0.0.65", di.Version, "os version should be identified")
   785  	assert.Equal(t, "d755854b5b21ecb8dca26b0a560e6842a0c638d7", di.Build, "os build version should be identified")
   786  	assert.Equal(t, "armv7l", di.Arch, "os arch should be identified")
   787  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   788  }
   789  
   790  func TestWindows2016Detector(t *testing.T) {
   791  	detector, err := newDetector("./testdata/detect-windows2016.toml")
   792  	assert.Nil(t, err, "was able to create the provider")
   793  	di, err := detector.Platform()
   794  	require.NoError(t, err)
   795  
   796  	assert.Equal(t, "windows", di.Name, "os name should be identified")
   797  	assert.Equal(t, "Microsoft Windows Server 2016 Standard Evaluation", di.Title, "os title should be identified")
   798  	assert.Equal(t, "14393", di.Version, "os version should be identified")
   799  	assert.Equal(t, "64-bit", di.Arch, "os arch should be identified")
   800  	assert.Equal(t, []string{"windows", "os"}, di.Family)
   801  }
   802  
   803  func TestWindows2019Detector(t *testing.T) {
   804  	detector, err := newDetector("./testdata/detect-windows2019.toml")
   805  	assert.Nil(t, err, "was able to create the provider")
   806  	di, err := detector.Platform()
   807  	require.NoError(t, err)
   808  
   809  	assert.Equal(t, "windows", di.Name, "os name should be identified")
   810  	assert.Equal(t, "Microsoft Windows Server 2019 Datacenter Evaluation", di.Title, "os title should be identified")
   811  	assert.Equal(t, "17763", di.Version, "os version should be identified")
   812  	assert.Equal(t, "720", di.Build, "os build version should be identified")
   813  	assert.Equal(t, "64-bit", di.Arch, "os arch should be identified")
   814  	assert.Equal(t, []string{"windows", "os"}, di.Family)
   815  }
   816  
   817  func TestPhoton1Detector(t *testing.T) {
   818  	detector, err := newDetector("./testdata/detect-photon1.toml")
   819  	assert.Nil(t, err, "was able to create the provider")
   820  	di, err := detector.Platform()
   821  	require.NoError(t, err)
   822  
   823  	assert.Equal(t, "photon", di.Name, "os name should be identified")
   824  	assert.Equal(t, "VMware Photon/Linux", di.Title, "os title should be identified")
   825  	assert.Equal(t, "1.0", di.Version, "os version should be identified")
   826  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   827  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   828  }
   829  
   830  func TestPhoton2Detector(t *testing.T) {
   831  	detector, err := newDetector("./testdata/detect-photon2.toml")
   832  	assert.Nil(t, err, "was able to create the provider")
   833  	di, err := detector.Platform()
   834  	require.NoError(t, err)
   835  
   836  	assert.Equal(t, "photon", di.Name, "os name should be identified")
   837  	assert.Equal(t, "VMware Photon OS/Linux", di.Title, "os title should be identified")
   838  	assert.Equal(t, "2.0", di.Version, "os version should be identified")
   839  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   840  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   841  }
   842  
   843  func TestPhoton3Detector(t *testing.T) {
   844  	detector, err := newDetector("./testdata/detect-photon3.toml")
   845  	assert.Nil(t, err, "was able to create the provider")
   846  	di, err := detector.Platform()
   847  	require.NoError(t, err)
   848  
   849  	assert.Equal(t, "photon", di.Name, "os name should be identified")
   850  	assert.Equal(t, "VMware Photon OS/Linux", di.Title, "os title should be identified")
   851  	assert.Equal(t, "3.0", di.Version, "os version should be identified")
   852  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   853  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   854  }
   855  
   856  func TestMacOSsDetector(t *testing.T) {
   857  	detector, err := newDetector("./testdata/detect-macos.toml")
   858  	assert.Nil(t, err, "was able to create the provider")
   859  	di, err := detector.Platform()
   860  	require.NoError(t, err)
   861  
   862  	assert.Equal(t, "macos", di.Name, "os name should be identified")
   863  	assert.Equal(t, "Mac OS X", di.Title, "os title should be identified")
   864  	assert.Equal(t, "10.14.5", di.Version, "os version should be identified")
   865  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   866  	assert.Equal(t, []string{"darwin", "bsd", "unix", "os"}, di.Family)
   867  }
   868  
   869  func TestBuildrootDetector(t *testing.T) {
   870  	detector, err := newDetector("./testdata/detect-buildroot.toml")
   871  	assert.Nil(t, err, "was able to create the provider")
   872  	di, err := detector.Platform()
   873  	require.NoError(t, err)
   874  
   875  	assert.Equal(t, "buildroot", di.Name, "os name should be identified")
   876  	assert.Equal(t, "Buildroot 2019.02.9", di.Title, "os title should be identified")
   877  	assert.Equal(t, "2019.02.9", di.Version, "os version should be identified")
   878  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   879  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   880  }
   881  
   882  func TestSolaris11Detector(t *testing.T) {
   883  	detector, err := newDetector("./testdata/detect-solaris11.toml")
   884  	assert.Nil(t, err, "was able to create the provider")
   885  	di, err := detector.Platform()
   886  	require.NoError(t, err)
   887  
   888  	assert.Equal(t, "solaris", di.Name, "os name should be identified")
   889  	assert.Equal(t, "Oracle Solaris", di.Title, "os title should be identified")
   890  	assert.Equal(t, "11.1", di.Version, "os version should be identified")
   891  	assert.Equal(t, "i86pc", di.Arch, "os arch should be identified")
   892  	assert.Equal(t, []string{"unix", "os"}, di.Family)
   893  }
   894  
   895  func TestNetbsd8Detector(t *testing.T) {
   896  	detector, err := newDetector("./testdata/detect-netbsd8.toml")
   897  	assert.Nil(t, err, "was able to create the provider")
   898  	di, err := detector.Platform()
   899  	require.NoError(t, err)
   900  
   901  	assert.Equal(t, "netbsd", di.Name, "os name should be identified")
   902  	assert.Equal(t, "NetBSD", di.Title, "os title should be identified")
   903  	assert.Equal(t, "8.0", di.Version, "os version should be identified")
   904  	assert.Equal(t, "amd64", di.Arch, "os arch should be identified")
   905  	assert.Equal(t, []string{"bsd", "unix", "os"}, di.Family)
   906  }
   907  
   908  func TestFreebsd12Detector(t *testing.T) {
   909  	detector, err := newDetector("./testdata/detect-freebsd12.toml")
   910  	assert.Nil(t, err, "was able to create the provider")
   911  	di, err := detector.Platform()
   912  	require.NoError(t, err)
   913  
   914  	assert.Equal(t, "freebsd", di.Name, "os name should be identified")
   915  	assert.Equal(t, "FreeBSD", di.Title, "os title should be identified")
   916  	assert.Equal(t, "12.0-CURRENT", di.Version, "os version should be identified")
   917  	assert.Equal(t, "amd64", di.Arch, "os arch should be identified")
   918  	assert.Equal(t, []string{"bsd", "unix", "os"}, di.Family)
   919  }
   920  
   921  func TestOpenBsd6Detector(t *testing.T) {
   922  	detector, err := newDetector("./testdata/detect-openbsd6.toml")
   923  	assert.Nil(t, err, "was able to create the provider")
   924  	di, err := detector.Platform()
   925  	require.NoError(t, err)
   926  
   927  	assert.Equal(t, "openbsd", di.Name, "os name should be identified")
   928  	assert.Equal(t, "OpenBSD", di.Title, "os title should be identified")
   929  	assert.Equal(t, "6.7", di.Version, "os version should be identified")
   930  	assert.Equal(t, "amd64", di.Arch, "os arch should be identified")
   931  	assert.Equal(t, []string{"bsd", "unix", "os"}, di.Family)
   932  }
   933  
   934  func TestDragonFlyBsd5Detector(t *testing.T) {
   935  	detector, err := newDetector("./testdata/detect-dragonflybsd5.toml")
   936  	assert.Nil(t, err, "was able to create the provider")
   937  	di, err := detector.Platform()
   938  	require.NoError(t, err)
   939  
   940  	assert.Equal(t, "dragonflybsd", di.Name, "os name should be identified")
   941  	assert.Equal(t, "DragonFly", di.Title, "os title should be identified")
   942  	assert.Equal(t, "5.8-RELEASE", di.Version, "os version should be identified")
   943  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   944  	assert.Equal(t, []string{"bsd", "unix", "os"}, di.Family)
   945  }
   946  
   947  func TestMint20Detector(t *testing.T) {
   948  	detector, err := newDetector("./testdata/detect-mint20.toml")
   949  	assert.Nil(t, err, "was able to create the provider")
   950  	di, err := detector.Platform()
   951  	require.NoError(t, err)
   952  
   953  	assert.Equal(t, "linuxmint", di.Name, "os name should be identified")
   954  	assert.Equal(t, "Linux Mint 20", di.Title, "os title should be identified")
   955  	assert.Equal(t, "20", di.Version, "os version should be identified")
   956  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   957  	assert.Equal(t, []string{"debian", "linux", "unix", "os"}, di.Family)
   958  }
   959  
   960  func TestGoogleCOSDetector(t *testing.T) {
   961  	detector, err := newDetector("./testdata/detect-google-cos.toml")
   962  	assert.Nil(t, err, "was able to create the provider")
   963  	di, err := detector.Platform()
   964  	require.NoError(t, err)
   965  
   966  	assert.Equal(t, "cos", di.Name, "os name should be identified")
   967  	assert.Equal(t, "Container-Optimized OS from Google", di.Title, "os title should be identified")
   968  	assert.Equal(t, "97", di.Version, "os version should be identified")
   969  	assert.Equal(t, "x86_64", di.Arch, "os arch should be identified")
   970  	assert.Equal(t, "16919.103.16", di.Build, "os build should be identified")
   971  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   972  }
   973  
   974  func TestUbiOSDetector(t *testing.T) {
   975  	detector, err := newDetector("./testdata/detect-ubios.toml")
   976  	assert.Nil(t, err, "was able to create the provider")
   977  	di, err := detector.Platform()
   978  	require.NoError(t, err)
   979  
   980  	assert.Equal(t, "ubios", di.Name, "os name should be identified")
   981  	assert.Equal(t, "UbiOS 1.12.24.4315", di.Title, "os title should be identified")
   982  	assert.Equal(t, "v1.12.24.4315-136ee7c", di.Version, "os version should be identified")
   983  	assert.Equal(t, "aarch64", di.Arch, "os arch should be identified")
   984  	assert.Equal(t, []string{"linux", "unix", "os"}, di.Family)
   985  }
   986  
   987  func TestFamilies(t *testing.T) {
   988  	di := &platform.Platform{}
   989  	di.Family = []string{"unix", "bsd", "darwin"}
   990  
   991  	assert.Equal(t, true, di.IsFamily("unix"), "unix should be a family")
   992  	assert.Equal(t, true, di.IsFamily("bsd"), "bsd should be a family")
   993  	assert.Equal(t, true, di.IsFamily("darwin"), "darwin should be a family")
   994  }
   995  
   996  type TestContainer struct {
   997  	Name  string
   998  	Image string
   999  }