fixed qunit tests

tests/common/index_filter.js

 QUnit.test("Filters out special indices", function(assert) {
     var filter = new IndexFilter("", true, false, true, true, 0);
-    var index = {index: "index_name", status: 'open', unhealthy: false, aliases: []};
+    var index = {name: "index_name", closed: false, special: true, unhealthy: false, aliases: []};
     assert.ok(!filter.matches(index), "Filters out special indices");
-});
+})
 
 QUnit.test("Maintains special indices", function(assert) {
     var filter = new IndexFilter("", true, true, true, true, 0);
-    var index = {index: "index_name", status: 'open', unhealthy: false, aliases: []};
+    var index = {name: "index_name", closed: false, special: true, unhealthy: false, aliases: []};
     assert.ok(filter.matches(index), "Filters out special indices");
-});
+})
 
 QUnit.test("Filters out closed indices", function(assert) {
     var filter = new IndexFilter("", false, true, true, true, 0);
-    var index = {index: "index_name", status: 'close', unhealthy: false, aliases: []};
+    var index = {name: "index_name", closed: true, special: false, unhealthy: false, aliases: []};
     assert.ok(!filter.matches(index), "Filters out closed indices");
-});
+})
 
 QUnit.test("Maintains closed indices", function(assert) {
     var filter = new IndexFilter("", true, true, true, true, 0);
-    var index = {index: "index_name", status: 'close', unhealthy: false, aliases: []};
+    var index = {name: "index_name", closed: true, special: false, unhealthy: false, aliases: []};
     assert.ok(filter.matches(index), "Filters out closed indices");
-});
+})
 
 QUnit.test("Maintains healthy indices", function(assert) {
     var filter = new IndexFilter("", true, true, true, true, 0);
-    var index = {index: "index_name", status: 'close', unhealthy: false, aliases: []};
+    var index = {name: "index_name", closed: true, special: false, unhealthy: false, aliases: []};
     assert.ok(filter.matches(index), "Maintains healthy indices");
-});
+})
 
 QUnit.test("Maintains unhealthy indices", function(assert) {
     var filter = new IndexFilter("", true, true, true, true, 0);
-    var index = {index: "index_name", status: 'close', unhealthy: true, aliases: []};
+    var index = {name: "index_name", closed: true, special: false, unhealthy: true, aliases: []};
     assert.ok(filter.matches(index), "Maintains unhealthy indices");
-});
+})
 
 QUnit.test("Filters out healthy indices", function(assert) {
     var filter = new IndexFilter("", true, true, false, true, 0);
-    var index = {index: "index_name", status: 'close', unhealthy: false, aliases: []};
+    var index = {name: "index_name", closed: true, special: false, unhealthy: false, aliases: []};
     assert.ok(!filter.matches(index), "Filters out healthy indices");
-});
+})
 
 QUnit.test("Filter by name on different name index", function(assert) {
     var filter = new IndexFilter("abc", true,  true, true, true, 0);
-    var index = {index: "cba", status: 'close', unhealthy: false, aliases: []};
+    var index = {name: "cba", closed: true, special: false, unhealthy: false, aliases: []};
     assert.ok(!filter.matches(index), "Doesnt match if filter name is not a substring of name");
-});
+})
 
 QUnit.test("Filter by name on index with matching name", function(assert) {
     var filter = new IndexFilter("abc", true, true, true, true, 0);
-    var index = {index: "abcdef", status: 'close', unhealthy: false, aliases: []};
+    var index = {name: "abcdef", closed: true, special: false, unhealthy: false, aliases: []};
     assert.ok(filter.matches(index), "Matches if filter name is a substring of name");
-});
+})
 
 QUnit.test("Filter by name regexp on index with matching name", function(assert) {
     var filter = new IndexFilter("a\.+f", true, true, true, true, 0);
-    var index = {index: "abcdef", status: 'close', unhealthy: false, aliases: []};
+    var index = {name: "abcdef", closed: true, special: false, unhealthy: false, aliases: []};
     assert.ok(filter.matches(index), "Matches if filter reg exp matches index name");
-});
+})
 
 QUnit.test("Use regexp as plain string if regexp doesnt compile", function(assert) {
     var filter = new IndexFilter("a\.f-", true, true, true, true, 0);
-    var index = {index: "a.f-", status: 'close', unhealthy: false, aliases: []};
+    var index = {name: "a.f-", closed: true, special: false, unhealthy: false, aliases: []};
     assert.ok(filter.matches(index), "Matches if filter reg exp matches index name");
-});
+})
 
 QUnit.test("Use regexp as plain string if regexp doesnt compile", function(assert) {
     var filter = new IndexFilter("a\.f-", true, true, true, true, 0);
-    var index = {index: "a.f-", status: 'close', unhealthy: false, aliases: []};
+    var index = {name: "a.f-", closed: true, special: false, unhealthy: false, aliases: []};
     assert.ok(filter.matches(index), "Matches if filter non compiling reg exp matches index name");
-});
+})
 
 QUnit.test("Checks also index aliases for matches", function(assert) {
     var filter = new IndexFilter("also", true, true, true, true, 0);
-    var index = {index: "a.f-", status: 'close', unhealthy: false, aliases: ["whatever", "also_aliases"]};
+    var index = {name: "a.f-", closed: true, special: false, unhealthy: false, aliases: ["whatever", "also_aliases"]};
     assert.ok(filter.matches(index), "Matches also on index aliases");
-});
+})
 
 QUnit.test("Checks also index aliases for matches if RegExp doesnt compile", function(assert) {
     var filter = new IndexFilter("[a\.f-", true, true, true, true, 0);
-    var index = {index: "a.f-", status: 'close', unhealthy: false, aliases: ["somethingelse", "[a\.f-lalala"]};
+    var index = {name: "a.f-", closed: true, special: false, unhealthy: false, aliases: ["somethingelse", "[a\.f-lalala"]};
     assert.ok(filter.matches(index), "Matches also on index aliases if regexp doesnt compile");
-});
+})
 
 QUnit.test("Doesnt match if neither name or aliases match the RegExp", function(assert) {
     var filter = new IndexFilter("[a\.f-", true, true, true, true, 0);
-    var index = {index: "a.f-", status: 'close', unhealthy: false, aliases: ["ddd"]};
+    var index = {name: "a.f-", closed: true, special: false, unhealthy: false, aliases: ["ddd"]};
     assert.ok(!filter.matches(index), "Matches also on index aliases if regexp doesnt compile");
-});
+})
 
 QUnit.test("Doesnt match if neither name or aliases match the text", function(assert) {
     var filter = new IndexFilter("bbbb", true, true, true, true, 0);
-    var index = {index: "a.f-", status: 'close', unhealthy: false, aliases: ["ddd"]};
+    var index = {name: "a.f-", closed: true, special: false, unhealthy: false, aliases: ["ddd"]};
     assert.ok(!filter.matches(index), "Matches also on index aliases if regexp doesnt compile");
-});
+})

