github.phpd.cn/thought-machine/please@v12.2.0+incompatible/src/cli/flags_test.go (about)

     1  package cli
     2  
     3  import (
     4  	"os"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/jessevdk/go-flags"
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestByteSize(t *testing.T) {
    13  	opts := struct {
    14  		Size ByteSize `short:"b"`
    15  	}{}
    16  	_, extraArgs, err := ParseFlags("test", &opts, []string{"test", "-b=15M"}, nil)
    17  	assert.NoError(t, err)
    18  	assert.Equal(t, 0, len(extraArgs))
    19  	assert.EqualValues(t, 15000000, opts.Size)
    20  }
    21  
    22  func TestDuration(t *testing.T) {
    23  	opts := struct {
    24  		D Duration `short:"d"`
    25  	}{}
    26  	_, extraArgs, err := ParseFlags("test", &opts, []string{"test", "-d=3h"}, nil)
    27  	assert.NoError(t, err)
    28  	assert.Equal(t, 0, len(extraArgs))
    29  	assert.EqualValues(t, 3*time.Hour, opts.D)
    30  
    31  	_, extraArgs, err = ParseFlags("test", &opts, []string{"test", "-d=3"}, nil)
    32  	assert.NoError(t, err)
    33  	assert.Equal(t, 0, len(extraArgs))
    34  	assert.EqualValues(t, 3*time.Second, opts.D)
    35  }
    36  
    37  func TestDurationDefault(t *testing.T) {
    38  	opts := struct {
    39  		D Duration `short:"d" default:"3h"`
    40  	}{}
    41  	_, extraArgs, err := ParseFlags("test", &opts, []string{"test"}, nil)
    42  	assert.NoError(t, err)
    43  	assert.Equal(t, 0, len(extraArgs))
    44  	assert.EqualValues(t, 3*time.Hour, opts.D)
    45  }
    46  
    47  func TestURL(t *testing.T) {
    48  	opts := struct {
    49  		U URL `short:"u"`
    50  	}{}
    51  	_, extraArgs, err := ParseFlags("test", &opts, []string{"test", "-u=https://localhost:8080"}, nil)
    52  	assert.NoError(t, err)
    53  	assert.Equal(t, 0, len(extraArgs))
    54  	assert.EqualValues(t, "https://localhost:8080", opts.U)
    55  }
    56  
    57  func TestURLDefault(t *testing.T) {
    58  	opts := struct {
    59  		U URL `short:"u" default:"https://localhost:8080"`
    60  	}{}
    61  	_, extraArgs, err := ParseFlags("test", &opts, []string{"test"}, nil)
    62  	assert.NoError(t, err)
    63  	assert.Equal(t, 0, len(extraArgs))
    64  	assert.EqualValues(t, "https://localhost:8080", opts.U)
    65  }
    66  
    67  func TestCompletionHandler(t *testing.T) {
    68  	os.Setenv("GO_FLAGS_COMPLETION", "1")
    69  	called := false
    70  	opts := struct{}{}
    71  	ParseFlags("test", &opts, []string{"test"}, func(parser *flags.Parser, items []flags.Completion) {
    72  		called = true
    73  	})
    74  	assert.True(t, called)
    75  }
    76  
    77  func TestVersion(t *testing.T) {
    78  	v := Version{}
    79  	assert.NoError(t, v.UnmarshalFlag("3.2.1"))
    80  	assert.EqualValues(t, 3, v.Major)
    81  	assert.EqualValues(t, 2, v.Minor)
    82  	assert.EqualValues(t, 1, v.Patch)
    83  	assert.False(t, v.IsGTE)
    84  	assert.NoError(t, v.UnmarshalFlag(">=3.2.1"))
    85  	assert.EqualValues(t, 3, v.Major)
    86  	assert.EqualValues(t, 2, v.Minor)
    87  	assert.EqualValues(t, 1, v.Patch)
    88  	assert.True(t, v.IsGTE)
    89  	assert.NoError(t, v.UnmarshalFlag(">= 3.2.1"))
    90  	assert.EqualValues(t, 3, v.Major)
    91  	assert.EqualValues(t, 2, v.Minor)
    92  	assert.EqualValues(t, 1, v.Patch)
    93  	assert.True(t, v.IsGTE)
    94  	assert.Error(t, v.UnmarshalFlag("thirty-five ham and cheese sandwiches"))
    95  }
    96  
    97  func TestVersionString(t *testing.T) {
    98  	v := Version{}
    99  	v.UnmarshalFlag("3.2.1")
   100  	assert.Equal(t, "3.2.1", v.String())
   101  	v.UnmarshalFlag(">=3.2.1")
   102  	assert.Equal(t, ">=3.2.1", v.String())
   103  }
   104  
   105  func TestGetUsageTag(t *testing.T) {
   106  	opts := struct {
   107  		Usage string `usage:"Test usage"`
   108  	}{}
   109  	assert.Equal(t, "Test usage", getUsage(&opts))
   110  }
   111  
   112  func TestGetUsageValue(t *testing.T) {
   113  	opts := struct {
   114  		Usage string
   115  	}{
   116  		Usage: "Test usage",
   117  	}
   118  	assert.Equal(t, "Test usage", getUsage(&opts))
   119  }
   120  
   121  func TestGetUsageNoUsage(t *testing.T) {
   122  	opts := struct{}{}
   123  	assert.Equal(t, "", getUsage(&opts))
   124  }
   125  
   126  func TestArch(t *testing.T) {
   127  	a := Arch{}
   128  	assert.NoError(t, a.UnmarshalFlag("linux_amd64"))
   129  	assert.Equal(t, "linux", a.OS)
   130  	assert.Equal(t, "amd64", a.Arch)
   131  	assert.Equal(t, "linux_amd64", a.String())
   132  	assert.Error(t, a.UnmarshalFlag("wibble"))
   133  	assert.Error(t, a.UnmarshalFlag("not/an_arch"))
   134  }
   135  
   136  func TestXOS(t *testing.T) {
   137  	a := NewArch("darwin", "amd64")
   138  	assert.Equal(t, "osx", a.XOS())
   139  	a = NewArch("linux", "amd64")
   140  	assert.Equal(t, "linux", a.XOS())
   141  }
   142  
   143  func TestXArch(t *testing.T) {
   144  	a := NewArch("darwin", "amd64")
   145  	assert.Equal(t, "x86_64", a.XArch())
   146  	a = NewArch("linux", "x86")
   147  	assert.Equal(t, "x86_32", a.XArch())
   148  	a = NewArch("linux", "arm")
   149  	assert.Equal(t, "arm", a.XArch())
   150  }
   151  
   152  func TestGoArch(t *testing.T) {
   153  	a := NewArch("darwin", "amd64")
   154  	assert.Equal(t, "amd64", a.GoArch())
   155  	a = NewArch("linux", "x86")
   156  	assert.Equal(t, "386", a.GoArch())
   157  }