[Tech]: Start migrating to Jest for tests (#9610)

* tech: investigating karma + jest mix

* tech: migrating tests to jest

* tech: moved anoter test file to jest

* test: migrated two more test files to jest

* test: updated readme and made test fail to verify that it causes CI build failure

* tech: added code coverage for jest tests

* tech: testing codecov coverage

* tech: migrated more tests

* tech: migrated template srv to typescript and the tests to jest

* tech: minor build fix

* tech: build fixes

* build: another attempt at fixing go test with coverage

public/app/plugins/datasource/graphite/specs/gfunc.jest.ts

@@ -1,25 +1,23 @@
-
-import {describe, it, expect} from 'test/lib/common';
 import gfunc from '../gfunc';
 
 describe('when creating func instance from func names', function() {
   it('should return func instance', function() {
     var func = gfunc.createFuncInstance('sumSeries');
-    expect(func).to.be.ok();
-    expect(func.def.name).to.equal('sumSeries');
-    expect(func.def.params.length).to.equal(5);
-    expect(func.def.defaultParams.length).to.equal(1);
+    expect(func).toBeTruthy();
+    expect(func.def.name).toEqual('sumSeries');
+    expect(func.def.params.length).toEqual(5);
+    expect(func.def.defaultParams.length).toEqual(1);
   });
 
   it('should return func instance with shortName', function() {
     var func = gfunc.createFuncInstance('sum');
-    expect(func).to.be.ok();
+    expect(func).toBeTruthy();
   });
 
   it('should return func instance from funcDef', function() {
     var func = gfunc.createFuncInstance('sum');
     var func2 = gfunc.createFuncInstance(func.def);
-    expect(func2).to.be.ok();
+    expect(func2).toBeTruthy();
   });
 
   it('func instance should have text representation', function() {
@@ -27,7 +25,7 @@ describe('when creating func instance from func names', function() {
     func.params[0] = 5;
     func.params[1] = 'avg';
     func.updateText();
-    expect(func.text).to.equal("groupByNode(5, avg)");
+    expect(func.text).toEqual("groupByNode(5, avg)");
   });
 });
 
@@ -35,51 +33,51 @@ describe('when rendering func instance', function() {
 
   it('should handle single metric param', function() {
     var func = gfunc.createFuncInstance('sumSeries');
-    expect(func.render('hello.metric')).to.equal("sumSeries(hello.metric)");
+    expect(func.render('hello.metric')).toEqual("sumSeries(hello.metric)");
   });
 
   it('should include default params if options enable it', function() {
     var func = gfunc.createFuncInstance('scaleToSeconds', { withDefaultParams: true });
-    expect(func.render('hello')).to.equal("scaleToSeconds(hello, 1)");
+    expect(func.render('hello')).toEqual("scaleToSeconds(hello, 1)");
   });
 
   it('should handle int or interval params with number', function() {
     var func = gfunc.createFuncInstance('movingMedian');
     func.params[0] = '5';
-    expect(func.render('hello')).to.equal("movingMedian(hello, 5)");
+    expect(func.render('hello')).toEqual("movingMedian(hello, 5)");
   });
 
   it('should handle int or interval params with interval string', function() {
     var func = gfunc.createFuncInstance('movingMedian');
     func.params[0] = '5min';
-    expect(func.render('hello')).to.equal("movingMedian(hello, '5min')");
+    expect(func.render('hello')).toEqual("movingMedian(hello, '5min')");
   });
 
   it('should handle metric param and int param and string param', function() {
     var func = gfunc.createFuncInstance('groupByNode');
     func.params[0] = 5;
     func.params[1] = 'avg';
-    expect(func.render('hello.metric')).to.equal("groupByNode(hello.metric, 5, 'avg')");
+    expect(func.render('hello.metric')).toEqual("groupByNode(hello.metric, 5, 'avg')");
   });
 
   it('should handle function with no metric param', function() {
     var func = gfunc.createFuncInstance('randomWalk');
     func.params[0] = 'test';
-    expect(func.render(undefined)).to.equal("randomWalk('test')");
+    expect(func.render(undefined)).toEqual("randomWalk('test')");
   });
 
   it('should handle function multiple series params', function() {
     var func = gfunc.createFuncInstance('asPercent');
     func.params[0] = '#B';
-    expect(func.render('#A')).to.equal("asPercent(#A, #B)");
+    expect(func.render('#A')).toEqual("asPercent(#A, #B)");
   });
 
 });
 
 describe('when requesting function categories', function() {
   it('should return function categories', function() {
-    var catIndex = gfunc.getCategories();
-    expect(catIndex.Special.length).to.be.greaterThan(8);
+    var catIndex = gfunc.getCategories('1.0');
+    expect(catIndex.Special.length).toBeGreaterThan(8);
   });
 });
 
@@ -87,14 +85,14 @@ describe('when updating func param', function() {
   it('should update param value and update text representation', function() {
     var func = gfunc.createFuncInstance('summarize', { withDefaultParams: true });
     func.updateParam('1h', 0);
-    expect(func.params[0]).to.be('1h');
-    expect(func.text).to.be('summarize(1h, sum, false)');
+    expect(func.params[0]).toBe('1h');
+    expect(func.text).toBe('summarize(1h, sum, false)');
   });
 
   it('should parse numbers as float', function() {
     var func = gfunc.createFuncInstance('scale');
     func.updateParam('0.001', 0);
-    expect(func.params[0]).to.be('0.001');
+    expect(func.params[0]).toBe('0.001');
   });
 });
 
@@ -102,24 +100,24 @@ describe('when updating func param with optional second parameter', function() {
   it('should update value and text', function() {
     var func = gfunc.createFuncInstance('aliasByNode');
     func.updateParam('1', 0);
-    expect(func.params[0]).to.be('1');
+    expect(func.params[0]).toBe('1');
   });
 
   it('should slit text and put value in second param', function() {
     var func = gfunc.createFuncInstance('aliasByNode');
     func.updateParam('4,-5', 0);
-    expect(func.params[0]).to.be('4');
-    expect(func.params[1]).to.be('-5');
-    expect(func.text).to.be('aliasByNode(4, -5)');
+    expect(func.params[0]).toBe('4');
+    expect(func.params[1]).toBe('-5');
+    expect(func.text).toBe('aliasByNode(4, -5)');
   });
 
   it('should remove second param when empty string is set', function() {
     var func = gfunc.createFuncInstance('aliasByNode');
     func.updateParam('4,-5', 0);
     func.updateParam('', 1);
-    expect(func.params[0]).to.be('4');
-    expect(func.params[1]).to.be(undefined);
-    expect(func.text).to.be('aliasByNode(4)');
+    expect(func.params[0]).toBe('4');
+    expect(func.params[1]).toBe(undefined);
+    expect(func.text).toBe('aliasByNode(4)');
   });
 });
 

public/app/plugins/datasource/graphite/specs/lexer.jest.ts

@@ -1,5 +1,3 @@
-
-import {describe, it, expect} from 'test/lib/common';
 import {Lexer} from '../lexer';
 
 describe('when lexing graphite expression', function() {
@@ -7,120 +5,120 @@ describe('when lexing graphite expression', function() {
   it('should tokenize metric expression', function() {
     var lexer = new Lexer('metric.test.*.asd.count');
     var tokens = lexer.tokenize();
-    expect(tokens[0].value).to.be('metric');
-    expect(tokens[1].value).to.be('.');
-    expect(tokens[2].type).to.be('identifier');
-    expect(tokens[4].type).to.be('identifier');
-    expect(tokens[4].pos).to.be(13);
+    expect(tokens[0].value).toBe('metric');
+    expect(tokens[1].value).toBe('.');
+    expect(tokens[2].type).toBe('identifier');
+    expect(tokens[4].type).toBe('identifier');
+    expect(tokens[4].pos).toBe(13);
   });
 
   it('should tokenize metric expression with dash', function() {
     var lexer = new Lexer('metric.test.se1-server-*.asd.count');
     var tokens = lexer.tokenize();
-    expect(tokens[4].type).to.be('identifier');
-    expect(tokens[4].value).to.be('se1-server-*');
+    expect(tokens[4].type).toBe('identifier');
+    expect(tokens[4].value).toBe('se1-server-*');
   });
 
   it('should tokenize metric expression with dash2', function() {
     var lexer = new Lexer('net.192-168-1-1.192-168-1-9.ping_value.*');
     var tokens = lexer.tokenize();
-    expect(tokens[0].value).to.be('net');
-    expect(tokens[2].value).to.be('192-168-1-1');
+    expect(tokens[0].value).toBe('net');
+    expect(tokens[2].value).toBe('192-168-1-1');
   });
 
   it('should tokenize metric expression with equal sign', function() {
     var lexer = new Lexer('apps=test');
     var tokens = lexer.tokenize();
-    expect(tokens[0].value).to.be('apps=test');
+    expect(tokens[0].value).toBe('apps=test');
   });
 
   it('simple function2', function() {
     var lexer = new Lexer('offset(test.metric, -100)');
     var tokens = lexer.tokenize();
-    expect(tokens[2].type).to.be('identifier');
-    expect(tokens[4].type).to.be('identifier');
-    expect(tokens[6].type).to.be('number');
+    expect(tokens[2].type).toBe('identifier');
+    expect(tokens[4].type).toBe('identifier');
+    expect(tokens[6].type).toBe('number');
   });
 
   it('should tokenize metric expression with curly braces', function() {
     var lexer = new Lexer('metric.se1-{first, second}.count');
     var tokens = lexer.tokenize();
-    expect(tokens.length).to.be(10);
-    expect(tokens[3].type).to.be('{');
-    expect(tokens[4].value).to.be('first');
-    expect(tokens[5].value).to.be(',');
-    expect(tokens[6].value).to.be('second');
+    expect(tokens.length).toBe(10);
+    expect(tokens[3].type).toBe('{');
+    expect(tokens[4].value).toBe('first');
+    expect(tokens[5].value).toBe(',');
+    expect(tokens[6].value).toBe('second');
   });
 
   it('should tokenize metric expression with number segments', function() {
     var lexer = new Lexer("metric.10.12_10.test");
     var tokens = lexer.tokenize();
-    expect(tokens[0].type).to.be('identifier');
-    expect(tokens[2].type).to.be('identifier');
-    expect(tokens[2].value).to.be('10');
-    expect(tokens[4].value).to.be('12_10');
-    expect(tokens[4].type).to.be('identifier');
+    expect(tokens[0].type).toBe('identifier');
+    expect(tokens[2].type).toBe('identifier');
+    expect(tokens[2].value).toBe('10');
+    expect(tokens[4].value).toBe('12_10');
+    expect(tokens[4].type).toBe('identifier');
   });
 
   it('should tokenize metric expression with segment that start with number', function() {
     var lexer = new Lexer("metric.001-server");
     var tokens = lexer.tokenize();
-    expect(tokens[0].type).to.be('identifier');
-    expect(tokens[2].type).to.be('identifier');
-    expect(tokens.length).to.be(3);
+    expect(tokens[0].type).toBe('identifier');
+    expect(tokens[2].type).toBe('identifier');
+    expect(tokens.length).toBe(3);
   });
 
   it('should tokenize func call with numbered metric and number arg', function() {
     var lexer = new Lexer("scale(metric.10, 15)");
     var tokens = lexer.tokenize();
-    expect(tokens[0].type).to.be('identifier');
-    expect(tokens[2].type).to.be('identifier');
-    expect(tokens[2].value).to.be('metric');
-    expect(tokens[4].value).to.be('10');
-    expect(tokens[4].type).to.be('number');
-    expect(tokens[6].type).to.be('number');
+    expect(tokens[0].type).toBe('identifier');
+    expect(tokens[2].type).toBe('identifier');
+    expect(tokens[2].value).toBe('metric');
+    expect(tokens[4].value).toBe('10');
+    expect(tokens[4].type).toBe('number');
+    expect(tokens[6].type).toBe('number');
   });
 
   it('should tokenize metric with template parameter', function() {
     var lexer = new Lexer("metric.[[server]].test");
     var tokens = lexer.tokenize();
-    expect(tokens[2].type).to.be('identifier');
-    expect(tokens[2].value).to.be('[[server]]');
-    expect(tokens[4].type).to.be('identifier');
+    expect(tokens[2].type).toBe('identifier');
+    expect(tokens[2].value).toBe('[[server]]');
+    expect(tokens[4].type).toBe('identifier');
   });
 
   it('should tokenize metric with question mark', function() {
     var lexer = new Lexer("metric.server_??.test");
     var tokens = lexer.tokenize();
-    expect(tokens[2].type).to.be('identifier');
-    expect(tokens[2].value).to.be('server_??');
-    expect(tokens[4].type).to.be('identifier');
+    expect(tokens[2].type).toBe('identifier');
+    expect(tokens[2].value).toBe('server_??');
+    expect(tokens[4].type).toBe('identifier');
   });
 
   it('should handle error with unterminated string', function() {
     var lexer = new Lexer("alias(metric, 'asd)");
     var tokens = lexer.tokenize();
-    expect(tokens[0].value).to.be('alias');
-    expect(tokens[1].value).to.be('(');
-    expect(tokens[2].value).to.be('metric');
-    expect(tokens[3].value).to.be(',');
-    expect(tokens[4].type).to.be('string');
-    expect(tokens[4].isUnclosed).to.be(true);
-    expect(tokens[4].pos).to.be(20);
+    expect(tokens[0].value).toBe('alias');
+    expect(tokens[1].value).toBe('(');
+    expect(tokens[2].value).toBe('metric');
+    expect(tokens[3].value).toBe(',');
+    expect(tokens[4].type).toBe('string');
+    expect(tokens[4].isUnclosed).toBe(true);
+    expect(tokens[4].pos).toBe(20);
   });
 
   it('should handle float parameters', function() {
     var lexer = new Lexer("alias(metric, 0.002)");
     var tokens = lexer.tokenize();
-    expect(tokens[4].type).to.be('number');
-    expect(tokens[4].value).to.be('0.002');
+    expect(tokens[4].type).toBe('number');
+    expect(tokens[4].value).toBe('0.002');
   });
 
   it('should handle bool parameters', function() {
     var lexer = new Lexer("alias(metric, true, false)");
     var tokens = lexer.tokenize();
-    expect(tokens[4].type).to.be('bool');
-    expect(tokens[4].value).to.be('true');
-    expect(tokens[6].type).to.be('bool');
+    expect(tokens[4].type).toBe('bool');
+    expect(tokens[4].value).toBe('true');
+    expect(tokens[6].type).toBe('bool');
   });
 });

public/app/plugins/datasource/graphite/specs/parser.jest.ts

@@ -0,0 +1,182 @@
+import {Parser} from '../parser';
+
+describe('when parsing', function() {
+
+  it('simple metric expression', function() {
+    var parser = new Parser('metric.test.*.asd.count');
+    var rootNode = parser.getAst();
+
+    expect(rootNode.type).toBe('metric');
+    expect(rootNode.segments.length).toBe(5);
+    expect(rootNode.segments[0].value).toBe('metric');
+  });
+
+  it('simple metric expression with numbers in segments', function() {
+    var parser = new Parser('metric.10.15_20.5');
+    var rootNode = parser.getAst();
+
+    expect(rootNode.type).toBe('metric');
+    expect(rootNode.segments.length).toBe(4);
+    expect(rootNode.segments[1].value).toBe('10');
+    expect(rootNode.segments[2].value).toBe('15_20');
+    expect(rootNode.segments[3].value).toBe('5');
+  });
+
+  it('simple metric expression with curly braces', function() {
+    var parser = new Parser('metric.se1-{count, max}');
+    var rootNode = parser.getAst();
+
+    expect(rootNode.type).toBe('metric');
+    expect(rootNode.segments.length).toBe(2);
+    expect(rootNode.segments[1].value).toBe('se1-{count,max}');
+  });
+
+  it('simple metric expression with curly braces at start of segment and with post chars', function() {
+    var parser = new Parser('metric.{count, max}-something.count');
+    var rootNode = parser.getAst();
+
+    expect(rootNode.type).toBe('metric');
+    expect(rootNode.segments.length).toBe(3);
+    expect(rootNode.segments[1].value).toBe('{count,max}-something');
+  });
+
+  it('simple function', function() {
+    var parser = new Parser('sum(test)');
+    var rootNode = parser.getAst();
+    expect(rootNode.type).toBe('function');
+    expect(rootNode.params.length).toBe(1);
+  });
+
+  it('simple function2', function() {
+    var parser = new Parser('offset(test.metric, -100)');
+    var rootNode = parser.getAst();
+    expect(rootNode.type).toBe('function');
+    expect(rootNode.params[0].type).toBe('metric');
+    expect(rootNode.params[1].type).toBe('number');
+  });
+
+  it('simple function with string arg', function() {
+    var parser = new Parser("randomWalk('test')");
+    var rootNode = parser.getAst();
+    expect(rootNode.type).toBe('function');
+    expect(rootNode.params.length).toBe(1);
+    expect(rootNode.params[0].type).toBe('string');
+  });
+
+  it('function with multiple args', function() {
+    var parser = new Parser("sum(test, 1, 'test')");
+    var rootNode = parser.getAst();
+
+    expect(rootNode.type).toBe('function');
+    expect(rootNode.params.length).toBe(3);
+    expect(rootNode.params[0].type).toBe('metric');
+    expect(rootNode.params[1].type).toBe('number');
+    expect(rootNode.params[2].type).toBe('string');
+  });
+
+  it('function with nested function', function() {
+    var parser = new Parser("sum(scaleToSeconds(test, 1))");
+    var rootNode = parser.getAst();
+
+    expect(rootNode.type).toBe('function');
+    expect(rootNode.params.length).toBe(1);
+    expect(rootNode.params[0].type).toBe('function');
+    expect(rootNode.params[0].name).toBe('scaleToSeconds');
+    expect(rootNode.params[0].params.length).toBe(2);
+    expect(rootNode.params[0].params[0].type).toBe('metric');
+    expect(rootNode.params[0].params[1].type).toBe('number');
+  });
+
+  it('function with multiple series', function() {
+    var parser = new Parser("sum(test.test.*.count, test.timers.*.count)");
+    var rootNode = parser.getAst();
+
+    expect(rootNode.type).toBe('function');
+    expect(rootNode.params.length).toBe(2);
+    expect(rootNode.params[0].type).toBe('metric');
+    expect(rootNode.params[1].type).toBe('metric');
+  });
+
+  it('function with templated series', function() {
+    var parser = new Parser("sum(test.[[server]].count)");
+    var rootNode = parser.getAst();
+
+    expect(rootNode.message).toBe(undefined);
+    expect(rootNode.params[0].type).toBe('metric');
+    expect(rootNode.params[0].segments[1].type).toBe('segment');
+    expect(rootNode.params[0].segments[1].value).toBe('[[server]]');
+  });
+
+  it('invalid metric expression', function() {
+    var parser = new Parser('metric.test.*.asd.');
+    var rootNode = parser.getAst();
+
+    expect(rootNode.message).toBe('Expected metric identifier instead found end of string');
+    expect(rootNode.pos).toBe(19);
+  });
+
+  it('invalid function expression missing closing parenthesis', function() {
+    var parser = new Parser('sum(test');
+    var rootNode = parser.getAst();
+
+    expect(rootNode.message).toBe('Expected closing parenthesis instead found end of string');
+    expect(rootNode.pos).toBe(9);
+  });
+
+  it('unclosed string in function', function() {
+    var parser = new Parser("sum('test)");
+    var rootNode = parser.getAst();
+
+    expect(rootNode.message).toBe('Unclosed string parameter');
+    expect(rootNode.pos).toBe(11);
+  });
+
+  it('handle issue #69', function() {
+    var parser = new Parser('cactiStyle(offset(scale(net.192-168-1-1.192-168-1-9.ping_value.*,0.001),-100))');
+    var rootNode = parser.getAst();
+    expect(rootNode.type).toBe('function');
+  });
+
+  it('handle float function arguments', function() {
+    var parser = new Parser('scale(test, 0.002)');
+    var rootNode = parser.getAst();
+    expect(rootNode.type).toBe('function');
+    expect(rootNode.params[1].type).toBe('number');
+    expect(rootNode.params[1].value).toBe(0.002);
+  });
+
+  it('handle curly brace pattern at start', function() {
+    var parser = new Parser('{apps}.test');
+    var rootNode = parser.getAst();
+    expect(rootNode.type).toBe('metric');
+    expect(rootNode.segments[0].value).toBe('{apps}');
+    expect(rootNode.segments[1].value).toBe('test');
+  });
+
+  it('series parameters', function() {
+    var parser = new Parser('asPercent(#A, #B)');
+    var rootNode = parser.getAst();
+    expect(rootNode.type).toBe('function');
+    expect(rootNode.params[0].type).toBe('series-ref');
+    expect(rootNode.params[0].value).toBe('#A');
+    expect(rootNode.params[1].value).toBe('#B');
+  });
+
+  it('series parameters, issue 2788', function() {
+    var parser = new Parser("summarize(diffSeries(#A, #B), '10m', 'sum', false)");
+    var rootNode = parser.getAst();
+    expect(rootNode.type).toBe('function');
+    expect(rootNode.params[0].type).toBe('function');
+    expect(rootNode.params[1].value).toBe('10m');
+    expect(rootNode.params[3].type).toBe('bool');
+  });
+
+  it('should parse metric expression with ip number segments', function() {
+    var parser = new Parser('5.10.123.5');
+    var rootNode = parser.getAst();
+    expect(rootNode.segments[0].value).toBe('5');
+    expect(rootNode.segments[1].value).toBe('10');
+    expect(rootNode.segments[2].value).toBe('123');
+    expect(rootNode.segments[3].value).toBe('5');
+  });
+});

public/app/plugins/datasource/graphite/specs/parser_specs.ts

@@ -1,183 +0,0 @@
-import {describe, it, expect} from 'test/lib/common';
-import {Parser} from '../parser';
-
-describe('when parsing', function() {
-
-  it('simple metric expression', function() {
-    var parser = new Parser('metric.test.*.asd.count');
-    var rootNode = parser.getAst();
-
-    expect(rootNode.type).to.be('metric');
-    expect(rootNode.segments.length).to.be(5);
-    expect(rootNode.segments[0].value).to.be('metric');
-  });
-
-  it('simple metric expression with numbers in segments', function() {
-    var parser = new Parser('metric.10.15_20.5');
-    var rootNode = parser.getAst();
-
-    expect(rootNode.type).to.be('metric');
-    expect(rootNode.segments.length).to.be(4);
-    expect(rootNode.segments[1].value).to.be('10');
-    expect(rootNode.segments[2].value).to.be('15_20');
-    expect(rootNode.segments[3].value).to.be('5');
-  });
-
-  it('simple metric expression with curly braces', function() {
-    var parser = new Parser('metric.se1-{count, max}');
-    var rootNode = parser.getAst();
-
-    expect(rootNode.type).to.be('metric');
-    expect(rootNode.segments.length).to.be(2);
-    expect(rootNode.segments[1].value).to.be('se1-{count,max}');
-  });
-
-  it('simple metric expression with curly braces at start of segment and with post chars', function() {
-    var parser = new Parser('metric.{count, max}-something.count');
-    var rootNode = parser.getAst();
-
-    expect(rootNode.type).to.be('metric');
-    expect(rootNode.segments.length).to.be(3);
-    expect(rootNode.segments[1].value).to.be('{count,max}-something');
-  });
-
-  it('simple function', function() {
-    var parser = new Parser('sum(test)');
-    var rootNode = parser.getAst();
-    expect(rootNode.type).to.be('function');
-    expect(rootNode.params.length).to.be(1);
-  });
-
-  it('simple function2', function() {
-    var parser = new Parser('offset(test.metric, -100)');
-    var rootNode = parser.getAst();
-    expect(rootNode.type).to.be('function');
-    expect(rootNode.params[0].type).to.be('metric');
-    expect(rootNode.params[1].type).to.be('number');
-  });
-
-  it('simple function with string arg', function() {
-    var parser = new Parser("randomWalk('test')");
-    var rootNode = parser.getAst();
-    expect(rootNode.type).to.be('function');
-    expect(rootNode.params.length).to.be(1);
-    expect(rootNode.params[0].type).to.be('string');
-  });
-
-  it('function with multiple args', function() {
-    var parser = new Parser("sum(test, 1, 'test')");
-    var rootNode = parser.getAst();
-
-    expect(rootNode.type).to.be('function');
-    expect(rootNode.params.length).to.be(3);
-    expect(rootNode.params[0].type).to.be('metric');
-    expect(rootNode.params[1].type).to.be('number');
-    expect(rootNode.params[2].type).to.be('string');
-  });
-
-  it('function with nested function', function() {
-    var parser = new Parser("sum(scaleToSeconds(test, 1))");
-    var rootNode = parser.getAst();
-
-    expect(rootNode.type).to.be('function');
-    expect(rootNode.params.length).to.be(1);
-    expect(rootNode.params[0].type).to.be('function');
-    expect(rootNode.params[0].name).to.be('scaleToSeconds');
-    expect(rootNode.params[0].params.length).to.be(2);
-    expect(rootNode.params[0].params[0].type).to.be('metric');
-    expect(rootNode.params[0].params[1].type).to.be('number');
-  });
-
-  it('function with multiple series', function() {
-    var parser = new Parser("sum(test.test.*.count, test.timers.*.count)");
-    var rootNode = parser.getAst();
-
-    expect(rootNode.type).to.be('function');
-    expect(rootNode.params.length).to.be(2);
-    expect(rootNode.params[0].type).to.be('metric');
-    expect(rootNode.params[1].type).to.be('metric');
-  });
-
-  it('function with templated series', function() {
-    var parser = new Parser("sum(test.[[server]].count)");
-    var rootNode = parser.getAst();
-
-    expect(rootNode.message).to.be(undefined);
-    expect(rootNode.params[0].type).to.be('metric');
-    expect(rootNode.params[0].segments[1].type).to.be('segment');
-    expect(rootNode.params[0].segments[1].value).to.be('[[server]]');
-  });
-
-  it('invalid metric expression', function() {
-    var parser = new Parser('metric.test.*.asd.');
-    var rootNode = parser.getAst();
-
-    expect(rootNode.message).to.be('Expected metric identifier instead found end of string');
-    expect(rootNode.pos).to.be(19);
-  });
-
-  it('invalid function expression missing closing parenthesis', function() {
-    var parser = new Parser('sum(test');
-    var rootNode = parser.getAst();
-
-    expect(rootNode.message).to.be('Expected closing parenthesis instead found end of string');
-    expect(rootNode.pos).to.be(9);
-  });
-
-  it('unclosed string in function', function() {
-    var parser = new Parser("sum('test)");
-    var rootNode = parser.getAst();
-
-    expect(rootNode.message).to.be('Unclosed string parameter');
-    expect(rootNode.pos).to.be(11);
-  });
-
-  it('handle issue #69', function() {
-    var parser = new Parser('cactiStyle(offset(scale(net.192-168-1-1.192-168-1-9.ping_value.*,0.001),-100))');
-    var rootNode = parser.getAst();
-    expect(rootNode.type).to.be('function');
-  });
-
-  it('handle float function arguments', function() {
-    var parser = new Parser('scale(test, 0.002)');
-    var rootNode = parser.getAst();
-    expect(rootNode.type).to.be('function');
-    expect(rootNode.params[1].type).to.be('number');
-    expect(rootNode.params[1].value).to.be(0.002);
-  });
-
-  it('handle curly brace pattern at start', function() {
-    var parser = new Parser('{apps}.test');
-    var rootNode = parser.getAst();
-    expect(rootNode.type).to.be('metric');
-    expect(rootNode.segments[0].value).to.be('{apps}');
-    expect(rootNode.segments[1].value).to.be('test');
-  });
-
-  it('series parameters', function() {
-    var parser = new Parser('asPercent(#A, #B)');
-    var rootNode = parser.getAst();
-    expect(rootNode.type).to.be('function');
-    expect(rootNode.params[0].type).to.be('series-ref');
-    expect(rootNode.params[0].value).to.be('#A');
-    expect(rootNode.params[1].value).to.be('#B');
-  });
-
-  it('series parameters, issue 2788', function() {
-    var parser = new Parser("summarize(diffSeries(#A, #B), '10m', 'sum', false)");
-    var rootNode = parser.getAst();
-    expect(rootNode.type).to.be('function');
-    expect(rootNode.params[0].type).to.be('function');
-    expect(rootNode.params[1].value).to.be('10m');
-    expect(rootNode.params[3].type).to.be('bool');
-  });
-
-  it('should parse metric expression with ip number segments', function() {
-    var parser = new Parser('5.10.123.5');
-    var rootNode = parser.getAst();
-    expect(rootNode.segments[0].value).to.be('5');
-    expect(rootNode.segments[1].value).to.be('10');
-    expect(rootNode.segments[2].value).to.be('123');
-    expect(rootNode.segments[3].value).to.be('5');
-  });
-});