github.com/hhrutter/nomad@v0.6.0-rc2.0.20170723054333-80c4b03f0705/command/validate_test.go (about)

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