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

     1  package command
     2  
     3  import (
     4  	"bytes"
     5  	"io"
     6  	"strings"
     7  	"testing"
     8  )
     9  
    10  func Test_DMTemplateLocalCommandSingle(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  		{"master-servers", "a,b,c", "master_servers:\n  - host: a\n  - host: b\n  - host: c"},
    23  		{"worker-servers", "a,b,c", "worker_servers:\n  - host: a\n  - host: b\n  - host: c"},
    24  		{"monitoring-servers", "a,b,c", "monitoring_servers:\n  - host: a\n  - host: b\n  - host: c"},
    25  		{"grafana-servers", "a,b,c", "grafana_servers:\n  - host: a\n  - host: b\n  - host: c"},
    26  		{"alertmanager-servers", "a,b,c", "alertmanager_servers:\n  - host: a\n  - host: b\n  - host: c"},
    27  	}
    28  
    29  	for _, test := range tests {
    30  		cmd := newTemplateCmd()
    31  		b := bytes.NewBufferString("")
    32  		cmd.SetOut(b)
    33  		_ = cmd.Flags().Set("local", "true") // add --local
    34  		_ = cmd.Flags().Set(test.optKey, test.optVal)
    35  
    36  		if err := cmd.Execute(); err != nil {
    37  			t.Fatal(err)
    38  		}
    39  
    40  		out, err := io.ReadAll(b)
    41  		if err != nil {
    42  			t.Fatal(err)
    43  		}
    44  		if !strings.Contains(string(out), test.expected) {
    45  			t.Fatalf("expected \"%s\", got \"%s\"", test.expected, string(out))
    46  		}
    47  	}
    48  }
    49  
    50  func Test_DMTemplateLocalCommandMulti(t *testing.T) {
    51  	cmd := newTemplateCmd()
    52  	b := bytes.NewBufferString("")
    53  	cmd.SetOut(b)
    54  	_ = cmd.Flags().Set("local", "true")                    // add --local
    55  	_ = cmd.Flags().Set("user", "ubuntu")                   // add --user=ubuntu
    56  	_ = cmd.Flags().Set("group", "ubuntu")                  // add --group=ubuntu
    57  	_ = cmd.Flags().Set("master-servers", "m1,m2,m3")       // add --master-servers=m1,m2,m3
    58  	_ = cmd.Flags().Set("worker-servers", "w1,w2,w3")       // add --worker-servers=w1,w2,w3
    59  	_ = cmd.Flags().Set("alertmanager-servers", "a1,a2,a3") // add --alertmanager-servers=a1,a2,a3
    60  
    61  	if err := cmd.Execute(); err != nil {
    62  		t.Fatal(err)
    63  	}
    64  
    65  	out, err := io.ReadAll(b)
    66  	if err != nil {
    67  		t.Fatal(err)
    68  	}
    69  
    70  	for _, b := range []bool{
    71  		strings.Contains(string(out), "user: \"ubuntu\""),
    72  		strings.Contains(string(out), "group: \"ubuntu\""),
    73  		strings.Contains(string(out), "master_servers:\n  - host: m1\n  - host: m2\n  - host: m3"),
    74  		strings.Contains(string(out), "worker_servers:\n  - host: w1\n  - host: w2\n  - host: w3"),
    75  		strings.Contains(string(out), "alertmanager_servers:\n  - host: a1\n  - host: a2\n  - host: a3"),
    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), "master_servers:\n  - host: 172.19.0.101\n  - host: 172.19.0.102\n  - host: 172.19.0.103"),
   106  		strings.Contains(string(out), "worker_servers:\n  - host: 172.19.0.101\n  - host: 172.19.0.102\n  - host: 172.19.0.103"),
   107  		strings.Contains(string(out), "monitoring_servers:\n  - host: 172.19.0.101"),
   108  		strings.Contains(string(out), "grafana_servers:\n  - host: 172.19.0.101"),
   109  		strings.Contains(string(out), "alertmanager_servers:\n  - host: 172.19.0.101"),
   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  	tests := []struct {
   119  		optKey string
   120  		optVal string
   121  	}{
   122  		{"arch", "i386"},
   123  		{"master-servers", "m1,m2"},
   124  		{"worker-servers", "w1"},
   125  	}
   126  
   127  	for _, test := range tests {
   128  		cmd := newTemplateCmd()
   129  		b := bytes.NewBufferString("")
   130  		cmd.SetOut(b)
   131  		_ = cmd.Flags().Set("local", "true")          // add --local
   132  		_ = cmd.Flags().Set(test.optKey, test.optVal) // add invalid option
   133  
   134  		// should returns err
   135  		if err := cmd.Execute(); err == nil {
   136  			t.Fatal(err)
   137  		}
   138  	}
   139  }