github.com/blixtra/nomad@v0.7.2-0.20171221000451-da9a1d7bb050/api/evaluations_test.go (about)

     1  package api
     2  
     3  import (
     4  	"reflect"
     5  	"sort"
     6  	"strings"
     7  	"testing"
     8  )
     9  
    10  func TestEvaluations_List(t *testing.T) {
    11  	t.Parallel()
    12  	c, s := makeClient(t, nil, nil)
    13  	defer s.Stop()
    14  	e := c.Evaluations()
    15  
    16  	// Listing when nothing exists returns empty
    17  	result, qm, err := e.List(nil)
    18  	if err != nil {
    19  		t.Fatalf("err: %s", err)
    20  	}
    21  	if qm.LastIndex != 0 {
    22  		t.Fatalf("bad index: %d", qm.LastIndex)
    23  	}
    24  	if n := len(result); n != 0 {
    25  		t.Fatalf("expected 0 evaluations, got: %d", n)
    26  	}
    27  
    28  	// Register a job. This will create an evaluation.
    29  	jobs := c.Jobs()
    30  	job := testJob()
    31  	resp, wm, err := jobs.Register(job, nil)
    32  	if err != nil {
    33  		t.Fatalf("err: %s", err)
    34  	}
    35  	assertWriteMeta(t, wm)
    36  
    37  	// Check the evaluations again
    38  	result, qm, err = e.List(nil)
    39  	if err != nil {
    40  		t.Fatalf("err: %s", err)
    41  	}
    42  	assertQueryMeta(t, qm)
    43  
    44  	// if the eval fails fast there can be more than 1
    45  	// but they are in order of most recent first, so look at the last one
    46  	idx := len(result) - 1
    47  	if len(result) == 0 || result[idx].ID != resp.EvalID {
    48  		t.Fatalf("expected eval (%s), got: %#v", resp.EvalID, result[idx])
    49  	}
    50  }
    51  
    52  func TestEvaluations_PrefixList(t *testing.T) {
    53  	t.Parallel()
    54  	c, s := makeClient(t, nil, nil)
    55  	defer s.Stop()
    56  	e := c.Evaluations()
    57  
    58  	// Listing when nothing exists returns empty
    59  	result, qm, err := e.PrefixList("abcdef")
    60  	if err != nil {
    61  		t.Fatalf("err: %s", err)
    62  	}
    63  	if qm.LastIndex != 0 {
    64  		t.Fatalf("bad index: %d", qm.LastIndex)
    65  	}
    66  	if n := len(result); n != 0 {
    67  		t.Fatalf("expected 0 evaluations, got: %d", n)
    68  	}
    69  
    70  	// Register a job. This will create an evaluation.
    71  	jobs := c.Jobs()
    72  	job := testJob()
    73  	resp, wm, err := jobs.Register(job, nil)
    74  	if err != nil {
    75  		t.Fatalf("err: %s", err)
    76  	}
    77  	assertWriteMeta(t, wm)
    78  
    79  	// Check the evaluations again
    80  	result, qm, err = e.PrefixList(resp.EvalID[:4])
    81  	if err != nil {
    82  		t.Fatalf("err: %s", err)
    83  	}
    84  	assertQueryMeta(t, qm)
    85  
    86  	// Check if we have the right list
    87  	if len(result) != 1 || result[0].ID != resp.EvalID {
    88  		t.Fatalf("bad: %#v", result)
    89  	}
    90  }
    91  
    92  func TestEvaluations_Info(t *testing.T) {
    93  	t.Parallel()
    94  	c, s := makeClient(t, nil, nil)
    95  	defer s.Stop()
    96  	e := c.Evaluations()
    97  
    98  	// Querying a non-existent evaluation returns error
    99  	_, _, err := e.Info("8E231CF4-CA48-43FF-B694-5801E69E22FA", nil)
   100  	if err == nil || !strings.Contains(err.Error(), "not found") {
   101  		t.Fatalf("expected not found error, got: %s", err)
   102  	}
   103  
   104  	// Register a job. Creates a new evaluation.
   105  	jobs := c.Jobs()
   106  	job := testJob()
   107  	resp, wm, err := jobs.Register(job, nil)
   108  	if err != nil {
   109  		t.Fatalf("err: %s", err)
   110  	}
   111  	assertWriteMeta(t, wm)
   112  
   113  	// Try looking up by the new eval ID
   114  	result, qm, err := e.Info(resp.EvalID, nil)
   115  	if err != nil {
   116  		t.Fatalf("err: %s", err)
   117  	}
   118  	assertQueryMeta(t, qm)
   119  
   120  	// Check that we got the right result
   121  	if result == nil || result.ID != resp.EvalID {
   122  		t.Fatalf("expected eval %q, got: %#v", resp.EvalID, result)
   123  	}
   124  }
   125  
   126  func TestEvaluations_Allocations(t *testing.T) {
   127  	t.Parallel()
   128  	c, s := makeClient(t, nil, nil)
   129  	defer s.Stop()
   130  	e := c.Evaluations()
   131  
   132  	// Returns empty if no allocations
   133  	allocs, qm, err := e.Allocations("8E231CF4-CA48-43FF-B694-5801E69E22FA", nil)
   134  	if err != nil {
   135  		t.Fatalf("err: %s", err)
   136  	}
   137  	if qm.LastIndex != 0 {
   138  		t.Fatalf("bad index: %d", qm.LastIndex)
   139  	}
   140  	if n := len(allocs); n != 0 {
   141  		t.Fatalf("expected 0 allocs, got: %d", n)
   142  	}
   143  }
   144  
   145  func TestEvaluations_Sort(t *testing.T) {
   146  	t.Parallel()
   147  	evals := []*Evaluation{
   148  		{CreateIndex: 2},
   149  		{CreateIndex: 1},
   150  		{CreateIndex: 5},
   151  	}
   152  	sort.Sort(EvalIndexSort(evals))
   153  
   154  	expect := []*Evaluation{
   155  		{CreateIndex: 5},
   156  		{CreateIndex: 2},
   157  		{CreateIndex: 1},
   158  	}
   159  	if !reflect.DeepEqual(evals, expect) {
   160  		t.Fatalf("\n\n%#v\n\n%#v", evals, expect)
   161  	}
   162  }