github.com/ActiveState/cli@v0.0.0-20240508170324-6801f60cd051/internal/language/language_test.go (about)

     1  package language
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  	"github.com/stretchr/testify/require"
     8  	"gopkg.in/yaml.v2"
     9  )
    10  
    11  func TestLanguage(t *testing.T) {
    12  	var l Language
    13  	assert.Equal(t, Unset, l)
    14  
    15  	assert.True(t, Bash.Executable().CanUseThirdParty())
    16  
    17  	assert.NotEmpty(t, Python3.Executable().Name())
    18  	assert.False(t, Python3.Executable().CanUseThirdParty())
    19  
    20  	assert.Equal(t, "#!/usr/bin/env perl\n", Perl.Header())
    21  }
    22  
    23  func TestMakeLanguage(t *testing.T) {
    24  	assert.Equal(t, Python3, MakeByName("python3"), "python3")
    25  	assert.Equal(t, Unknown, MakeByName("python4"), "unknown language")
    26  	assert.Equal(t, Unset, MakeByName(""), "unset language")
    27  }
    28  
    29  func TestUnmarshal(t *testing.T) {
    30  	var l Language
    31  
    32  	err := yaml.Unmarshal([]byte("junk"), &l)
    33  	assert.Error(t, err, "fail due to bad yaml input")
    34  	assert.Equal(t, Unset, l)
    35  
    36  	err = yaml.Unmarshal([]byte("python3"), &l)
    37  	assert.NoError(t, err, "successfully unmarshal 'python3'")
    38  	assert.Equal(t, Python3, l)
    39  
    40  	err = yaml.Unmarshal([]byte("bash"), &l)
    41  	assert.NoError(t, err, "successfully unmarshal 'bash'")
    42  	assert.Equal(t, Bash, l)
    43  
    44  	err = yaml.Unmarshal([]byte("unknown"), &l)
    45  	assert.Error(t, err, "not successfully unmarshal 'unknown'")
    46  }
    47  
    48  func TestMarshal(t *testing.T) {
    49  	l := Python3
    50  	bs, err := yaml.Marshal(l)
    51  	require.NoError(t, err)
    52  	assert.Contains(t, string(bs), "python")
    53  
    54  	l = Batch
    55  	bs, err = yaml.Marshal(&l)
    56  	require.NoError(t, err)
    57  	assert.Contains(t, string(bs), "batch")
    58  	assert.Empty(t, l.Header())
    59  
    60  }
    61  
    62  func TestMakeLanguageByShell(t *testing.T) {
    63  	assert.Equal(t, Batch, MakeByShell("cmd.exe"), "strings with 'cmd' return batch")
    64  	assert.Equal(t, Bash, MakeByShell("anything_else"), "anything else returns bash")
    65  }
    66  
    67  func TestRecognized(t *testing.T) {
    68  	langs := Recognized()
    69  	for _, l := range langs {
    70  		assert.NotEqual(t, l, Unset, "not unset")
    71  		assert.NotEqual(t, l, Unknown, "not unknown")
    72  	}
    73  }
    74  
    75  func TestSupported(t *testing.T) {
    76  	var l Supported
    77  	assert.Equal(t, Unset, l.Language)
    78  }
    79  
    80  func TestSupportedUnmarshal(t *testing.T) {
    81  	var l Supported
    82  
    83  	err := yaml.Unmarshal([]byte("junk"), &l)
    84  	assert.Error(t, err, "fail due to bad yaml input")
    85  	assert.Equal(t, Unset, l.Language)
    86  
    87  	err = yaml.Unmarshal([]byte("python3"), &l)
    88  	assert.NoError(t, err, "successfully unmarshal 'python3'")
    89  	assert.Equal(t, Python3, l.Language)
    90  
    91  	err = yaml.Unmarshal([]byte("bash"), &l)
    92  	assert.Error(t, err, "not successfully unmarshal 'bash'")
    93  }
    94  
    95  func TestSupportedMarshal(t *testing.T) {
    96  	l := Supported{Python3}
    97  	bs, err := yaml.Marshal(l)
    98  	require.NoError(t, err)
    99  	assert.Contains(t, string(bs), "python")
   100  
   101  	l = Supported{Batch}
   102  	bs, err = yaml.Marshal(&l)
   103  	require.NoError(t, err)
   104  	assert.Contains(t, string(bs), "batch")
   105  	assert.Empty(t, l.Header())
   106  
   107  }
   108  
   109  func TestRecognizedSupporteds(t *testing.T) {
   110  	langs := RecognizedSupporteds()
   111  	for _, l := range langs {
   112  		assert.NotEqual(t, l.Language, Unset, "not unset")
   113  		assert.NotEqual(t, l.Language, Unknown, "not unknown")
   114  		assert.False(t, l.Executable().CanUseThirdParty())
   115  		assert.NotEmpty(t, l.Executable().Name())
   116  	}
   117  }
   118  
   119  func TestMakeByNameAndVersion(t *testing.T) {
   120  	type args struct {
   121  		name    string
   122  		version string
   123  	}
   124  	tests := []struct {
   125  		name string
   126  		args args
   127  		want Language
   128  	}{
   129  		{
   130  			"Valid Python3 version",
   131  			args{"python", "3.6.6"},
   132  			Python3,
   133  		},
   134  		{
   135  			"Valid Python2 version",
   136  			args{"python", "2.7.18"},
   137  			Python2,
   138  		},
   139  		{
   140  			"Valid Python2 invalid patch",
   141  			args{"python", "2.7.18.1"},
   142  			Python2,
   143  		},
   144  		{
   145  			"Valid Python3 invalid patch",
   146  			args{"python", "3.9"},
   147  			Python3,
   148  		},
   149  		{
   150  			"Missing version",
   151  			args{"python", ""},
   152  			Python3,
   153  		},
   154  		{
   155  			"Valid Perl version",
   156  			args{"perl", "5.28.1"},
   157  			Perl,
   158  		},
   159  	}
   160  	for _, tt := range tests {
   161  		t.Run(tt.name, func(t *testing.T) {
   162  			got := MakeByNameAndVersion(tt.args.name, tt.args.version)
   163  			if got != tt.want {
   164  				t.Errorf("MakeByNameAndVersion() = %v, want %v", got, tt.want)
   165  			}
   166  		})
   167  	}
   168  }