github.com/ahmet2mir/goreleaser@v0.180.3-0.20210927151101-8e5ee5a9b8c5/internal/builders/buildtarget/targets_test.go (about)

     1  package buildtarget
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/goreleaser/goreleaser/pkg/config"
     8  	"github.com/stretchr/testify/require"
     9  )
    10  
    11  func TestAllBuildTargets(t *testing.T) {
    12  	build := config.Build{
    13  		GoBinary: "go",
    14  		Goos: []string{
    15  			"linux",
    16  			"darwin",
    17  			"freebsd",
    18  			"openbsd",
    19  			"windows",
    20  			"js",
    21  		},
    22  		Goarch: []string{
    23  			"386",
    24  			"amd64",
    25  			"arm",
    26  			"arm64",
    27  			"wasm",
    28  			"mips",
    29  			"mips64",
    30  			"mipsle",
    31  			"mips64le",
    32  			"riscv64",
    33  		},
    34  		Goarm: []string{
    35  			"6",
    36  			"7",
    37  		},
    38  		Gomips: []string{
    39  			"hardfloat",
    40  			"softfloat",
    41  		},
    42  		Ignore: []config.IgnoredBuild{
    43  			{
    44  				Goos:   "linux",
    45  				Goarch: "arm",
    46  				Goarm:  "7",
    47  			}, {
    48  				Goos:   "openbsd",
    49  				Goarch: "arm",
    50  			}, {
    51  				Goarch: "mips64",
    52  				Gomips: "hardfloat",
    53  			}, {
    54  				Goarch: "mips64le",
    55  				Gomips: "softfloat",
    56  			},
    57  		},
    58  	}
    59  
    60  	t.Run("go 1.15", func(t *testing.T) {
    61  		result, err := matrix(build, []byte("go version go1.15.0"))
    62  		require.NoError(t, err)
    63  		require.Equal(t, []string{
    64  			"linux_386",
    65  			"linux_amd64",
    66  			"linux_arm_6",
    67  			"linux_arm64",
    68  			"linux_mips_hardfloat",
    69  			"linux_mips_softfloat",
    70  			"linux_mips64_softfloat",
    71  			"linux_mipsle_hardfloat",
    72  			"linux_mipsle_softfloat",
    73  			"linux_mips64le_hardfloat",
    74  			"linux_riscv64",
    75  			"darwin_amd64",
    76  			"freebsd_386",
    77  			"freebsd_amd64",
    78  			"freebsd_arm_6",
    79  			"freebsd_arm_7",
    80  			"freebsd_arm64",
    81  			"openbsd_386",
    82  			"openbsd_amd64",
    83  			"openbsd_arm64",
    84  			"windows_386",
    85  			"windows_amd64",
    86  			"windows_arm_6",
    87  			"windows_arm_7",
    88  			"js_wasm",
    89  		}, result)
    90  	})
    91  
    92  	t.Run("go 1.16", func(t *testing.T) {
    93  		result, err := matrix(build, []byte("go version go1.16.2"))
    94  		require.NoError(t, err)
    95  		require.Equal(t, []string{
    96  			"linux_386",
    97  			"linux_amd64",
    98  			"linux_arm_6",
    99  			"linux_arm64",
   100  			"linux_mips_hardfloat",
   101  			"linux_mips_softfloat",
   102  			"linux_mips64_softfloat",
   103  			"linux_mipsle_hardfloat",
   104  			"linux_mipsle_softfloat",
   105  			"linux_mips64le_hardfloat",
   106  			"linux_riscv64",
   107  			"darwin_amd64",
   108  			"darwin_arm64",
   109  			"freebsd_386",
   110  			"freebsd_amd64",
   111  			"freebsd_arm_6",
   112  			"freebsd_arm_7",
   113  			"freebsd_arm64",
   114  			"openbsd_386",
   115  			"openbsd_amd64",
   116  			"openbsd_arm64",
   117  			"windows_386",
   118  			"windows_amd64",
   119  			"windows_arm_6",
   120  			"windows_arm_7",
   121  			"js_wasm",
   122  		}, result)
   123  	})
   124  
   125  	t.Run("go 1.17", func(t *testing.T) {
   126  		result, err := matrix(build, []byte("go version go1.17.0"))
   127  		require.NoError(t, err)
   128  		require.Equal(t, []string{
   129  			"linux_386",
   130  			"linux_amd64",
   131  			"linux_arm_6",
   132  			"linux_arm64",
   133  			"linux_mips_hardfloat",
   134  			"linux_mips_softfloat",
   135  			"linux_mips64_softfloat",
   136  			"linux_mipsle_hardfloat",
   137  			"linux_mipsle_softfloat",
   138  			"linux_mips64le_hardfloat",
   139  			"linux_riscv64",
   140  			"darwin_amd64",
   141  			"darwin_arm64",
   142  			"freebsd_386",
   143  			"freebsd_amd64",
   144  			"freebsd_arm_6",
   145  			"freebsd_arm_7",
   146  			"freebsd_arm64",
   147  			"openbsd_386",
   148  			"openbsd_amd64",
   149  			"openbsd_arm64",
   150  			"windows_386",
   151  			"windows_amd64",
   152  			"windows_arm_6",
   153  			"windows_arm_7",
   154  			"windows_arm64",
   155  			"js_wasm",
   156  		}, result)
   157  	})
   158  
   159  	t.Run("invalid goos", func(t *testing.T) {
   160  		_, err := matrix(config.Build{
   161  			Goos:   []string{"invalid"},
   162  			Goarch: []string{"amd64"},
   163  		}, []byte("go version go1.17.0"))
   164  		require.EqualError(t, err, "invalid goos: invalid")
   165  	})
   166  
   167  	t.Run("invalid goarch", func(t *testing.T) {
   168  		_, err := matrix(config.Build{
   169  			Goos:   []string{"linux"},
   170  			Goarch: []string{"invalid"},
   171  		}, []byte("go version go1.17.0"))
   172  		require.EqualError(t, err, "invalid goarch: invalid")
   173  	})
   174  
   175  	t.Run("invalid goarm", func(t *testing.T) {
   176  		_, err := matrix(config.Build{
   177  			Goos:   []string{"linux"},
   178  			Goarch: []string{"arm"},
   179  			Goarm:  []string{"invalid"},
   180  		}, []byte("go version go1.17.0"))
   181  		require.EqualError(t, err, "invalid goarm: invalid")
   182  	})
   183  
   184  	t.Run("invalid gomips", func(t *testing.T) {
   185  		_, err := matrix(config.Build{
   186  			Goos:   []string{"linux"},
   187  			Goarch: []string{"mips"},
   188  			Gomips: []string{"invalid"},
   189  		}, []byte("go version go1.17.0"))
   190  		require.EqualError(t, err, "invalid gomips: invalid")
   191  	})
   192  }
   193  
   194  func TestGoosGoarchCombos(t *testing.T) {
   195  	platforms := []struct {
   196  		os    string
   197  		arch  string
   198  		valid bool
   199  	}{
   200  		// valid targets:
   201  		{"aix", "ppc64", true},
   202  		{"android", "386", true},
   203  		{"android", "amd64", true},
   204  		{"android", "arm", true},
   205  		{"android", "arm64", true},
   206  		{"darwin", "amd64", true},
   207  		{"darwin", "arm64", true},
   208  		{"dragonfly", "amd64", true},
   209  		{"freebsd", "386", true},
   210  		{"freebsd", "amd64", true},
   211  		{"freebsd", "arm", true},
   212  		{"illumos", "amd64", true},
   213  		{"linux", "386", true},
   214  		{"linux", "amd64", true},
   215  		{"linux", "arm", true},
   216  		{"linux", "arm64", true},
   217  		{"linux", "mips", true},
   218  		{"linux", "mipsle", true},
   219  		{"linux", "mips64", true},
   220  		{"linux", "mips64le", true},
   221  		{"linux", "ppc64", true},
   222  		{"linux", "ppc64le", true},
   223  		{"linux", "s390x", true},
   224  		{"linux", "riscv64", true},
   225  		{"netbsd", "386", true},
   226  		{"netbsd", "amd64", true},
   227  		{"netbsd", "arm", true},
   228  		{"openbsd", "386", true},
   229  		{"openbsd", "amd64", true},
   230  		{"openbsd", "arm", true},
   231  		{"plan9", "386", true},
   232  		{"plan9", "amd64", true},
   233  		{"plan9", "arm", true},
   234  		{"solaris", "amd64", true},
   235  		{"windows", "386", true},
   236  		{"windows", "amd64", true},
   237  		{"windows", "arm", true},
   238  		{"windows", "arm64", true},
   239  		{"js", "wasm", true},
   240  		// invalid targets
   241  		{"darwin", "386", false},
   242  		{"darwin", "arm", false},
   243  		{"windows", "riscv64", false},
   244  	}
   245  	for _, p := range platforms {
   246  		t.Run(fmt.Sprintf("%v %v valid=%v", p.os, p.arch, p.valid), func(t *testing.T) {
   247  			require.Equal(t, p.valid, valid(target{p.os, p.arch, "", ""}))
   248  		})
   249  	}
   250  }
   251  
   252  func TestList(t *testing.T) {
   253  	t.Run("success", func(t *testing.T) {
   254  		targets, err := List(config.Build{
   255  			Goos:     []string{"linux"},
   256  			Goarch:   []string{"amd64"},
   257  			GoBinary: "go",
   258  		})
   259  		require.NoError(t, err)
   260  		require.Equal(t, []string{"linux_amd64"}, targets)
   261  	})
   262  
   263  	t.Run("success with dir", func(t *testing.T) {
   264  		targets, err := List(config.Build{
   265  			Goos:     []string{"linux"},
   266  			Goarch:   []string{"amd64"},
   267  			GoBinary: "go",
   268  			Dir:      "./testdata",
   269  		})
   270  		require.NoError(t, err)
   271  		require.Equal(t, []string{"linux_amd64"}, targets)
   272  	})
   273  
   274  	t.Run("fail", func(t *testing.T) {
   275  		_, err := List(config.Build{
   276  			Goos:     []string{"linux"},
   277  			Goarch:   []string{"amd64"},
   278  			GoBinary: "nope",
   279  		})
   280  		require.EqualError(t, err, `unable to determine version of go binary (nope): exec: "nope": executable file not found in $PATH`)
   281  	})
   282  }