github.com/noqcks/syft@v0.0.0-20230920222752-a9e2c4e288e5/syft/pkg/language_test.go (about)

     1  package pkg
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/scylladb/go-set/strset"
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  func TestLanguageFromPURL(t *testing.T) {
    11  
    12  	tests := []struct {
    13  		purl string
    14  		want Language
    15  	}{
    16  
    17  		{
    18  			purl: "pkg:npm/util@2.32",
    19  			want: JavaScript,
    20  		},
    21  		{
    22  			purl: "pkg:pypi/util-linux@2.32.1-27.el8",
    23  			want: Python,
    24  		},
    25  		{
    26  			purl: "pkg:gem/ruby-advisory-db-check@0.12.4",
    27  			want: Ruby,
    28  		},
    29  		{
    30  			purl: "pkg:golang/github.com/gorilla/context@234fd47e07d1004f0aed9c",
    31  			want: Go,
    32  		},
    33  		{
    34  			purl: "pkg:pub/util@1.2.34",
    35  			want: Dart,
    36  		},
    37  		{
    38  			purl: "pkg:dotnet/Microsoft.CodeAnalysis.Razor@2.2.0",
    39  			want: Dotnet,
    40  		},
    41  		{
    42  			purl: "pkg:cargo/clap@2.33.0",
    43  			want: Rust,
    44  		},
    45  		{
    46  			purl: "pkg:composer/laravel/laravel@5.5.0",
    47  			want: PHP,
    48  		},
    49  		{
    50  			purl: "pkg:maven/org.apache.xmlgraphics/batik-anim@1.9.1?type=zip&classifier=dist",
    51  			want: Java,
    52  		},
    53  		{
    54  			purl: "pkg:cocoapods/GlossButtonNode@3.1.2",
    55  			want: Swift,
    56  		},
    57  		{
    58  			purl: "pkg:conan/catch2@2.13.8",
    59  			want: CPP,
    60  		},
    61  		{
    62  			purl: "pkg:hackage/HTTP@4000.3.16",
    63  			want: Haskell,
    64  		},
    65  		{
    66  			purl: "pkg:hex/hpax/hpax@0.1.1",
    67  			want: UnknownLanguage,
    68  		},
    69  		{
    70  			purl: "pkg:cran/base@4.3.0",
    71  			want: R,
    72  		},
    73  		{
    74  			purl: "pkg:swift/github.com/apple/swift-numerics/swift-numerics@1.0.2",
    75  			want: Swift,
    76  		},
    77  	}
    78  
    79  	var languages = strset.New()
    80  	var expectedLanguages = strset.New()
    81  	for _, ty := range AllLanguages {
    82  		expectedLanguages.Add(string(ty))
    83  	}
    84  
    85  	// we cannot determine the language from these purl ecosystems (yet?)
    86  	expectedLanguages.Remove(Elixir.String())
    87  	expectedLanguages.Remove(Erlang.String())
    88  
    89  	for _, tt := range tests {
    90  		t.Run(tt.purl, func(t *testing.T) {
    91  			actual := LanguageFromPURL(tt.purl)
    92  
    93  			if actual != "" {
    94  				languages.Add(string(actual))
    95  			}
    96  
    97  			assert.Equalf(t, tt.want, actual, "LanguageFromPURL(%v)", tt.purl)
    98  		})
    99  	}
   100  
   101  	assert.ElementsMatch(t, expectedLanguages.List(), languages.List(), "missing one or more languages to test against (maybe a package type was added?)")
   102  
   103  }
   104  
   105  func TestLanguageByName(t *testing.T) {
   106  	tests := []struct {
   107  		name     string
   108  		language Language
   109  	}{
   110  		{
   111  			name:     "maven",
   112  			language: Java,
   113  		},
   114  		{
   115  			name:     "java",
   116  			language: Java,
   117  		},
   118  		{
   119  			name:     "java-archive",
   120  			language: Java,
   121  		},
   122  		{
   123  			name:     "java",
   124  			language: Java,
   125  		},
   126  		{
   127  			name:     "composer",
   128  			language: PHP,
   129  		},
   130  		{
   131  			name:     "php-composer",
   132  			language: PHP,
   133  		},
   134  		{
   135  			name:     "php",
   136  			language: PHP,
   137  		},
   138  		{
   139  			name:     "go",
   140  			language: Go,
   141  		},
   142  		{
   143  			name:     "golang",
   144  			language: Go,
   145  		},
   146  		{
   147  			name:     "go-module",
   148  			language: Go,
   149  		},
   150  		{
   151  			name:     "npm",
   152  			language: JavaScript,
   153  		},
   154  		{
   155  			name:     "javascript",
   156  			language: JavaScript,
   157  		},
   158  		{
   159  			name:     "node.js",
   160  			language: JavaScript,
   161  		},
   162  		{
   163  			name:     "nodejs",
   164  			language: JavaScript,
   165  		},
   166  		{
   167  			name:     "pypi",
   168  			language: Python,
   169  		},
   170  		{
   171  			name:     "python",
   172  			language: Python,
   173  		},
   174  		{
   175  			name:     "gem",
   176  			language: Ruby,
   177  		},
   178  		{
   179  			name:     "ruby",
   180  			language: Ruby,
   181  		},
   182  		{
   183  			name:     "rust",
   184  			language: Rust,
   185  		},
   186  		{
   187  			name:     "rust-crate",
   188  			language: Rust,
   189  		},
   190  		{
   191  			name:     "cargo",
   192  			language: Rust,
   193  		},
   194  		{
   195  			name:     "dart",
   196  			language: Dart,
   197  		},
   198  		{
   199  			name:     "dart-pub",
   200  			language: Dart,
   201  		},
   202  		{
   203  			name:     "pub",
   204  			language: Dart,
   205  		},
   206  		{
   207  			name:     "dotnet",
   208  			language: Dotnet,
   209  		},
   210  		{
   211  			name:     "swift",
   212  			language: Swift,
   213  		},
   214  		{
   215  			name:     "pod",
   216  			language: Swift,
   217  		},
   218  		{
   219  			name:     "cocoapods",
   220  			language: Swift,
   221  		},
   222  		{
   223  			name:     "unknown",
   224  			language: UnknownLanguage,
   225  		},
   226  		{
   227  			name:     "conan",
   228  			language: CPP,
   229  		},
   230  		{
   231  			name:     "c++",
   232  			language: CPP,
   233  		},
   234  		{
   235  			name:     "hackage",
   236  			language: Haskell,
   237  		},
   238  		{
   239  			name:     "haskell",
   240  			language: Haskell,
   241  		},
   242  		{
   243  			name:     "R",
   244  			language: R,
   245  		},
   246  	}
   247  
   248  	for _, test := range tests {
   249  		assert.Equal(t, LanguageByName(test.name), test.language)
   250  	}
   251  }