github.com/Ilhicas/nomad@v1.0.4-0.20210304152020-e86851182bc3/command/job_validate_test.go (about)

     1  package command
     2  
     3  import (
     4  	"io/ioutil"
     5  	"os"
     6  	"strings"
     7  	"testing"
     8  
     9  	"github.com/hashicorp/nomad/testutil"
    10  	"github.com/mitchellh/cli"
    11  )
    12  
    13  func TestValidateCommand_Implements(t *testing.T) {
    14  	t.Parallel()
    15  	var _ cli.Command = &JobValidateCommand{}
    16  }
    17  
    18  func TestValidateCommand(t *testing.T) {
    19  	t.Parallel()
    20  	// Create a server
    21  	s := testutil.NewTestServer(t, nil)
    22  	defer s.Stop()
    23  
    24  	ui := cli.NewMockUi()
    25  	cmd := &JobValidateCommand{Meta: Meta{Ui: ui, flagAddress: "http://" + s.HTTPAddr}}
    26  
    27  	fh, err := ioutil.TempFile("", "nomad")
    28  	if err != nil {
    29  		t.Fatalf("err: %s", err)
    30  	}
    31  	defer os.Remove(fh.Name())
    32  	_, err = fh.WriteString(`
    33  job "job1" {
    34  	type = "service"
    35  	datacenters = [ "dc1" ]
    36  	group "group1" {
    37  		count = 1
    38  		task "task1" {
    39  			driver = "exec"
    40  			config {
    41  				command = "/bin/sleep"
    42  			}
    43  			resources {
    44  				cpu = 1000
    45  				memory = 512
    46  			}
    47  		}
    48  	}
    49  }`)
    50  	if err != nil {
    51  		t.Fatalf("err: %s", err)
    52  	}
    53  	if code := cmd.Run([]string{fh.Name()}); code != 0 {
    54  		t.Fatalf("expect exit 0, got: %d: %s", code, ui.ErrorWriter.String())
    55  	}
    56  }
    57  
    58  func TestValidateCommand_Fails(t *testing.T) {
    59  	t.Parallel()
    60  	ui := cli.NewMockUi()
    61  	cmd := &JobValidateCommand{Meta: Meta{Ui: ui}}
    62  
    63  	// Fails on misuse
    64  	if code := cmd.Run([]string{"some", "bad", "args"}); code != 1 {
    65  		t.Fatalf("expected exit code 1, got: %d", code)
    66  	}
    67  	if out := ui.ErrorWriter.String(); !strings.Contains(out, commandErrorText(cmd)) {
    68  		t.Fatalf("expected help output, got: %s", out)
    69  	}
    70  	ui.ErrorWriter.Reset()
    71  
    72  	// Fails when specified file does not exist
    73  	if code := cmd.Run([]string{"/unicorns/leprechauns"}); code != 1 {
    74  		t.Fatalf("expect exit 1, got: %d", code)
    75  	}
    76  	if out := ui.ErrorWriter.String(); !strings.Contains(out, "Error getting job struct") {
    77  		t.Fatalf("expect getting job struct error, got: %s", out)
    78  	}
    79  	ui.ErrorWriter.Reset()
    80  
    81  	// Fails on invalid HCL
    82  	fh1, err := ioutil.TempFile("", "nomad")
    83  	if err != nil {
    84  		t.Fatalf("err: %s", err)
    85  	}
    86  	defer os.Remove(fh1.Name())
    87  	if _, err := fh1.WriteString("nope"); err != nil {
    88  		t.Fatalf("err: %s", err)
    89  	}
    90  	if code := cmd.Run([]string{fh1.Name()}); code != 1 {
    91  		t.Fatalf("expect exit 1, got: %d", code)
    92  	}
    93  	if out := ui.ErrorWriter.String(); !strings.Contains(out, "Error getting job struct") {
    94  		t.Fatalf("expect parsing error, got: %s", out)
    95  	}
    96  	ui.ErrorWriter.Reset()
    97  
    98  	// Fails on invalid job spec
    99  	fh2, err := ioutil.TempFile("", "nomad")
   100  	if err != nil {
   101  		t.Fatalf("err: %s", err)
   102  	}
   103  	defer os.Remove(fh2.Name())
   104  	if _, err := fh2.WriteString(`job "job1" {}`); err != nil {
   105  		t.Fatalf("err: %s", err)
   106  	}
   107  	if code := cmd.Run([]string{fh2.Name()}); code != 1 {
   108  		t.Fatalf("expect exit 1, got: %d", code)
   109  	}
   110  	if out := ui.ErrorWriter.String(); !strings.Contains(out, "Job validation errors") {
   111  		t.Fatalf("expect validation error, got: %s", out)
   112  	}
   113  	ui.ErrorWriter.Reset()
   114  }
   115  
   116  func TestValidateCommand_From_STDIN(t *testing.T) {
   117  	t.Parallel()
   118  	stdinR, stdinW, err := os.Pipe()
   119  	if err != nil {
   120  		t.Fatalf("err: %s", err)
   121  	}
   122  
   123  	// Create a server
   124  	s := testutil.NewTestServer(t, nil)
   125  	defer s.Stop()
   126  
   127  	ui := cli.NewMockUi()
   128  	cmd := &JobValidateCommand{
   129  		Meta:      Meta{Ui: ui, flagAddress: "http://" + s.HTTPAddr},
   130  		JobGetter: JobGetter{testStdin: stdinR},
   131  	}
   132  
   133  	go func() {
   134  		stdinW.WriteString(`
   135  job "job1" {
   136    type = "service"
   137    datacenters = [ "dc1" ]
   138    group "group1" {
   139                  count = 1
   140                  task "task1" {
   141                          driver = "exec"
   142  						config {
   143  							command = "/bin/echo"
   144  						}
   145                          resources {
   146                                  cpu = 1000
   147                                  memory = 512
   148                          }
   149                  }
   150          }
   151  }`)
   152  		stdinW.Close()
   153  	}()
   154  
   155  	args := []string{"-"}
   156  	if code := cmd.Run(args); code != 0 {
   157  		t.Fatalf("expected exit code 0, got %d: %q", code, ui.ErrorWriter.String())
   158  	}
   159  	ui.ErrorWriter.Reset()
   160  }
   161  
   162  func TestValidateCommand_From_URL(t *testing.T) {
   163  	t.Parallel()
   164  	ui := cli.NewMockUi()
   165  	cmd := &JobRunCommand{
   166  		Meta: Meta{Ui: ui},
   167  	}
   168  
   169  	args := []string{"https://example.com/foo/bar"}
   170  	if code := cmd.Run(args); code != 1 {
   171  		t.Fatalf("expected exit code 1, got %d: %q", code, ui.ErrorWriter.String())
   172  	}
   173  
   174  	if out := ui.ErrorWriter.String(); !strings.Contains(out, "Error getting jobfile") {
   175  		t.Fatalf("expected error getting jobfile, got: %s", out)
   176  	}
   177  }