github.com/pingcap/tiup@v1.15.1/components/cluster/command/template_test.go (about)

     1  package command
     2  
     3  import (
     4  	"bytes"
     5  	"io"
     6  	"strings"
     7  	"testing"
     8  )
     9  
    10  func Test_TemplateLocalCommandSingle(t *testing.T) {
    11  	tests := []struct {
    12  		optKey   string
    13  		optVal   string
    14  		expected string
    15  	}{
    16  		{"user", "ubuntu", "user: \"ubuntu\""},
    17  		{"group", "ubuntu", "group: \"ubuntu\""},
    18  		{"ssh-port", "2222", "ssh_port: 2222"},
    19  		{"deploy-dir", "/path/to/deploy", "deploy_dir: \"/path/to/deploy\""},
    20  		{"data-dir", "/path/to/data", "data_dir: \"/path/to/data\""},
    21  		{"arch", "arm64", "arch: \"arm64\""},
    22  		{"pd-servers", "a,b,c", "pd_servers:\n  - host: a\n  - host: b\n  - host: c"},
    23  		{"tidb-servers", "a,b,c", "tidb_servers:\n  - host: a\n  - host: b\n  - host: c"},
    24  		{"tikv-servers", "a,b,c", "tikv_servers:\n  - host: a\n  - host: b\n  - host: c"},
    25  		{"tiflash-servers", "a,b,c", "tiflash_servers:\n  - host: a\n  - host: b\n  - host: c"},
    26  		{"monitoring-servers", "a,b,c", "monitoring_servers:\n  - host: a\n  - host: b\n  - host: c"},
    27  		{"grafana-servers", "a,b,c", "grafana_servers:\n  - host: a\n  - host: b\n  - host: c"},
    28  		{"alertmanager-servers", "a,b,c", "alertmanager_servers:\n  - host: a\n  - host: b\n  - host: c"},
    29  	}
    30  
    31  	for _, test := range tests {
    32  		cmd := newTemplateCmd()
    33  		b := bytes.NewBufferString("")
    34  		cmd.SetOut(b)
    35  		_ = cmd.Flags().Set("local", "true") // add --local
    36  		_ = cmd.Flags().Set(test.optKey, test.optVal)
    37  
    38  		if err := cmd.Execute(); err != nil {
    39  			t.Fatal(err)
    40  		}
    41  
    42  		out, err := io.ReadAll(b)
    43  		if err != nil {
    44  			t.Fatal(err)
    45  		}
    46  		if !strings.Contains(string(out), test.expected) {
    47  			t.Fatalf("expected \"%s\", got \"%s\"", test.expected, string(out))
    48  		}
    49  	}
    50  }
    51  
    52  func Test_TemplateLocalCommandMulti(t *testing.T) {
    53  	cmd := newTemplateCmd()
    54  	b := bytes.NewBufferString("")
    55  	cmd.SetOut(b)
    56  	_ = cmd.Flags().Set("local", "true")                 // add --local
    57  	_ = cmd.Flags().Set("user", "ubuntu")                // add --user=ubuntu
    58  	_ = cmd.Flags().Set("group", "ubuntu")               // add --group=ubuntu
    59  	_ = cmd.Flags().Set("tidb-servers", "a,b,c")         // add --tidb-servers=a,b,c
    60  	_ = cmd.Flags().Set("alertmanager-servers", "a,b,c") // add --alertmanager-servers=a,b,c
    61  
    62  	if err := cmd.Execute(); err != nil {
    63  		t.Fatal(err)
    64  	}
    65  
    66  	out, err := io.ReadAll(b)
    67  	if err != nil {
    68  		t.Fatal(err)
    69  	}
    70  
    71  	for _, b := range []bool{
    72  		strings.Contains(string(out), "user: \"ubuntu\""),
    73  		strings.Contains(string(out), "group: \"ubuntu\""),
    74  		strings.Contains(string(out), "tidb_servers:\n  - host: a\n  - host: b\n  - host: c"),
    75  		strings.Contains(string(out), "alertmanager_servers:\n  - host: a\n  - host: b\n  - host: c"),
    76  	} {
    77  		if !b {
    78  			t.Fatalf("unexpected output. got \"%s\"", string(out))
    79  		}
    80  	}
    81  }
    82  
    83  func Test_TemplateLocalCommandNoopt(t *testing.T) {
    84  	cmd := newTemplateCmd()
    85  	b := bytes.NewBufferString("")
    86  	cmd.SetOut(b)
    87  	_ = cmd.Flags().Set("local", "true") // add --local
    88  
    89  	if err := cmd.Execute(); err != nil {
    90  		t.Fatal(err)
    91  	}
    92  
    93  	out, err := io.ReadAll(b)
    94  	if err != nil {
    95  		t.Fatal(err)
    96  	}
    97  
    98  	// check default output
    99  	for _, b := range []bool{
   100  		strings.Contains(string(out), "user: \"tidb\""),
   101  		strings.Contains(string(out), "ssh_port: 22"),
   102  		strings.Contains(string(out), "deploy_dir: \"/tidb-deploy\""),
   103  		strings.Contains(string(out), "data_dir: \"/tidb-data\""),
   104  		strings.Contains(string(out), "arch: \"amd64\""),
   105  		strings.Contains(string(out), "pd_servers:\n  - host: 127.0.0.1"),
   106  		strings.Contains(string(out), "tidb_servers:\n  - host: 127.0.0.1"),
   107  		strings.Contains(string(out), "tikv_servers:\n  - host: 127.0.0.1"),
   108  		strings.Contains(string(out), "monitoring_servers:\n  - host: 127.0.0.1"),
   109  		strings.Contains(string(out), "grafana_servers:\n  - host: 127.0.0.1"),
   110  	} {
   111  		if !b {
   112  			t.Fatalf("unexpected output. got \"%s\"", string(out))
   113  		}
   114  	}
   115  }
   116  
   117  func Test_TemplateLocalCommandValidate(t *testing.T) {
   118  	cmd := newTemplateCmd()
   119  	b := bytes.NewBufferString("")
   120  	cmd.SetOut(b)
   121  	_ = cmd.Flags().Set("local", "true") // add --local
   122  	_ = cmd.Flags().Set("arch", "i386")  // add --arch=i386 (invalid)
   123  
   124  	// should returns err
   125  	if err := cmd.Execute(); err == nil {
   126  		t.Fatal(err)
   127  	}
   128  }