github.com/kardianos/nomad@v0.1.3-0.20151022182107-b13df73ee850/api/nodes_test.go (about) 1 package api 2 3 import ( 4 "fmt" 5 "reflect" 6 "sort" 7 "strings" 8 "testing" 9 10 "github.com/hashicorp/nomad/testutil" 11 ) 12 13 func TestNodes_List(t *testing.T) { 14 c, s := makeClient(t, nil, func(c *testutil.TestServerConfig) { 15 c.DevMode = true 16 }) 17 defer s.Stop() 18 nodes := c.Nodes() 19 20 var qm *QueryMeta 21 var out []*NodeListStub 22 var err error 23 24 testutil.WaitForResult(func() (bool, error) { 25 out, qm, err = nodes.List(nil) 26 if err != nil { 27 return false, err 28 } 29 if n := len(out); n != 1 { 30 return false, fmt.Errorf("expected 1 node, got: %d", n) 31 } 32 return true, nil 33 }, func(err error) { 34 t.Fatalf("err: %s", err) 35 }) 36 37 // Check that we got valid QueryMeta. 38 assertQueryMeta(t, qm) 39 } 40 41 func TestNodes_Info(t *testing.T) { 42 c, s := makeClient(t, nil, func(c *testutil.TestServerConfig) { 43 c.DevMode = true 44 }) 45 defer s.Stop() 46 nodes := c.Nodes() 47 48 // Retrieving a non-existent node returns error 49 _, _, err := nodes.Info("nope", nil) 50 if err == nil || !strings.Contains(err.Error(), "not found") { 51 t.Fatalf("expected not found error, got: %#v", err) 52 } 53 54 // Get the node ID 55 var nodeID, dc string 56 testutil.WaitForResult(func() (bool, error) { 57 out, _, err := nodes.List(nil) 58 if err != nil { 59 return false, err 60 } 61 if n := len(out); n != 1 { 62 return false, fmt.Errorf("expected 1 node, got: %d", n) 63 } 64 nodeID = out[0].ID 65 dc = out[0].Datacenter 66 return true, nil 67 }, func(err error) { 68 t.Fatalf("err: %s", err) 69 }) 70 71 // Querying for existing nodes returns properly 72 result, qm, err := nodes.Info(nodeID, nil) 73 if err != nil { 74 t.Fatalf("err: %s", err) 75 } 76 assertQueryMeta(t, qm) 77 78 // Check that the result is what we expect 79 if result.ID != nodeID || result.Datacenter != dc { 80 t.Fatalf("expected %s (%s), got: %s (%s)", 81 nodeID, dc, 82 result.ID, result.Datacenter) 83 } 84 } 85 86 func TestNodes_ToggleDrain(t *testing.T) { 87 c, s := makeClient(t, nil, func(c *testutil.TestServerConfig) { 88 c.DevMode = true 89 }) 90 defer s.Stop() 91 nodes := c.Nodes() 92 93 // Wait for node registration and get the ID 94 var nodeID string 95 testutil.WaitForResult(func() (bool, error) { 96 out, _, err := nodes.List(nil) 97 if err != nil { 98 return false, err 99 } 100 if n := len(out); n != 1 { 101 return false, fmt.Errorf("expected 1 node, got: %d", n) 102 } 103 nodeID = out[0].ID 104 return true, nil 105 }, func(err error) { 106 t.Fatalf("err: %s", err) 107 }) 108 109 // Check for drain mode 110 out, _, err := nodes.Info(nodeID, nil) 111 if err != nil { 112 t.Fatalf("err: %s", err) 113 } 114 if out.Drain { 115 t.Fatalf("drain mode should be off") 116 } 117 118 // Toggle it on 119 wm, err := nodes.ToggleDrain(nodeID, true, nil) 120 if err != nil { 121 t.Fatalf("err: %s", err) 122 } 123 assertWriteMeta(t, wm) 124 125 // Check again 126 out, _, err = nodes.Info(nodeID, nil) 127 if err != nil { 128 t.Fatalf("err: %s", err) 129 } 130 if !out.Drain { 131 t.Fatalf("drain mode should be on") 132 } 133 134 // Toggle off again 135 wm, err = nodes.ToggleDrain(nodeID, false, nil) 136 if err != nil { 137 t.Fatalf("err: %s", err) 138 } 139 assertWriteMeta(t, wm) 140 141 // Check again 142 out, _, err = nodes.Info(nodeID, nil) 143 if err != nil { 144 t.Fatalf("err: %s", err) 145 } 146 if out.Drain { 147 t.Fatalf("drain mode should be off") 148 } 149 } 150 151 func TestNodes_Allocations(t *testing.T) { 152 c, s := makeClient(t, nil, nil) 153 defer s.Stop() 154 nodes := c.Nodes() 155 156 // Looking up by a non-existent node returns nothing. We 157 // don't check the index here because it's possible the node 158 // has already registered, in which case we will get a non- 159 // zero result anyways. 160 allocs, _, err := nodes.Allocations("nope", nil) 161 if err != nil { 162 t.Fatalf("err: %s", err) 163 } 164 if n := len(allocs); n != 0 { 165 t.Fatalf("expected 0 allocs, got: %d", n) 166 } 167 } 168 169 func TestNodes_ForceEvaluate(t *testing.T) { 170 c, s := makeClient(t, nil, func(c *testutil.TestServerConfig) { 171 c.DevMode = true 172 }) 173 defer s.Stop() 174 nodes := c.Nodes() 175 176 // Force-eval on a non-existent node fails 177 _, _, err := nodes.ForceEvaluate("nope", nil) 178 if err == nil || !strings.Contains(err.Error(), "not found") { 179 t.Fatalf("expected not found error, got: %#v", err) 180 } 181 182 // Wait for node registration and get the ID 183 var nodeID string 184 testutil.WaitForResult(func() (bool, error) { 185 out, _, err := nodes.List(nil) 186 if err != nil { 187 return false, err 188 } 189 if n := len(out); n != 1 { 190 return false, fmt.Errorf("expected 1 node, got: %d", n) 191 } 192 nodeID = out[0].ID 193 return true, nil 194 }, func(err error) { 195 t.Fatalf("err: %s", err) 196 }) 197 198 // Try force-eval again. We don't check the WriteMeta because 199 // there are no allocations to process, so we would get an index 200 // of zero. Same goes for the eval ID. 201 _, _, err = nodes.ForceEvaluate(nodeID, nil) 202 if err != nil { 203 t.Fatalf("err: %s", err) 204 } 205 } 206 207 func TestNodes_Sort(t *testing.T) { 208 nodes := []*NodeListStub{ 209 &NodeListStub{CreateIndex: 2}, 210 &NodeListStub{CreateIndex: 1}, 211 &NodeListStub{CreateIndex: 5}, 212 } 213 sort.Sort(NodeIndexSort(nodes)) 214 215 expect := []*NodeListStub{ 216 &NodeListStub{CreateIndex: 5}, 217 &NodeListStub{CreateIndex: 2}, 218 &NodeListStub{CreateIndex: 1}, 219 } 220 if !reflect.DeepEqual(nodes, expect) { 221 t.Fatalf("\n\n%#v\n\n%#v", nodes, expect) 222 } 223 }