tests/common/node_filter.js

 QUnit.test("Blank node filter", function(assert) {
     var filter = new NodeFilter("", true, true, true, true, 0);
-    var node = { name: 'a', 'node.role': 'mdi' };
+    var node = { name: 'a', master: true, coordinating: false, data: true, ingest: true };
     assert.ok(filter.matches(node), "Matches any node if filter is blank");
-});
+})
 
 QUnit.test("Only master node filter x non master node", function(assert) {
     var filter = new NodeFilter("", false, true, false, false, 0);
-    var node = { name: 'a', 'node.role': 'di' };
+    var node = { name: 'a', master: false, coordinating: false, data: true, ingest: true };
     assert.ok(!filter.matches(node),"Doesnt match a non master node");
-});
+})
 
 QUnit.test("Only master node filter x master node", function(assert) {
     var filter = new NodeFilter("", false, true, false, false, 0);
-    var node = { name: 'a', 'node.role': 'mdi' };
+    var node = { name: 'a', master: true, coordinating: false, data: true, ingest: true };
     assert.ok(filter.matches(node),"Matches a master node");
-});
+})
 
 QUnit.test("Only data node filter x non data node", function(assert) {
     var filter = new NodeFilter("", true, false, false, false, 0);
-    var node = { name: 'a', 'node.role': 'i' };
+    var node = { name: 'a', master: false, coordinating: true, data: false, ingest: true };
     assert.ok(!filter.matches(node),"Doesnt match a non data node");
-});
+})
 
 QUnit.test("Only data node filter x data node", function(assert) {
     var filter = new NodeFilter("", true, false, false, false, 0);
-    var node = { name: 'a', 'node.role': 'd' };
+    var node = { name: 'a', master: false, coordinating: false, data: true, ingest: false };
     assert.ok(filter.matches(node),"Match a data node");
-});
+})
 
 QUnit.test("Only coordinating node filter x non client node", function(assert) {
     var filter = new NodeFilter("", false, false, false, true, 0);
-    var node = { name: 'a', 'node.role': 'd' };
+    var node = { name: 'a', master: false, coordinating: false, data: true, ingest: false };
     assert.ok(!filter.matches(node), "Doesnt match a non client node");
-});
+})
 
 QUnit.test("Only client node filter x client node", function(assert) {
     var filter = new NodeFilter("", false, false, false, true, 0);
-    var node = { name: 'a', 'node.role': '-' };
+    var node = { name: 'a', master: false, coordinating: true, data: false };
     assert.ok(filter.matches(node),"Match a client node");
-});
+})
 
 QUnit.test("Only ingest node filter x ingest node", function(assert) {
   var filter = new NodeFilter("", false, false, true, false, 0);
-  var node = { name: 'a', 'node.role': 'i' };
+  var node = { name: 'a', master: false, coordinating: false, data: false, ingest: true };
   assert.ok(filter.matches(node),"Match an ingest node");
-});
+})
 
 QUnit.test("Only ingest node filter x non ingest node", function(assert) {
   var filter = new NodeFilter("", false, false, true, false, 0);
-  var node = { name: 'a', 'node.role': '-' };
+  var node = { name: 'a', master: false, coordinating: true, data: false, ingest: false };
   assert.ok(!filter.matches(node),"Doesnt match a non ingest node");
-});
+})
 
 QUnit.test("Master or client node filter x data node", function(assert) {
     var filter = new NodeFilter("", false, true, true, 0);
-    var node = { name: 'a', 'node.role': 'd' };
+    var node = { name: 'a', master: false, coordinating: false, data: true };
     assert.ok(!filter.matches(node), "Doesnt match a non master/client node");
-});
+})
 
 QUnit.test("Master or client node filter x client node x master node", function(assert) {
     var filter = new NodeFilter("", false, true, false, true, 0);
-    var node = { name: 'a', 'node.role': '-' };
-    var node2 = { name: 'a', 'node.role': 'mi' };
+    var node = { name: 'a', master: false, coordinating: true, data: false, ingest: true  };
+    var node2 = { name: 'a', master: true, coordinating: false, data: false, ingest: true  };
     assert.ok(filter.matches(node),"Match a client node");
     assert.ok(filter.matches(node2),"Match a master node");
-});
+})
 
 QUnit.test("node filter with name x non matching name", function(assert) {
     var filter = new NodeFilter("moli", true, true, true, true, 0);
-    var node = { name: 'milo_id', 'node.role': 'mdi' };
+    var node = { name: 'milo_id', master: true, coordinating: false, data: true, ingest: true  };
     assert.ok(!filter.matches(node),"Doesnt match if name is not a substring");
-});
+})
 
 QUnit.test("node filter with name x matching name", function(assert) {
     var filter = new NodeFilter("moli", true, true, true, true, 0);
-    var node = { name: 'moliware', 'node.role': 'mdi' };
+    var node = { name: 'moliware', master: true, coordinating: false, data: true, ingest: true  };
     assert.ok(filter.matches(node),"Matches if name is not a substring");
-});
+})