github.com/dkerwin/nomad@v0.3.3-0.20160525181927-74554135514b/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  	// Check if we have the right list
    44  	if len(result) != 1 || result[0].ID != evalID {
    45  		t.Fatalf("bad: %#v", result)
    46  	}
    47  }
    48  
    49  func TestEvaluations_PrefixList(t *testing.T) {
    50  	c, s := makeClient(t, nil, nil)
    51  	defer s.Stop()
    52  	e := c.Evaluations()
    53  
    54  	// Listing when nothing exists returns empty
    55  	result, qm, err := e.PrefixList("abcdef")
    56  	if err != nil {
    57  		t.Fatalf("err: %s", err)
    58  	}
    59  	if qm.LastIndex != 0 {
    60  		t.Fatalf("bad index: %d", qm.LastIndex)
    61  	}
    62  	if n := len(result); n != 0 {
    63  		t.Fatalf("expected 0 evaluations, got: %d", n)
    64  	}
    65  
    66  	// Register a job. This will create an evaluation.
    67  	jobs := c.Jobs()
    68  	job := testJob()
    69  	evalID, wm, err := jobs.Register(job, nil)
    70  	if err != nil {
    71  		t.Fatalf("err: %s", err)
    72  	}
    73  	assertWriteMeta(t, wm)
    74  
    75  	// Check the evaluations again
    76  	result, qm, err = e.PrefixList(evalID[:4])
    77  	if err != nil {
    78  		t.Fatalf("err: %s", err)
    79  	}
    80  	assertQueryMeta(t, qm)
    81  
    82  	// Check if we have the right list
    83  	if len(result) != 1 || result[0].ID != evalID {
    84  		t.Fatalf("bad: %#v", result)
    85  	}
    86  }
    87  
    88  func TestEvaluations_Info(t *testing.T) {
    89  	c, s := makeClient(t, nil, nil)
    90  	defer s.Stop()
    91  	e := c.Evaluations()
    92  
    93  	// Querying a non-existent evaluation returns error
    94  	_, _, err := e.Info("8E231CF4-CA48-43FF-B694-5801E69E22FA", nil)
    95  	if err == nil || !strings.Contains(err.Error(), "not found") {
    96  		t.Fatalf("expected not found error, got: %s", err)
    97  	}
    98  
    99  	// Register a job. Creates a new evaluation.
   100  	jobs := c.Jobs()
   101  	job := testJob()
   102  	evalID, wm, err := jobs.Register(job, nil)
   103  	if err != nil {
   104  		t.Fatalf("err: %s", err)
   105  	}
   106  	assertWriteMeta(t, wm)
   107  
   108  	// Try looking up by the new eval ID
   109  	result, qm, err := e.Info(evalID, nil)
   110  	if err != nil {
   111  		t.Fatalf("err: %s", err)
   112  	}
   113  	assertQueryMeta(t, qm)
   114  
   115  	// Check that we got the right result
   116  	if result == nil || result.ID != evalID {
   117  		t.Fatalf("expected eval %q, got: %#v", evalID, result)
   118  	}
   119  }
   120  
   121  func TestEvaluations_Allocations(t *testing.T) {
   122  	c, s := makeClient(t, nil, nil)
   123  	defer s.Stop()
   124  	e := c.Evaluations()
   125  
   126  	// Returns empty if no allocations
   127  	allocs, qm, err := e.Allocations("8E231CF4-CA48-43FF-B694-5801E69E22FA", nil)
   128  	if err != nil {
   129  		t.Fatalf("err: %s", err)
   130  	}
   131  	if qm.LastIndex != 0 {
   132  		t.Fatalf("bad index: %d", qm.LastIndex)
   133  	}
   134  	if n := len(allocs); n != 0 {
   135  		t.Fatalf("expected 0 allocs, got: %d", n)
   136  	}
   137  }
   138  
   139  func TestEvaluations_Sort(t *testing.T) {
   140  	evals := []*Evaluation{
   141  		&Evaluation{CreateIndex: 2},
   142  		&Evaluation{CreateIndex: 1},
   143  		&Evaluation{CreateIndex: 5},
   144  	}
   145  	sort.Sort(EvalIndexSort(evals))
   146  
   147  	expect := []*Evaluation{
   148  		&Evaluation{CreateIndex: 5},
   149  		&Evaluation{CreateIndex: 2},
   150  		&Evaluation{CreateIndex: 1},
   151  	}
   152  	if !reflect.DeepEqual(evals, expect) {
   153  		t.Fatalf("\n\n%#v\n\n%#v", evals, expect)
   154  	}
   155  }