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