github.com/diptanu/nomad@v0.5.7-0.20170516172507-d72e86cbe3d9/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  	var _ cli.Command = &ValidateCommand{}
    16  }
    17  
    18  func TestValidateCommand(t *testing.T) {
    19  	ui := new(cli.MockUi)
    20  	cmd := &ValidateCommand{Meta: Meta{Ui: ui}}
    21  
    22  	// Create a server
    23  	s := testutil.NewTestServer(t, nil)
    24  	defer s.Stop()
    25  	os.Setenv("NOMAD_ADDR", fmt.Sprintf("http://%s", 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  	ui := new(cli.MockUi)
    60  	cmd := &ValidateCommand{Meta: Meta{Ui: ui}}
    61  
    62  	// Fails on misuse
    63  	if code := cmd.Run([]string{"some", "bad", "args"}); code != 1 {
    64  		t.Fatalf("expected exit code 1, got: %d", code)
    65  	}
    66  	if out := ui.ErrorWriter.String(); !strings.Contains(out, cmd.Help()) {
    67  		t.Fatalf("expected help output, got: %s", out)
    68  	}
    69  	ui.ErrorWriter.Reset()
    70  
    71  	// Fails when specified file does not exist
    72  	if code := cmd.Run([]string{"/unicorns/leprechauns"}); code != 1 {
    73  		t.Fatalf("expect exit 1, got: %d", code)
    74  	}
    75  	if out := ui.ErrorWriter.String(); !strings.Contains(out, "Error getting job struct") {
    76  		t.Fatalf("expect getting job struct error, got: %s", out)
    77  	}
    78  	ui.ErrorWriter.Reset()
    79  
    80  	// Fails on invalid HCL
    81  	fh1, err := ioutil.TempFile("", "nomad")
    82  	if err != nil {
    83  		t.Fatalf("err: %s", err)
    84  	}
    85  	defer os.Remove(fh1.Name())
    86  	if _, err := fh1.WriteString("nope"); err != nil {
    87  		t.Fatalf("err: %s", err)
    88  	}
    89  	if code := cmd.Run([]string{fh1.Name()}); code != 1 {
    90  		t.Fatalf("expect exit 1, got: %d", code)
    91  	}
    92  	if out := ui.ErrorWriter.String(); !strings.Contains(out, "Error getting job struct") {
    93  		t.Fatalf("expect parsing error, got: %s", out)
    94  	}
    95  	ui.ErrorWriter.Reset()
    96  
    97  	// Fails on invalid job spec
    98  	fh2, err := ioutil.TempFile("", "nomad")
    99  	if err != nil {
   100  		t.Fatalf("err: %s", err)
   101  	}
   102  	defer os.Remove(fh2.Name())
   103  	if _, err := fh2.WriteString(`job "job1" {}`); err != nil {
   104  		t.Fatalf("err: %s", err)
   105  	}
   106  	if code := cmd.Run([]string{fh2.Name()}); code != 1 {
   107  		t.Fatalf("expect exit 1, got: %d", code)
   108  	}
   109  	if out := ui.ErrorWriter.String(); !strings.Contains(out, "Job validation errors") {
   110  		t.Fatalf("expect validation error, got: %s", out)
   111  	}
   112  	ui.ErrorWriter.Reset()
   113  }
   114  
   115  func TestValidateCommand_From_STDIN(t *testing.T) {
   116  	stdinR, stdinW, err := os.Pipe()
   117  	if err != nil {
   118  		t.Fatalf("err: %s", err)
   119  	}
   120  
   121  	ui := new(cli.MockUi)
   122  	cmd := &ValidateCommand{
   123  		Meta:      Meta{Ui: ui},
   124  		JobGetter: JobGetter{testStdin: stdinR},
   125  	}
   126  	// Create a server
   127  	s := testutil.NewTestServer(t, nil)
   128  	defer s.Stop()
   129  	os.Setenv("NOMAD_ADDR", fmt.Sprintf("http://%s", s.HTTPAddr))
   130  
   131  	go func() {
   132  		stdinW.WriteString(`
   133  job "job1" {
   134    type = "service"
   135    datacenters = [ "dc1" ]
   136    group "group1" {
   137                  count = 1
   138                  task "task1" {
   139                          driver = "exec"
   140  						config {
   141  							command = "/bin/echo"
   142  						}
   143                          resources = {
   144                                  cpu = 1000
   145                                  memory = 512
   146                          }
   147                  }
   148          }
   149  }`)
   150  		stdinW.Close()
   151  	}()
   152  
   153  	args := []string{"-"}
   154  	if code := cmd.Run(args); code != 0 {
   155  		t.Fatalf("expected exit code 0, got %d: %q", code, ui.ErrorWriter.String())
   156  	}
   157  	ui.ErrorWriter.Reset()
   158  }
   159  
   160  func TestValidateCommand_From_URL(t *testing.T) {
   161  	ui := new(cli.MockUi)
   162  	cmd := &RunCommand{
   163  		Meta: Meta{Ui: ui},
   164  	}
   165  
   166  	args := []string{"https://example.com/foo/bar"}
   167  	if code := cmd.Run(args); code != 1 {
   168  		t.Fatalf("expected exit code 1, got %d: %q", code, ui.ErrorWriter.String())
   169  	}
   170  
   171  	if out := ui.ErrorWriter.String(); !strings.Contains(out, "Error getting jobfile") {
   172  		t.Fatalf("expected error getting jobfile, got: %s", out)
   173  	}
   174  }