github.com/jmitchell/nomad@v0.1.3-0.20151007230021-7ab84c2862d8/nomad/structs/structs_test.go (about)

     1  package structs
     2  
     3  import (
     4  	"reflect"
     5  	"strings"
     6  	"testing"
     7  
     8  	"github.com/hashicorp/go-multierror"
     9  )
    10  
    11  func TestJob_Validate(t *testing.T) {
    12  	j := &Job{}
    13  	err := j.Validate()
    14  	mErr := err.(*multierror.Error)
    15  	if !strings.Contains(mErr.Errors[0].Error(), "job region") {
    16  		t.Fatalf("err: %s", err)
    17  	}
    18  	if !strings.Contains(mErr.Errors[1].Error(), "job ID") {
    19  		t.Fatalf("err: %s", err)
    20  	}
    21  	if !strings.Contains(mErr.Errors[2].Error(), "job name") {
    22  		t.Fatalf("err: %s", err)
    23  	}
    24  	if !strings.Contains(mErr.Errors[3].Error(), "job type") {
    25  		t.Fatalf("err: %s", err)
    26  	}
    27  	if !strings.Contains(mErr.Errors[4].Error(), "priority") {
    28  		t.Fatalf("err: %s", err)
    29  	}
    30  	if !strings.Contains(mErr.Errors[5].Error(), "datacenters") {
    31  		t.Fatalf("err: %s", err)
    32  	}
    33  	if !strings.Contains(mErr.Errors[6].Error(), "task groups") {
    34  		t.Fatalf("err: %s", err)
    35  	}
    36  
    37  	j = &Job{
    38  		Region:      "global",
    39  		ID:          GenerateUUID(),
    40  		Name:        "my-job",
    41  		Type:        JobTypeService,
    42  		Priority:    50,
    43  		Datacenters: []string{"dc1"},
    44  		TaskGroups: []*TaskGroup{
    45  			&TaskGroup{
    46  				Name: "web",
    47  			},
    48  			&TaskGroup{
    49  				Name: "web",
    50  			},
    51  			&TaskGroup{},
    52  		},
    53  	}
    54  	err = j.Validate()
    55  	mErr = err.(*multierror.Error)
    56  	if !strings.Contains(mErr.Errors[0].Error(), "2 redefines 'web' from group 1") {
    57  		t.Fatalf("err: %s", err)
    58  	}
    59  	if !strings.Contains(mErr.Errors[1].Error(), "group 3 missing name") {
    60  		t.Fatalf("err: %s", err)
    61  	}
    62  	if !strings.Contains(mErr.Errors[2].Error(), "Task group 1 validation failed") {
    63  		t.Fatalf("err: %s", err)
    64  	}
    65  }
    66  
    67  func TestTaskGroup_Validate(t *testing.T) {
    68  	tg := &TaskGroup{}
    69  	err := tg.Validate()
    70  	mErr := err.(*multierror.Error)
    71  	if !strings.Contains(mErr.Errors[0].Error(), "group name") {
    72  		t.Fatalf("err: %s", err)
    73  	}
    74  	if !strings.Contains(mErr.Errors[1].Error(), "count must be positive") {
    75  		t.Fatalf("err: %s", err)
    76  	}
    77  	if !strings.Contains(mErr.Errors[2].Error(), "Missing tasks") {
    78  		t.Fatalf("err: %s", err)
    79  	}
    80  
    81  	tg = &TaskGroup{
    82  		Name:  "web",
    83  		Count: 1,
    84  		Tasks: []*Task{
    85  			&Task{Name: "web"},
    86  			&Task{Name: "web"},
    87  			&Task{},
    88  		},
    89  	}
    90  	err = tg.Validate()
    91  	mErr = err.(*multierror.Error)
    92  	if !strings.Contains(mErr.Errors[0].Error(), "2 redefines 'web' from task 1") {
    93  		t.Fatalf("err: %s", err)
    94  	}
    95  	if !strings.Contains(mErr.Errors[1].Error(), "Task 3 missing name") {
    96  		t.Fatalf("err: %s", err)
    97  	}
    98  	if !strings.Contains(mErr.Errors[2].Error(), "Task 1 validation failed") {
    99  		t.Fatalf("err: %s", err)
   100  	}
   101  }
   102  
   103  func TestTask_Validate(t *testing.T) {
   104  	task := &Task{}
   105  	err := task.Validate()
   106  	mErr := err.(*multierror.Error)
   107  	if !strings.Contains(mErr.Errors[0].Error(), "task name") {
   108  		t.Fatalf("err: %s", err)
   109  	}
   110  	if !strings.Contains(mErr.Errors[1].Error(), "task driver") {
   111  		t.Fatalf("err: %s", err)
   112  	}
   113  	if !strings.Contains(mErr.Errors[2].Error(), "task resources") {
   114  		t.Fatalf("err: %s", err)
   115  	}
   116  
   117  	task = &Task{
   118  		Name:      "web",
   119  		Driver:    "docker",
   120  		Resources: &Resources{},
   121  	}
   122  	err = task.Validate()
   123  	if err != nil {
   124  		t.Fatalf("err: %s", err)
   125  	}
   126  }
   127  
   128  func TestResource_NetIndex(t *testing.T) {
   129  	r := &Resources{
   130  		Networks: []*NetworkResource{
   131  			&NetworkResource{Device: "eth0"},
   132  			&NetworkResource{Device: "lo0"},
   133  			&NetworkResource{Device: ""},
   134  		},
   135  	}
   136  	if idx := r.NetIndex(&NetworkResource{Device: "eth0"}); idx != 0 {
   137  		t.Fatalf("Bad: %d", idx)
   138  	}
   139  	if idx := r.NetIndex(&NetworkResource{Device: "lo0"}); idx != 1 {
   140  		t.Fatalf("Bad: %d", idx)
   141  	}
   142  	if idx := r.NetIndex(&NetworkResource{Device: "eth1"}); idx != -1 {
   143  		t.Fatalf("Bad: %d", idx)
   144  	}
   145  }
   146  
   147  func TestResource_Superset(t *testing.T) {
   148  	r1 := &Resources{
   149  		CPU:      2000,
   150  		MemoryMB: 2048,
   151  		DiskMB:   10000,
   152  		IOPS:     100,
   153  	}
   154  	r2 := &Resources{
   155  		CPU:      2000,
   156  		MemoryMB: 1024,
   157  		DiskMB:   5000,
   158  		IOPS:     50,
   159  	}
   160  
   161  	if s, _ := r1.Superset(r1); !s {
   162  		t.Fatalf("bad")
   163  	}
   164  	if s, _ := r1.Superset(r2); !s {
   165  		t.Fatalf("bad")
   166  	}
   167  	if s, _ := r2.Superset(r1); s {
   168  		t.Fatalf("bad")
   169  	}
   170  	if s, _ := r2.Superset(r2); !s {
   171  		t.Fatalf("bad")
   172  	}
   173  }
   174  
   175  func TestResource_Add(t *testing.T) {
   176  	r1 := &Resources{
   177  		CPU:      2000,
   178  		MemoryMB: 2048,
   179  		DiskMB:   10000,
   180  		IOPS:     100,
   181  		Networks: []*NetworkResource{
   182  			&NetworkResource{
   183  				CIDR:          "10.0.0.0/8",
   184  				MBits:         100,
   185  				ReservedPorts: []int{22},
   186  			},
   187  		},
   188  	}
   189  	r2 := &Resources{
   190  		CPU:      2000,
   191  		MemoryMB: 1024,
   192  		DiskMB:   5000,
   193  		IOPS:     50,
   194  		Networks: []*NetworkResource{
   195  			&NetworkResource{
   196  				IP:            "10.0.0.1",
   197  				MBits:         50,
   198  				ReservedPorts: []int{80},
   199  			},
   200  		},
   201  	}
   202  
   203  	err := r1.Add(r2)
   204  	if err != nil {
   205  		t.Fatalf("Err: %v", err)
   206  	}
   207  
   208  	expect := &Resources{
   209  		CPU:      3000,
   210  		MemoryMB: 3072,
   211  		DiskMB:   15000,
   212  		IOPS:     150,
   213  		Networks: []*NetworkResource{
   214  			&NetworkResource{
   215  				CIDR:          "10.0.0.0/8",
   216  				MBits:         150,
   217  				ReservedPorts: []int{22, 80},
   218  			},
   219  		},
   220  	}
   221  
   222  	if !reflect.DeepEqual(expect.Networks, r1.Networks) {
   223  		t.Fatalf("bad: %#v %#v", expect, r1)
   224  	}
   225  }
   226  
   227  func TestResource_Add_Network(t *testing.T) {
   228  	r1 := &Resources{}
   229  	r2 := &Resources{
   230  		Networks: []*NetworkResource{
   231  			&NetworkResource{
   232  				MBits:        50,
   233  				DynamicPorts: []string{"http", "https"},
   234  			},
   235  		},
   236  	}
   237  	r3 := &Resources{
   238  		Networks: []*NetworkResource{
   239  			&NetworkResource{
   240  				MBits:        25,
   241  				DynamicPorts: []string{"admin"},
   242  			},
   243  		},
   244  	}
   245  
   246  	err := r1.Add(r2)
   247  	if err != nil {
   248  		t.Fatalf("Err: %v", err)
   249  	}
   250  	err = r1.Add(r3)
   251  	if err != nil {
   252  		t.Fatalf("Err: %v", err)
   253  	}
   254  
   255  	expect := &Resources{
   256  		Networks: []*NetworkResource{
   257  			&NetworkResource{
   258  				MBits:        75,
   259  				DynamicPorts: []string{"http", "https", "admin"},
   260  			},
   261  		},
   262  	}
   263  
   264  	if !reflect.DeepEqual(expect.Networks, r1.Networks) {
   265  		t.Fatalf("bad: %#v %#v", expect.Networks[0], r1.Networks[0])
   266  	}
   267  }
   268  
   269  func TestMapDynamicPorts(t *testing.T) {
   270  	resources := &NetworkResource{
   271  		ReservedPorts: []int{80, 443, 3306, 8080},
   272  		DynamicPorts:  []string{"mysql", "admin"},
   273  	}
   274  
   275  	expected := map[string]int{
   276  		"mysql": 3306,
   277  		"admin": 8080,
   278  	}
   279  	actual := resources.MapDynamicPorts()
   280  
   281  	if !reflect.DeepEqual(expected, actual) {
   282  		t.Fatalf("Expected %#v; found %#v", expected, actual)
   283  	}
   284  }
   285  
   286  func TestMapDynamicPortsEmpty(t *testing.T) {
   287  	resources := &NetworkResource{
   288  		ReservedPorts: []int{},
   289  		DynamicPorts:  []string{},
   290  	}
   291  
   292  	expected := map[string]int{}
   293  	actual := resources.MapDynamicPorts()
   294  
   295  	if !reflect.DeepEqual(expected, actual) {
   296  		t.Fatalf("Expected %#v; found %#v", expected, actual)
   297  	}
   298  }
   299  
   300  func TestMapDynamicPortsStaticOnly(t *testing.T) {
   301  	resources := &NetworkResource{
   302  		ReservedPorts: []int{80, 443},
   303  		DynamicPorts:  []string{},
   304  	}
   305  
   306  	expected := map[string]int{}
   307  	actual := resources.MapDynamicPorts()
   308  
   309  	if !reflect.DeepEqual(expected, actual) {
   310  		t.Fatalf("Expected %#v; found %#v", expected, actual)
   311  	}
   312  }
   313  
   314  func TestMapDynamicPortsOnly(t *testing.T) {
   315  	resources := &NetworkResource{
   316  		ReservedPorts: []int{3306, 8080},
   317  		DynamicPorts:  []string{"mysql", "admin"},
   318  	}
   319  
   320  	expected := map[string]int{
   321  		"mysql": 3306,
   322  		"admin": 8080,
   323  	}
   324  	actual := resources.MapDynamicPorts()
   325  
   326  	if !reflect.DeepEqual(expected, actual) {
   327  		t.Fatalf("Expected %#v; found %#v", expected, actual)
   328  	}
   329  }
   330  
   331  func TestListStaticPorts(t *testing.T) {
   332  	resources := &NetworkResource{
   333  		ReservedPorts: []int{80, 443, 3306, 8080},
   334  		DynamicPorts:  []string{"mysql", "admin"},
   335  	}
   336  
   337  	expected := []int{80, 443}
   338  	actual := resources.ListStaticPorts()
   339  
   340  	if !reflect.DeepEqual(expected, actual) {
   341  		t.Fatalf("Expected %#v; found %#v", expected, actual)
   342  	}
   343  }
   344  
   345  func TestListStaticPortsEmpty(t *testing.T) {
   346  	resources := &NetworkResource{
   347  		ReservedPorts: []int{},
   348  		DynamicPorts:  []string{},
   349  	}
   350  
   351  	expected := []int{}
   352  	actual := resources.ListStaticPorts()
   353  
   354  	if !reflect.DeepEqual(expected, actual) {
   355  		t.Fatalf("Expected %#v; found %#v", expected, actual)
   356  	}
   357  }
   358  
   359  func TestListStaticPortsOnly(t *testing.T) {
   360  	resources := &NetworkResource{
   361  		ReservedPorts: []int{80, 443},
   362  		DynamicPorts:  []string{},
   363  	}
   364  
   365  	expected := []int{80, 443}
   366  	actual := resources.ListStaticPorts()
   367  
   368  	if !reflect.DeepEqual(expected, actual) {
   369  		t.Fatalf("Expected %#v; found %#v", expected, actual)
   370  	}
   371  }
   372  
   373  func TestListStaticPortsDynamicOnly(t *testing.T) {
   374  	resources := &NetworkResource{
   375  		ReservedPorts: []int{3306, 8080},
   376  		DynamicPorts:  []string{"mysql", "admin"},
   377  	}
   378  
   379  	expected := []int{}
   380  	actual := resources.ListStaticPorts()
   381  
   382  	if !reflect.DeepEqual(expected, actual) {
   383  		t.Fatalf("Expected %#v; found %#v", expected, actual)
   384  	}
   385  }
   386  
   387  func TestEncodeDecode(t *testing.T) {
   388  	type FooRequest struct {
   389  		Foo string
   390  		Bar int
   391  		Baz bool
   392  	}
   393  	arg := &FooRequest{
   394  		Foo: "test",
   395  		Bar: 42,
   396  		Baz: true,
   397  	}
   398  	buf, err := Encode(1, arg)
   399  	if err != nil {
   400  		t.Fatalf("err: %v", err)
   401  	}
   402  
   403  	var out FooRequest
   404  	err = Decode(buf[1:], &out)
   405  	if err != nil {
   406  		t.Fatalf("err: %v", err)
   407  	}
   408  
   409  	if !reflect.DeepEqual(arg, &out) {
   410  		t.Fatalf("bad: %#v %#v", arg, out)
   411  	}
   412  }