diff --git a/Graphite.Test/Graphite.Test.csproj b/Graphite.Test/Graphite.Test.csproj
index 011b71f..60586fa 100644
--- a/Graphite.Test/Graphite.Test.csproj
+++ b/Graphite.Test/Graphite.Test.csproj
@@ -1,136 +1,30 @@
-
-
+
+
- Debug
- AnyCPU
- {C4EB3065-0684-4CC2-8327-3429C5DE9C16}
- Library
- Properties
+ netcoreapp2.1;net461
+ false
ahd.Graphite.Test
ahd.Graphite.Test
- v4.6.1
- 512
- {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
- 10.0
- $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)
- $(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages
- False
- UnitTest
- SAK
- SAK
- SAK
- SAK
-
-
-
- true
- full
- false
- bin\Debug\
- DEBUG;TRACE
- prompt
- 4
+
+
true
+
-
- pdbonly
- true
- bin\Release\
- TRACE
- prompt
- 4
- true
+
+
true
+
+
-
- ..\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dll
- True
-
-
- ..\packages\Razorvine.Pyrolite.4.16.0\lib\net40\Razorvine.Pyrolite.dll
- True
-
-
- ..\packages\Razorvine.Serpent.1.16.0\lib\net40\Razorvine.Serpent.dll
- True
-
-
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
+
-
-
-
-
-
- True
- True
- Settings.settings
-
+
-
-
- {05530EED-1658-4F66-8E42-796FF449AEA4}
- Graphite
-
-
-
-
- Designer
-
-
- Designer
-
-
- SettingsSingleFileGenerator
- Settings.Designer.cs
-
-
-
-
-
-
- False
-
-
- False
-
-
- False
-
-
- False
-
-
-
-
-
-
-
-
-
- Dieses Projekt verweist auf mindestens ein NuGet-Paket, das auf diesem Computer fehlt. Verwenden Sie die Wiederherstellung von NuGet-Paketen, um die fehlenden Dateien herunterzuladen. Weitere Informationen finden Sie unter "http://go.microsoft.com/fwlink/?LinkID=322105". Die fehlende Datei ist "{0}".
-
-
-
-
-
\ No newline at end of file
+
+
diff --git a/Graphite.Test/GraphiteClientTest.cs b/Graphite.Test/GraphiteClientTest.cs
index 2bd4bd7..5d1fc2d 100644
--- a/Graphite.Test/GraphiteClientTest.cs
+++ b/Graphite.Test/GraphiteClientTest.cs
@@ -7,23 +7,24 @@
using System.Text;
using System.Threading.Tasks;
using ahd.Graphite.Base;
-using ahd.Graphite.Test.Properties;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
using Newtonsoft.Json;
using Razorvine.Pickle;
+using Xunit;
+using Xunit.Sdk;
namespace ahd.Graphite.Test
{
- [TestClass]
public class GraphiteClientTest
{
- [TestMethod]
+ private static readonly string GraphiteHost = "example.com";
+
+ [Fact]
public void CanCreateClient()
{
var client = new GraphiteClient();
}
- [TestMethod]
+ [Fact]
public void CanPickle()
{
var pickler = new Pickler();
@@ -43,28 +44,28 @@ public void CanPickle()
}
}
- [TestMethod]
+ [Fact]
public void ClientHasSaneDefaultValues()
{
var client = new GraphiteClient();
- Assert.AreEqual(2003, client.Formatter.Port);
- Assert.IsInstanceOfType(client.Formatter, typeof(PlaintextGraphiteFormatter));
- Assert.AreEqual("localhost", client.Host);
+ Assert.Equal(2003, client.Formatter.Port);
+ Assert.IsType(client.Formatter);
+ Assert.Equal("localhost", client.Host);
}
- [TestMethod]
+ [Fact]
public void CanCreateClientWithParams()
{
- var client = new GraphiteClient(Settings.Default.GraphiteHost);
- Assert.AreEqual(Settings.Default.GraphiteHost, client.Host);
+ var client = new GraphiteClient(GraphiteHost);
+ Assert.Equal(GraphiteHost, client.Host);
- client = new GraphiteClient(Settings.Default.GraphiteHost, new TestGraphiteFormatter(2004));
- Assert.AreEqual(Settings.Default.GraphiteHost, client.Host);
- Assert.AreEqual(2004, client.Formatter.Port);
- Assert.IsInstanceOfType(client.Formatter, typeof(TestGraphiteFormatter));
+ client = new GraphiteClient(GraphiteHost, new TestGraphiteFormatter(2004));
+ Assert.Equal(GraphiteHost, client.Host);
+ Assert.Equal(2004, client.Formatter.Port);
+ Assert.IsType(client.Formatter);
}
- [TestMethod]
+ [Fact]
public async Task CanSendMetric()
{
var server = new TcpListener(new IPEndPoint(IPAddress.Loopback, 33225));
@@ -74,16 +75,16 @@ public async Task CanSendMetric()
var sendTask = client.SendAsync("usage.unittest.cpu.count", Environment.ProcessorCount);
await sendTask;
var metric = await recvTask;
- Assert.IsTrue(metric.Contains("usage.unittest.cpu.count"));
+ Assert.Contains("usage.unittest.cpu.count", metric);
server.Stop();
Console.WriteLine(metric);
}
- [TestMethod]
+ [Fact]
public void DataPointConversion()
{
var data = new Datapoint("test", 0, 1451338593);
- Assert.AreEqual(1451338593,data.UnixTimestamp);
+ Assert.Equal(1451338593,data.UnixTimestamp);
}
private async Task ReceiveMetric(TcpListener server)
@@ -97,25 +98,25 @@ private async Task ReceiveMetric(TcpListener server)
}
- [TestMethod]
- [TestCategory("Integration")]
+ [Fact]
+ [Trait("Category", "Integration")]
public async Task SendMetric()
{
- var client = new GraphiteClient(Settings.Default.GraphiteHost);
+ var client = new GraphiteClient(GraphiteHost);
await client.SendAsync("usage.unittest.cpu.count", Environment.ProcessorCount);
Console.WriteLine("done");
}
- [TestMethod]
- [TestCategory("Integration")]
+ [Fact]
+ [Trait("Category", "Integration")]
public async Task SendPickledMetric()
{
- var client = new GraphiteClient(Settings.Default.GraphiteHost, new PickleGraphiteFormatter());
+ var client = new GraphiteClient(GraphiteHost, new PickleGraphiteFormatter());
await client.SendAsync("usage.unittest.pickled.cpu.count", Environment.ProcessorCount);
}
- [TestMethod]
- [TestCategory("Integration")]
+ [Fact]
+ [Trait("Category", "Integration")]
public async Task CanSendToV6OnlyHost()
{
var client = new GraphiteClient("ipv6.test-ipv6.com", new PlaintextGraphiteFormatter(80));
@@ -123,8 +124,8 @@ public async Task CanSendToV6OnlyHost()
client.Send("usage.unittest.cpu.count", 1);
}
- [TestMethod]
- [TestCategory("Integration")]
+ [Fact]
+ [Trait("Category", "Integration")]
public async Task CanSendToV4OnlyHost()
{
var client = new GraphiteClient("test-ipv6.com", new PlaintextGraphiteFormatter(80));
@@ -145,104 +146,104 @@ public TestGraphiteFormatter():base()
}
}
- [TestMethod]
- [TestCategory("Integration")]
+ [Fact]
+ [Trait("Category", "Integration")]
public async Task CanGetAllMetrics()
{
- var client = new GraphiteClient(Settings.Default.GraphiteHost);
+ var client = new GraphiteClient(GraphiteHost);
var metrics = await client.GetAllMetricsAsync();
- Assert.IsNotNull(metrics);
- Assert.AreNotEqual(0, metrics.Length);
- Assert.IsFalse(String.IsNullOrEmpty(metrics[0]));
+ Assert.NotNull(metrics);
+ Assert.NotEmpty(metrics);
+ Assert.False(String.IsNullOrEmpty(metrics[0]));
}
- [TestMethod]
- [TestCategory("Integration")]
+ [Fact]
+ [Trait("Category", "Integration")]
public async Task CanFindMetric()
{
- var client = new GraphiteClient(Settings.Default.GraphiteHost);
+ var client = new GraphiteClient(GraphiteHost);
var metrics = await client.FindMetricsAsync("usage.unittest.*");
- Assert.IsNotNull(metrics);
- Assert.AreNotEqual(0, metrics.Length);
- Assert.IsTrue(metrics.All(x=>x.Id.StartsWith("usage.unittest.")));
+ Assert.NotNull(metrics);
+ Assert.NotEmpty(metrics);
+ Assert.True(metrics.All(x=>x.Id.StartsWith("usage.unittest.")));
}
- [TestMethod]
- [TestCategory("Integration")]
+ [Fact]
+ [Trait("Category", "Integration")]
public async Task CanExpandMetrics()
{
- var client = new GraphiteClient(Settings.Default.GraphiteHost);
+ var client = new GraphiteClient(GraphiteHost);
var path1 = new GraphitePath("usage").Dot("unittest").Dot("iaas").DotWildcard().DotWildcard().DotWildcard();
var path2 = new GraphitePath("usage").Dot("unittest").Dot("license").DotWildcard();
var metrics = await client.ExpandMetricsAsync(path1, path2);
- Assert.IsNotNull(metrics);
- Assert.AreNotEqual(0, metrics.Length);
- Assert.IsTrue(metrics.All(x=>x.StartsWith("usage.unittest.")));
- Assert.IsTrue(metrics.Any(x=>x.StartsWith("usage.unittest.iaas.")));
- Assert.IsTrue(metrics.Any(x=>x.StartsWith("usage.unittest.license.")));
+ Assert.NotNull(metrics);
+ Assert.NotEmpty(metrics);
+ Assert.True(metrics.All(x=>x.StartsWith("usage.unittest.")));
+ Assert.Contains(metrics, x =>x.StartsWith("usage.unittest.iaas."));
+ Assert.Contains(metrics, x =>x.StartsWith("usage.unittest.license."));
}
- [TestMethod]
+ [Fact]
public void CanDeserializeMetrics()
{
var json = "{\"is_leaf\": \"0\", \"name\": \"pickled\", \"path\": \"usage.unittest.pickled.\"}";
var metric = JsonConvert.DeserializeObject(json);
- Assert.AreEqual("usage.unittest.pickled", metric.Id);
- Assert.AreEqual("pickled", metric.Text);
- Assert.IsFalse(metric.Leaf);
- Assert.IsTrue(metric.Expandable);
+ Assert.Equal("usage.unittest.pickled", metric.Id);
+ Assert.Equal("pickled", metric.Text);
+ Assert.False(metric.Leaf);
+ Assert.True(metric.Expandable);
}
- [TestMethod]
+ [Fact]
public void CanDeserializeMetricsData()
{
var json = "{\"target\": \"usage.unittest.cpu.count\", \"datapoints\": [[3.5, 1474716420], [null, 1474716480], [null, 1474716540], [0, 1474716600], [7.0, 1474716660], [null, 1474716720], [null, 1474716780]]}";
var data = JsonConvert.DeserializeObject(json);
- Assert.AreEqual("usage.unittest.cpu.count", data.Target);
- Assert.IsNotNull(data.Datapoints);
- Assert.AreEqual(7,data.Datapoints.Length);
+ Assert.Equal("usage.unittest.cpu.count", data.Target);
+ Assert.NotNull(data.Datapoints);
+ Assert.Equal(7,data.Datapoints.Length);
var value = data.Datapoints[0];
- Assert.AreEqual(3.5, value.Value);
- Assert.AreEqual(1474716420, value.UnixTimestamp);
- Assert.AreEqual(new DateTime(2016, 09, 24, 11, 27, 0), value.Timestamp);
+ Assert.Equal(3.5, value.Value);
+ Assert.Equal(1474716420, value.UnixTimestamp);
+ Assert.Equal(new DateTime(2016, 09, 24, 11, 27, 0), value.Timestamp);
}
- [TestMethod]
+ [Fact]
public void CanSerialize()
{
var datapoint = new MetricDatapoint(null, 987654321);
var json = JsonConvert.SerializeObject(datapoint);
- Assert.AreEqual("[null,987654321]", json);
+ Assert.Equal("[null,987654321]", json);
var datapoint2 = new MetricDatapoint(5, 123456789);
json = JsonConvert.SerializeObject(datapoint2);
- Assert.AreEqual("[5.0,123456789]", json);
+ Assert.Equal("[5.0,123456789]", json);
var metricData = new GraphiteMetricData("unit.test", new[] { datapoint2, datapoint });
json = JsonConvert.SerializeObject(metricData);
- Assert.AreEqual("{\"target\":\"unit.test\",\"datapoints\":[[5.0,123456789],[null,987654321]]}", json);
+ Assert.Equal("{\"target\":\"unit.test\",\"datapoints\":[[5.0,123456789],[null,987654321]]}", json);
}
- [TestMethod]
- [TestCategory("Integration")]
+ [Fact]
+ [Trait("Category", "Integration")]
public async Task CanGetMetricValues()
{
- var client = new GraphiteClient(Settings.Default.GraphiteHost);
+ var client = new GraphiteClient(GraphiteHost);
var metric = new GraphitePath("usage").Dot("unittest").Dot("iaas").DotWildcard().Dot("cpu").Dot("max");
var data = await client.GetMetricsDataAsync(metric);
- Assert.IsNotNull(data);
+ Assert.NotNull(data);
var series = data.FirstOrDefault();
- Assert.IsNotNull(series);
- Assert.IsNotNull(series.Datapoints);
- Assert.AreNotEqual(0, series.Datapoints.Length);
- Assert.IsTrue(series.Datapoints.Any(x=>x.Value.HasValue));
- Assert.IsTrue(series.Datapoints.All(x=>x.Timestamp < DateTime.Now));
+ Assert.NotNull(series);
+ Assert.NotNull(series.Datapoints);
+ Assert.NotEmpty(series.Datapoints);
+ Assert.Contains(series.Datapoints, x =>x.Value.HasValue);
+ Assert.True(series.Datapoints.All(x=>x.Timestamp < DateTime.Now));
}
- [TestMethod]
+ [Fact]
public async Task CanQueryLongFormulas()
{
- var client = new GraphiteClient(Settings.Default.GraphiteHost){UseSsl = false};
+ var client = new GraphiteClient(GraphiteHost){UseSsl = false};
var metrics = new SeriesListBase[768];
for (int i = 0; i < metrics.Length; i++)
{
@@ -254,8 +255,7 @@ public async Task CanQueryLongFormulas()
.Alias(i.ToString());
}
var metric = metrics.Sum();
- if (metric.ToString().Length < UInt16.MaxValue)
- Assert.Inconclusive("request too short to fail");
+ Assert.True(metric.ToString().Length > UInt16.MaxValue, "request too short to fail");
try
{
await client.GetMetricsDataAsync(metric);
diff --git a/Graphite.Test/GraphiteFunctionsTest.cs b/Graphite.Test/GraphiteFunctionsTest.cs
index df26f9c..daff01c 100644
--- a/Graphite.Test/GraphiteFunctionsTest.cs
+++ b/Graphite.Test/GraphiteFunctionsTest.cs
@@ -2,774 +2,773 @@
using System.Collections.Generic;
using ahd.Graphite.Base;
using ahd.Graphite.Functions;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
namespace ahd.Graphite.Test
{
- [TestClass]
public class GraphiteFunctionsTest
{
private readonly SeriesListBase _series = new GraphitePath("metric");
- [TestMethod]
+ [Fact]
public void Alias()
{
var alias = _series.Alias("Foo");
- Assert.AreEqual("alias(metric,\"Foo\")", alias.ToString());
+ Assert.Equal("alias(metric,\"Foo\")", alias.ToString());
}
- [TestMethod]
+ [Fact]
public void Absolute()
{
var absolute = _series.Absolute();
- Assert.AreEqual("absolute(metric)", absolute.ToString());
+ Assert.Equal("absolute(metric)", absolute.ToString());
}
- [TestMethod]
+ [Fact]
public void AggregateLine()
{
var aggregateLine = _series.AggregateLine();
- Assert.AreEqual("aggregateLine(metric,'avg')", aggregateLine.ToString());
+ Assert.Equal("aggregateLine(metric,'avg')", aggregateLine.ToString());
}
- [TestMethod]
+ [Fact]
public void AliasByMetric()
{
var aliasByMetric = _series.AliasByMetric();
- Assert.AreEqual("aliasByMetric(metric)", aliasByMetric.ToString());
+ Assert.Equal("aliasByMetric(metric)", aliasByMetric.ToString());
}
- [TestMethod]
+ [Fact]
public void AliasByNode()
{
var aliasByNode = _series.AliasByNode(1, 4);
- Assert.AreEqual("aliasByNode(metric,1,4)", aliasByNode.ToString());
+ Assert.Equal("aliasByNode(metric,1,4)", aliasByNode.ToString());
}
- [TestMethod]
+ [Fact]
public void AliasSub()
{
var aliasSub = _series.AliasSub("^.*TCP(\\d+)", "\\1");
- Assert.AreEqual("aliasSub(metric,\"^.*TCP(\\d+)\",\"\\1\")", aliasSub.ToString());
+ Assert.Equal("aliasSub(metric,\"^.*TCP(\\d+)\",\"\\1\")", aliasSub.ToString());
}
- [TestMethod]
+ [Fact]
public void ApplyByNode()
{
var innerCalc = GraphitePath.Parse("%.disk.bytes_free")
.DivideSeries(GraphitePath.Parse("%.disk.bytes_*").SumSeriesWithWildcards());
var applyByNode = GraphitePath.Parse("servers.*.disk.bytes_free").ApplyByNode(1, innerCalc);
- Assert.AreEqual("applyByNode(servers.*.disk.bytes_free,1,\"divideSeries(%.disk.bytes_free,sumSeriesWithWildcards(%.disk.bytes_*))\")", applyByNode.ToString());
+ Assert.Equal("applyByNode(servers.*.disk.bytes_free,1,\"divideSeries(%.disk.bytes_free,sumSeriesWithWildcards(%.disk.bytes_*))\")", applyByNode.ToString());
}
- [TestMethod]
+ [Fact]
public void AsPercent()
{
var asPercent = _series.AsPercent(1500);
- Assert.AreEqual("asPercent(metric,1500)", asPercent.ToString());
+ Assert.Equal("asPercent(metric,1500)", asPercent.ToString());
asPercent = _series.AsPercent(_series);
- Assert.AreEqual("asPercent(metric,metric)", asPercent.ToString());
+ Assert.Equal("asPercent(metric,metric)", asPercent.ToString());
asPercent = _series.AsPercent();
- Assert.AreEqual("asPercent(metric)", asPercent.ToString());
+ Assert.Equal("asPercent(metric)", asPercent.ToString());
}
- [TestMethod]
+ [Fact]
public void AverageAbove()
{
var averageAbove = _series.AverageAbove(5);
- Assert.AreEqual("averageAbove(metric,5)", averageAbove.ToString());
+ Assert.Equal("averageAbove(metric,5)", averageAbove.ToString());
averageAbove = _series.AverageAbove(1.1);
- Assert.AreEqual("averageAbove(metric,1.1)", averageAbove.ToString());
+ Assert.Equal("averageAbove(metric,1.1)", averageAbove.ToString());
}
- [TestMethod]
+ [Fact]
public void AverageBelow()
{
var averageBelow = _series.AverageBelow(5);
- Assert.AreEqual("averageBelow(metric,5)", averageBelow.ToString());
+ Assert.Equal("averageBelow(metric,5)", averageBelow.ToString());
averageBelow = _series.AverageBelow(1.1);
- Assert.AreEqual("averageBelow(metric,1.1)", averageBelow.ToString());
+ Assert.Equal("averageBelow(metric,1.1)", averageBelow.ToString());
}
- [TestMethod]
+ [Fact]
public void AverageOutsidePercentile()
{
var series = _series.AverageOutsidePercentile(5);
- Assert.AreEqual("averageOutsidePercentile(metric,5)", series.ToString());
+ Assert.Equal("averageOutsidePercentile(metric,5)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Avg()
{
var series = _series.Avg();
- Assert.AreEqual("avg(metric)", series.ToString());
+ Assert.Equal("avg(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void AverageSeriesWithWildcards()
{
var series = _series.AverageSeriesWithWildcards(1, 5);
- Assert.AreEqual("averageSeriesWithWildcards(metric,1,5)", series.ToString());
+ Assert.Equal("averageSeriesWithWildcards(metric,1,5)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Changed()
{
var series = _series.Changed();
- Assert.AreEqual("changed(metric)", series.ToString());
+ Assert.Equal("changed(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void ConsolidateBy()
{
var series = _series.ConsolidateBy(ConsolidateFunction.max);
- Assert.AreEqual("consolidateBy(metric,'max')", series.ToString());
+ Assert.Equal("consolidateBy(metric,'max')", series.ToString());
}
- [TestMethod]
+ [Fact]
public void CountSeries()
{
var series = _series.CountSeries();
- Assert.AreEqual("countSeries(metric)", series.ToString());
+ Assert.Equal("countSeries(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void CurrentAbove()
{
var series = _series.CurrentAbove(5);
- Assert.AreEqual("currentAbove(metric,5)", series.ToString());
+ Assert.Equal("currentAbove(metric,5)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void CurrentBelow()
{
var series = _series.CurrentBelow(5);
- Assert.AreEqual("currentBelow(metric,5)", series.ToString());
+ Assert.Equal("currentBelow(metric,5)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Delay()
{
var series = _series.Delay(5);
- Assert.AreEqual("delay(metric,5)", series.ToString());
+ Assert.Equal("delay(metric,5)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Derivative()
{
var series = _series.Derivative();
- Assert.AreEqual("derivative(metric)", series.ToString());
+ Assert.Equal("derivative(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void DiffSeries()
{
var series = _series.DiffSeries(_series);
- Assert.AreEqual("diffSeries(metric,metric)", series.ToString());
+ Assert.Equal("diffSeries(metric,metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void DivideSeries()
{
var series = _series.DivideSeries(_series);
- Assert.AreEqual("divideSeries(metric,metric)", series.ToString());
+ Assert.Equal("divideSeries(metric,metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Exclude()
{
var series = _series.Exclude("server02");
- Assert.AreEqual("exclude(metric,\"server02\")", series.ToString());
+ Assert.Equal("exclude(metric,\"server02\")", series.ToString());
}
- [TestMethod]
+ [Fact]
public void FallbackSeries()
{
var series = _series.FallbackSeries(new ConstantLineSeriesList(5));
- Assert.AreEqual("fallbackSeries(metric,constantLine(5))", series.ToString());
+ Assert.Equal("fallbackSeries(metric,constantLine(5))", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Grep()
{
var series = _series.Grep("server02");
- Assert.AreEqual("grep(metric,\"server02\")", series.ToString());
+ Assert.Equal("grep(metric,\"server02\")", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Group()
{
var series = _series.Group();
- Assert.AreEqual("group(metric)", series.ToString());
+ Assert.Equal("group(metric)", series.ToString());
var sumSeries = _series.Group(new GraphitePath("test1"), _series);
- Assert.AreEqual("group(metric,test1,metric)", sumSeries.ToString());
+ Assert.Equal("group(metric,test1,metric)", sumSeries.ToString());
var serie1 = _series.ConsolidateBy(ConsolidateFunction.max);
var serie2 = _series.ConsolidateBy(ConsolidateFunction.sum);
- Assert.AreEqual("group(consolidateBy(metric,'max'),consolidateBy(metric,'sum'))", new SeriesListBase[] {serie1, serie2}.Group().ToString());
+ Assert.Equal("group(consolidateBy(metric,'max'),consolidateBy(metric,'sum'))", new SeriesListBase[] {serie1, serie2}.Group().ToString());
IEnumerable sources = new[] { _series };
- Assert.AreEqual("group(metric)", sources.Group().ToString());
+ Assert.Equal("group(metric)", sources.Group().ToString());
}
- [TestMethod]
+ [Fact]
public void GroupByNode()
{
var series = _series.GroupByNode(2, x => x.Sum);
- Assert.AreEqual("groupByNode(metric,2,\"sum\")", series.ToString());
+ Assert.Equal("groupByNode(metric,2,\"sum\")", series.ToString());
}
- [TestMethod]
+ [Fact]
public void GroupByNodes()
{
var series = _series.GroupByNodes(x => x.Sum, 1, 4);
- Assert.AreEqual("groupByNodes(metric,\"sum\",1,4)", series.ToString());
+ Assert.Equal("groupByNodes(metric,\"sum\",1,4)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void HighestAverage()
{
var series = _series.HighestAverage(4);
- Assert.AreEqual("highestAverage(metric,4)", series.ToString());
+ Assert.Equal("highestAverage(metric,4)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void HighestCurrent()
{
var series = _series.HighestCurrent(4);
- Assert.AreEqual("highestCurrent(metric,4)", series.ToString());
+ Assert.Equal("highestCurrent(metric,4)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void HighestMax()
{
var series = _series.HighestMax(4);
- Assert.AreEqual("highestMax(metric,4)", series.ToString());
+ Assert.Equal("highestMax(metric,4)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Hitcount()
{
var series = _series.Hitcount("day", alignToInterval: false);
- Assert.AreEqual("hitcount(metric,\"day\",0)", series.ToString());
+ Assert.Equal("hitcount(metric,\"day\",0)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void HoltWintersAberration()
{
var series = _series.HoltWintersAberration();
- Assert.AreEqual("holtWintersAberration(metric,3)", series.ToString());
+ Assert.Equal("holtWintersAberration(metric,3)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void HoltWintersConfidenceArea()
{
var series = _series.HoltWintersConfidenceArea(4);
- Assert.AreEqual("holtWintersConfidenceArea(metric,4)", series.ToString());
+ Assert.Equal("holtWintersConfidenceArea(metric,4)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void HoltWintersConfidenceBands()
{
var series = _series.HoltWintersConfidenceBands(3);
- Assert.AreEqual("holtWintersConfidenceBands(metric,3)", series.ToString());
+ Assert.Equal("holtWintersConfidenceBands(metric,3)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void HoltWintersForecast()
{
var series = _series.HoltWintersForecast();
- Assert.AreEqual("holtWintersForecast(metric)", series.ToString());
+ Assert.Equal("holtWintersForecast(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Integral()
{
var series = _series.Integral();
- Assert.AreEqual("integral(metric)", series.ToString());
+ Assert.Equal("integral(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void IntegralByInterval()
{
var series = _series.IntegralByInterval("1d");
- Assert.AreEqual("integralByInterval(metric,\"1d\")", series.ToString());
+ Assert.Equal("integralByInterval(metric,\"1d\")", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Interpolate()
{
var series = _series.Interpolate(-1);
- Assert.AreEqual("interpolate(metric)", series.ToString());
+ Assert.Equal("interpolate(metric)", series.ToString());
series = _series.Interpolate();
- Assert.AreEqual("interpolate(metric)", series.ToString());
+ Assert.Equal("interpolate(metric)", series.ToString());
series = _series.Interpolate(10);
- Assert.AreEqual("interpolate(metric,10)", series.ToString());
+ Assert.Equal("interpolate(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Invert()
{
var series = _series.Invert();
- Assert.AreEqual("invert(metric)", series.ToString());
+ Assert.Equal("invert(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void IsNonNull()
{
var series = _series.IsNonNull();
- Assert.AreEqual("isNonNull(metric)", series.ToString());
+ Assert.Equal("isNonNull(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void KeepLastValue()
{
var series = _series.KeepLastValue(-1);
- Assert.AreEqual("keepLastValue(metric)", series.ToString());
+ Assert.Equal("keepLastValue(metric)", series.ToString());
series = _series.KeepLastValue();
- Assert.AreEqual("keepLastValue(metric)", series.ToString());
+ Assert.Equal("keepLastValue(metric)", series.ToString());
series = _series.KeepLastValue(10);
- Assert.AreEqual("keepLastValue(metric,10)", series.ToString());
+ Assert.Equal("keepLastValue(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Limit()
{
var series = _series.Limit(10);
- Assert.AreEqual("limit(metric,10)", series.ToString());
+ Assert.Equal("limit(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void LinearRegressionAnalysis()
{
var series = _series.LinearRegressionAnalysis();
- Assert.AreEqual("linearRegressionAnalysis(metric)", series.ToString());
+ Assert.Equal("linearRegressionAnalysis(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Logarithm()
{
var series = _series.Logarithm(10);
- Assert.AreEqual("logarithm(metric)", series.ToString());
+ Assert.Equal("logarithm(metric)", series.ToString());
series = _series.Logarithm();
- Assert.AreEqual("logarithm(metric)", series.ToString());
+ Assert.Equal("logarithm(metric)", series.ToString());
series = _series.Logarithm(2);
- Assert.AreEqual("logarithm(metric,2)", series.ToString());
+ Assert.Equal("logarithm(metric,2)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void LowestAverage()
{
var series = _series.LowestAverage(10);
- Assert.AreEqual("lowestAverage(metric,10)", series.ToString());
+ Assert.Equal("lowestAverage(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void LowestCurrent()
{
var series = _series.LowestCurrent(10);
- Assert.AreEqual("lowestCurrent(metric,10)", series.ToString());
+ Assert.Equal("lowestCurrent(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void MaxSeries()
{
var series = _series.MaxSeries();
- Assert.AreEqual("maxSeries(metric)", series.ToString());
+ Assert.Equal("maxSeries(metric)", series.ToString());
var sumSeries = _series.MaxSeries(new GraphitePath("test1"), new GraphitePath("test2"));
- Assert.AreEqual("maxSeries(metric,test1,test2)", sumSeries.ToString());
+ Assert.Equal("maxSeries(metric,test1,test2)", sumSeries.ToString());
var serie1 = _series.ConsolidateBy(ConsolidateFunction.max);
var serie2 = _series.ConsolidateBy(ConsolidateFunction.sum);
- Assert.AreEqual("maxSeries(consolidateBy(metric,'max'),consolidateBy(metric,'sum'))", new SeriesListBase[] { serie1, serie2 }.MaxSeries().ToString());
+ Assert.Equal("maxSeries(consolidateBy(metric,'max'),consolidateBy(metric,'sum'))", new SeriesListBase[] { serie1, serie2 }.MaxSeries().ToString());
IEnumerable sources = new[] { _series };
- Assert.AreEqual("maxSeries(metric)", sources.MaxSeries().ToString());
+ Assert.Equal("maxSeries(metric)", sources.MaxSeries().ToString());
}
- [TestMethod]
+ [Fact]
public void MaximumAbove()
{
var series = _series.MaximumAbove(10);
- Assert.AreEqual("maximumAbove(metric,10)", series.ToString());
+ Assert.Equal("maximumAbove(metric,10)", series.ToString());
series = _series.MaximumAbove(1.1);
- Assert.AreEqual("maximumAbove(metric,1.1)", series.ToString());
+ Assert.Equal("maximumAbove(metric,1.1)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void MaximumBelow()
{
var series = _series.MaximumBelow(10);
- Assert.AreEqual("maximumBelow(metric,10)", series.ToString());
+ Assert.Equal("maximumBelow(metric,10)", series.ToString());
series = _series.MaximumBelow(1.1);
- Assert.AreEqual("maximumBelow(metric,1.1)", series.ToString());
+ Assert.Equal("maximumBelow(metric,1.1)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void MinSeries()
{
var series = _series.MinSeries();
- Assert.AreEqual("minSeries(metric)", series.ToString());
+ Assert.Equal("minSeries(metric)", series.ToString());
var sumSeries = _series.MinSeries(new GraphitePath("test1"), new GraphitePath("test2"));
- Assert.AreEqual("minSeries(metric,test1,test2)", sumSeries.ToString());
+ Assert.Equal("minSeries(metric,test1,test2)", sumSeries.ToString());
var serie1 = _series.ConsolidateBy(ConsolidateFunction.max);
var serie2 = _series.ConsolidateBy(ConsolidateFunction.sum);
- Assert.AreEqual("minSeries(consolidateBy(metric,'max'),consolidateBy(metric,'sum'))", new SeriesListBase[] { serie1, serie2 }.MinSeries().ToString());
+ Assert.Equal("minSeries(consolidateBy(metric,'max'),consolidateBy(metric,'sum'))", new SeriesListBase[] { serie1, serie2 }.MinSeries().ToString());
IEnumerable sources = new[] { _series };
- Assert.AreEqual("minSeries(metric)", sources.MinSeries().ToString());
+ Assert.Equal("minSeries(metric)", sources.MinSeries().ToString());
}
- [TestMethod]
+ [Fact]
public void MinimumAbove()
{
var series = _series.MinimumAbove(10);
- Assert.AreEqual("minimumAbove(metric,10)", series.ToString());
+ Assert.Equal("minimumAbove(metric,10)", series.ToString());
series = _series.MinimumAbove(1.1);
- Assert.AreEqual("minimumAbove(metric,1.1)", series.ToString());
+ Assert.Equal("minimumAbove(metric,1.1)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void MinimumBelow()
{
var series = _series.MinimumBelow(10);
- Assert.AreEqual("minimumBelow(metric,10)", series.ToString());
+ Assert.Equal("minimumBelow(metric,10)", series.ToString());
series = _series.MinimumBelow(1.1);
- Assert.AreEqual("minimumBelow(metric,1.1)", series.ToString());
+ Assert.Equal("minimumBelow(metric,1.1)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void MostDeviant()
{
var series = _series.MostDeviant(10);
- Assert.AreEqual("mostDeviant(metric,10)", series.ToString());
+ Assert.Equal("mostDeviant(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void MovingAverage()
{
var series = _series.MovingAverage(10);
- Assert.AreEqual("movingAverage(metric,10)", series.ToString());
+ Assert.Equal("movingAverage(metric,10)", series.ToString());
series = _series.MovingAverage("5min");
- Assert.AreEqual("movingAverage(metric,'5min')", series.ToString());
+ Assert.Equal("movingAverage(metric,'5min')", series.ToString());
}
- [TestMethod]
+ [Fact]
public void MovingMedian()
{
var series = _series.MovingMedian(10);
- Assert.AreEqual("movingMedian(metric,10)", series.ToString());
+ Assert.Equal("movingMedian(metric,10)", series.ToString());
series = _series.MovingMedian("5min");
- Assert.AreEqual("movingMedian(metric,'5min')", series.ToString());
+ Assert.Equal("movingMedian(metric,'5min')", series.ToString());
}
- [TestMethod]
+ [Fact]
public void MultiplySeries()
{
var series = _series.MultiplySeries();
- Assert.AreEqual("multiplySeries(metric)", series.ToString());
+ Assert.Equal("multiplySeries(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void MultiplySeriesWithWildcards()
{
var series = _series.MultiplySeriesWithWildcards(1, 5);
- Assert.AreEqual("multiplySeriesWithWildcards(metric,1,5)", series.ToString());
+ Assert.Equal("multiplySeriesWithWildcards(metric,1,5)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void NPercentile()
{
var series = _series.NPercentile(10);
- Assert.AreEqual("nPercentile(metric,10)", series.ToString());
+ Assert.Equal("nPercentile(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void NonNegativeDerivative()
{
var series = _series.NonNegativeDerivative();
- Assert.AreEqual("nonNegativeDerivative(metric)", series.ToString());
+ Assert.Equal("nonNegativeDerivative(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Offset()
{
var series = _series.Offset(10);
- Assert.AreEqual("offset(metric,10)", series.ToString());
+ Assert.Equal("offset(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void OffsetToZero()
{
var series = _series.OffsetToZero();
- Assert.AreEqual("offsetToZero(metric)", series.ToString());
+ Assert.Equal("offsetToZero(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void PerSecond()
{
var series = _series.PerSecond();
- Assert.AreEqual("perSecond(metric)", series.ToString());
+ Assert.Equal("perSecond(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void PercentileOfSeries()
{
var series = _series.PercentileOfSeries(10, false);
- Assert.AreEqual("percentileOfSeries(metric,10)", series.ToString());
+ Assert.Equal("percentileOfSeries(metric,10)", series.ToString());
series = _series.PercentileOfSeries(10, true);
- Assert.AreEqual("percentileOfSeries(metric,10,1)", series.ToString());
+ Assert.Equal("percentileOfSeries(metric,10,1)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Pow()
{
var series = _series.Pow(10);
- Assert.AreEqual("pow(metric,10)", series.ToString());
+ Assert.Equal("pow(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void RangeOfSeries()
{
var series = _series.RangeOfSeries();
- Assert.AreEqual("rangeOfSeries(metric)", series.ToString());
+ Assert.Equal("rangeOfSeries(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void RemoveAbovePercentile()
{
var series = _series.RemoveAbovePercentile(10);
- Assert.AreEqual("removeAbovePercentile(metric,10)", series.ToString());
+ Assert.Equal("removeAbovePercentile(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void RemoveAboveValue()
{
var series = _series.RemoveAboveValue(10);
- Assert.AreEqual("removeAboveValue(metric,10)", series.ToString());
+ Assert.Equal("removeAboveValue(metric,10)", series.ToString());
series = _series.RemoveAboveValue(1.1);
- Assert.AreEqual("removeAboveValue(metric,1.1)", series.ToString());
+ Assert.Equal("removeAboveValue(metric,1.1)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void RemoveBelowPercentile()
{
var series = _series.RemoveBelowPercentile(10);
- Assert.AreEqual("removeBelowPercentile(metric,10)", series.ToString());
+ Assert.Equal("removeBelowPercentile(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void RemoveBelowValue()
{
var series = _series.RemoveBelowValue(10);
- Assert.AreEqual("removeBelowValue(metric,10)", series.ToString());
+ Assert.Equal("removeBelowValue(metric,10)", series.ToString());
series = _series.RemoveBelowValue(1.1);
- Assert.AreEqual("removeBelowValue(metric,1.1)", series.ToString());
+ Assert.Equal("removeBelowValue(metric,1.1)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void RemoveBetweenPercentile()
{
var series = _series.RemoveBetweenPercentile(10);
- Assert.AreEqual("removeBetweenPercentile(metric,10)", series.ToString());
+ Assert.Equal("removeBetweenPercentile(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void RemoveEmptySeries()
{
var series = _series.RemoveEmptySeries();
- Assert.AreEqual("removeEmptySeries(metric)", series.ToString());
+ Assert.Equal("removeEmptySeries(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Scale()
{
var series = _series.Scale(10);
- Assert.AreEqual("scale(metric,10)", series.ToString());
+ Assert.Equal("scale(metric,10)", series.ToString());
series = _series.Scale(1000.1);
- Assert.AreEqual("scale(metric,1000.1)", series.ToString());
+ Assert.Equal("scale(metric,1000.1)", series.ToString());
series = _series.Scale(0.0005);
- Assert.AreEqual("scale(metric,0.0005)", series.ToString());
+ Assert.Equal("scale(metric,0.0005)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void ScaleToSeconds()
{
var series = _series.ScaleToSeconds(10);
- Assert.AreEqual("scaleToSeconds(metric,10)", series.ToString());
+ Assert.Equal("scaleToSeconds(metric,10)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void SmartSummarize()
{
var series = _series.SmartSummarize("1day", x => x.Sum);
- Assert.AreEqual("smartSummarize(metric,'1day','sum')", series.ToString());
+ Assert.Equal("smartSummarize(metric,'1day','sum')", series.ToString());
}
- [TestMethod]
+ [Fact]
public void SortByMaxima()
{
var series = _series.SortByMaxima();
- Assert.AreEqual("sortByMaxima(metric)", series.ToString());
+ Assert.Equal("sortByMaxima(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void SortByMinima()
{
var series = _series.SortByMinima();
- Assert.AreEqual("sortByMinima(metric)", series.ToString());
+ Assert.Equal("sortByMinima(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void SortByName()
{
var series = _series.SortByName();
- Assert.AreEqual("sortByName(metric)", series.ToString());
+ Assert.Equal("sortByName(metric)", series.ToString());
series = _series.SortByName(true);
- Assert.AreEqual("sortByName(metric,1)", series.ToString());
+ Assert.Equal("sortByName(metric,1)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void SortByTotal()
{
var series = _series.SortByTotal();
- Assert.AreEqual("sortByTotal(metric)", series.ToString());
+ Assert.Equal("sortByTotal(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void SquareRoot()
{
var series = _series.SquareRoot();
- Assert.AreEqual("squareRoot(metric)", series.ToString());
+ Assert.Equal("squareRoot(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void StddevSeries()
{
var series = _series.StddevSeries();
- Assert.AreEqual("stddevSeries(metric)", series.ToString());
+ Assert.Equal("stddevSeries(metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Stdev()
{
var series = _series.Stdev(1, 0.3);
- Assert.AreEqual("stdev(metric,1,0.3)", series.ToString());
+ Assert.Equal("stdev(metric,1,0.3)", series.ToString());
series = _series.Stdev(1);
- Assert.AreEqual("stdev(metric,1)", series.ToString());
+ Assert.Equal("stdev(metric,1)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Substr()
{
var series = _series.Substr(2, 4);
- Assert.AreEqual("substr(metric,2,4)", series.ToString());
+ Assert.Equal("substr(metric,2,4)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Sum()
{
var series = _series.Sum();
- Assert.AreEqual("sum(metric)", series.ToString());
+ Assert.Equal("sum(metric)", series.ToString());
var sumSeries = _series.Sum(new GraphitePath("test1"), new GraphitePath("test2"));
- Assert.AreEqual("sum(metric,test1,test2)", sumSeries.ToString());
+ Assert.Equal("sum(metric,test1,test2)", sumSeries.ToString());
var serie1 = _series.ConsolidateBy(ConsolidateFunction.max);
var serie2 = _series.ConsolidateBy(ConsolidateFunction.sum);
- Assert.AreEqual("sum(consolidateBy(metric,'max'),consolidateBy(metric,'sum'))", new SeriesListBase[] {serie1, serie2}.Sum().ToString());
+ Assert.Equal("sum(consolidateBy(metric,'max'),consolidateBy(metric,'sum'))", new SeriesListBase[] {serie1, serie2}.Sum().ToString());
IEnumerable sources = new[] { _series };
- Assert.AreEqual("sum(metric)", sources.Sum().ToString());
+ Assert.Equal("sum(metric)", sources.Sum().ToString());
}
- [TestMethod]
+ [Fact]
public void SumSeriesWithWildcards()
{
var series = _series.SumSeriesWithWildcards(1, 4);
- Assert.AreEqual("sumSeriesWithWildcards(metric,1,4)", series.ToString());
+ Assert.Equal("sumSeriesWithWildcards(metric,1,4)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void Summarize()
{
var series = _series.Summarize("1day", SummarizeFunction.sum);
- Assert.AreEqual("summarize(metric,'1day','sum')", series.ToString());
+ Assert.Equal("summarize(metric,'1day','sum')", series.ToString());
}
- [TestMethod]
+ [Fact]
public void TimeShift()
{
var series = _series.TimeShift("1day", resetEnd: true, alignDst: false);
- Assert.AreEqual("timeShift(metric,'1day')", series.ToString());
+ Assert.Equal("timeShift(metric,'1day')", series.ToString());
series = _series.TimeShift("1day", resetEnd: false, alignDst: true);
- Assert.AreEqual("timeShift(metric,'1day',0,1)", series.ToString());
+ Assert.Equal("timeShift(metric,'1day',0,1)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void TimeSlice()
{
var series = _series.TimeSlice("-7day", "-1day");
- Assert.AreEqual("timeSlice(metric,'-7day','-1day')", series.ToString());
+ Assert.Equal("timeSlice(metric,'-7day','-1day')", series.ToString());
series = _series.TimeSlice("-7day");
- Assert.AreEqual("timeSlice(metric,'-7day')", series.ToString());
+ Assert.Equal("timeSlice(metric,'-7day')", series.ToString());
series = _series.TimeSlice("-7day", "now");
- Assert.AreEqual("timeSlice(metric,'-7day')", series.ToString());
+ Assert.Equal("timeSlice(metric,'-7day')", series.ToString());
}
- [TestMethod]
+ [Fact]
public void TimeStack()
{
var series = _series.TimeStack("-7day", 0, 7);
- Assert.AreEqual("timeStack(metric,'-7day',0,7)", series.ToString());
+ Assert.Equal("timeStack(metric,'-7day',0,7)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void TransformNull()
{
var series = _series.TransformNull();
- Assert.AreEqual("transformNull(metric)", series.ToString());
+ Assert.Equal("transformNull(metric)", series.ToString());
series = _series.TransformNull(0);
- Assert.AreEqual("transformNull(metric)", series.ToString());
+ Assert.Equal("transformNull(metric)", series.ToString());
series = _series.TransformNull(10);
- Assert.AreEqual("transformNull(metric,10)", series.ToString());
+ Assert.Equal("transformNull(metric,10)", series.ToString());
series = _series.TransformNull(10, _series);
- Assert.AreEqual("transformNull(metric,10,metric)", series.ToString());
+ Assert.Equal("transformNull(metric,10,metric)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void UseSeriesAbove()
{
var series = _series.UseSeriesAbove(10, "reqs", "time");
- Assert.AreEqual("useSeriesAbove(metric,10,\"reqs\",\"time\")", series.ToString());
+ Assert.Equal("useSeriesAbove(metric,10,\"reqs\",\"time\")", series.ToString());
series = _series.UseSeriesAbove(1.1, "reqs", "time");
- Assert.AreEqual("useSeriesAbove(metric,1.1,\"reqs\",\"time\")", series.ToString());
+ Assert.Equal("useSeriesAbove(metric,1.1,\"reqs\",\"time\")", series.ToString());
}
- [TestMethod]
+ [Fact]
public void WeightedAverage()
{
var series = _series.WeightedAverage(_series, 1, 3, 4);
- Assert.AreEqual("weightedAverage(metric,metric,1,3,4)", series.ToString());
+ Assert.Equal("weightedAverage(metric,metric,1,3,4)", series.ToString());
}
- [TestMethod]
+ [Fact]
public void TemplatePositional()
{
var series = _series.Template("worker1");
- Assert.AreEqual("template(metric,\"worker1\")", series.ToString());
+ Assert.Equal("template(metric,\"worker1\")", series.ToString());
}
- [TestMethod]
+ [Fact]
public void TemplateNamed()
{
var series = _series.Template(new Tuple("hostname", "worker1"));
- Assert.AreEqual("template(metric,hostname=\"worker1\")", series.ToString());
+ Assert.Equal("template(metric,hostname=\"worker1\")", series.ToString());
}
}
}
\ No newline at end of file
diff --git a/Graphite.Test/GraphitePathTest.cs b/Graphite.Test/GraphitePathTest.cs
index 9851ac6..57121ca 100644
--- a/Graphite.Test/GraphitePathTest.cs
+++ b/Graphite.Test/GraphitePathTest.cs
@@ -1,65 +1,64 @@
using ahd.Graphite.Base;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
namespace ahd.Graphite.Test
{
- [TestClass]
public class GraphitePathTest
{
- [TestMethod]
+ [Fact]
public void GraphitePath()
{
var path = new GraphitePath("metric");
- Assert.AreEqual("metric", path.Name);
- Assert.AreEqual("metric", path.ToString());
+ Assert.Equal("metric", path.Name);
+ Assert.Equal("metric", path.ToString());
}
- [TestMethod]
+ [Fact]
public void CombineNameTest()
{
var path = new GraphitePath("metric");
- Assert.AreEqual("metric", path.ToString());
+ Assert.Equal("metric", path.ToString());
path = path.Dot("used");
- Assert.AreEqual("metric.used", path.ToString());
+ Assert.Equal("metric.used", path.ToString());
path = path.Wildcard();
- Assert.AreEqual("metric.used*", path.ToString());
+ Assert.Equal("metric.used*", path.ToString());
path = path.Wildcard();
- Assert.AreEqual("metric.used*", path.ToString());
+ Assert.Equal("metric.used*", path.ToString());
path = path.DotWildcard();
- Assert.AreEqual("metric.used*.*", path.ToString());
+ Assert.Equal("metric.used*.*", path.ToString());
path = path.Range('a', 'z');
- Assert.AreEqual("metric.used*.*[a-z]", path.ToString());
+ Assert.Equal("metric.used*.*[a-z]", path.ToString());
path = path.Range('0', '9');
- Assert.AreEqual("metric.used*.*[a-z0-9]", path.ToString());
+ Assert.Equal("metric.used*.*[a-z0-9]", path.ToString());
path = path.DotRange('0', '9');
- Assert.AreEqual("metric.used*.*[a-z0-9].[0-9]", path.ToString());
+ Assert.Equal("metric.used*.*[a-z0-9].[0-9]", path.ToString());
path = path.Chars('a', 'd', 'f');
- Assert.AreEqual("metric.used*.*[a-z0-9].[0-9][adf]", path.ToString());
+ Assert.Equal("metric.used*.*[a-z0-9].[0-9][adf]", path.ToString());
path = path.Chars('q');
- Assert.AreEqual("metric.used*.*[a-z0-9].[0-9][adfq]", path.ToString());
+ Assert.Equal("metric.used*.*[a-z0-9].[0-9][adfq]", path.ToString());
path = path.DotChars('w');
- Assert.AreEqual("metric.used*.*[a-z0-9].[0-9][adfq].[w]", path.ToString());
+ Assert.Equal("metric.used*.*[a-z0-9].[0-9][adfq].[w]", path.ToString());
path = path.Values("asdf");
- Assert.AreEqual("metric.used*.*[a-z0-9].[0-9][adfq].[w]{asdf}", path.ToString());
+ Assert.Equal("metric.used*.*[a-z0-9].[0-9][adfq].[w]{asdf}", path.ToString());
path = path.Values("qwertz");
- Assert.AreEqual("metric.used*.*[a-z0-9].[0-9][adfq].[w]{asdf,qwertz}", path.ToString());
+ Assert.Equal("metric.used*.*[a-z0-9].[0-9][adfq].[w]{asdf,qwertz}", path.ToString());
path = path.DotValues("01","02","03");
- Assert.AreEqual("metric.used*.*[a-z0-9].[0-9][adfq].[w]{asdf,qwertz}.{01,02,03}", path.ToString());
+ Assert.Equal("metric.used*.*[a-z0-9].[0-9][adfq].[w]{asdf,qwertz}.{01,02,03}", path.ToString());
}
- [TestMethod]
+ [Fact]
public void AlternatingTest()
{
var path = new GraphitePath("dummy");
path = path.Chars('a', 'b', 'd').Values("a","v","b").Chars('z','y','x');
- Assert.AreEqual("dummy[abd]{a,v,b}[zyx]", path.ToString());
+ Assert.Equal("dummy[abd]{a,v,b}[zyx]", path.ToString());
}
- [TestMethod]
+ [Fact]
public void WildcardTest()
{
var metric = new GraphitePath("usage").Dot("unittest").DotWildcard().Dot("count");
- Assert.AreEqual("usage.unittest.*.count", metric.ToString());
+ Assert.Equal("usage.unittest.*.count", metric.ToString());
}
}
}
\ No newline at end of file
diff --git a/Graphite.Test/Properties/AssemblyInfo.cs b/Graphite.Test/Properties/AssemblyInfo.cs
deleted file mode 100644
index 6ce8503..0000000
--- a/Graphite.Test/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// Allgemeine Informationen über eine Assembly werden über folgende
-// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
-// die einer Assembly zugeordnet sind.
-[assembly: AssemblyTitle("Graphite.Test")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("ahd GmbH & Co. KG")]
-[assembly: AssemblyProduct("MP")]
-[assembly: AssemblyCopyright("Copyright © 2016")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Wenn ComVisible auf "false" festgelegt wird, sind die Typen innerhalb dieser Assembly
-// für COM-Komponenten unsichtbar. Wenn Sie auf einen Typ in dieser Assembly von
-// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen.
-[assembly: ComVisible(false)]
-
-// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
-[assembly: Guid("c4eb3065-0684-4cc2-8327-3429c5de9c16")]
-
-// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
-//
-// Hauptversion
-// Nebenversion
-// Buildnummer
-// Revision
-//
-// Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern
-// übernehmen, indem Sie "*" eingeben:
-// [Assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/Graphite.Test/Properties/Settings.Designer.cs b/Graphite.Test/Properties/Settings.Designer.cs
deleted file mode 100644
index 07c312a..0000000
--- a/Graphite.Test/Properties/Settings.Designer.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-//
-// Dieser Code wurde von einem Tool generiert.
-// Laufzeitversion:4.0.30319.42000
-//
-// Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn
-// der Code erneut generiert wird.
-//
-//------------------------------------------------------------------------------
-
-namespace ahd.Graphite.Test.Properties {
-
-
- [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
- [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "14.0.0.0")]
- internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
-
- private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
-
- public static Settings Default {
- get {
- return defaultInstance;
- }
- }
-
- [global::System.Configuration.ApplicationScopedSettingAttribute()]
- [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
- [global::System.Configuration.DefaultSettingValueAttribute("example.com")]
- public string GraphiteHost {
- get {
- return ((string)(this["GraphiteHost"]));
- }
- }
- }
-}
diff --git a/Graphite.Test/Properties/Settings.settings b/Graphite.Test/Properties/Settings.settings
deleted file mode 100644
index 23caf14..0000000
--- a/Graphite.Test/Properties/Settings.settings
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-
-
-
- example.com
-
-
-
\ No newline at end of file
diff --git a/Graphite.Test/app.config b/Graphite.Test/app.config
deleted file mode 100644
index 4fb8d04..0000000
--- a/Graphite.Test/app.config
+++ /dev/null
@@ -1,23 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- example.com
-
-
-
-
\ No newline at end of file
diff --git a/Graphite.sln b/Graphite.sln
index 22bf46e..bb6e910 100644
--- a/Graphite.sln
+++ b/Graphite.sln
@@ -1,7 +1,7 @@
Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.25420.1
+# Visual Studio 15
+VisualStudioVersion = 15.0.28010.2048
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Graphite", "Graphite\Graphite.csproj", "{05530EED-1658-4F66-8E42-796FF449AEA4}"
EndProject
@@ -24,5 +24,8 @@ Global
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
- EndGlobalSection
+ EndGlobalSection
+ GlobalSection(ExtensibilityGlobals) = postSolution
+ SolutionGuid = {8AB39995-BF82-453F-925B-969EBD601A22}
+ EndGlobalSection
EndGlobal
diff --git a/Graphite/Graphite.csproj b/Graphite/Graphite.csproj
index b17ad36..01faba8 100644
--- a/Graphite/Graphite.csproj
+++ b/Graphite/Graphite.csproj
@@ -1,131 +1,47 @@
-
-
-
+
+
- Debug
- AnyCPU
- {05530EED-1658-4F66-8E42-796FF449AEA4}
- Library
- Properties
+ netstandard2.0;net461
ahd.Graphite
ahd.Graphite
- v4.6.1
- 512
- SAK
- SAK
- SAK
- SAK
-
-
- true
- true
+ Graphite client
+ 2.0.0
+ ahd GmbH & Co. KG
+ ahd GmbH & Co. KG
+ false
+ https://github.com/ahdde/graphite.net
+ https://raw.github.com/ahdde/graphite.net/master/LICENSE.md
+ https://raw.github.com/ahdde/graphite.net/master/icon.png
+ https://github.com/ahdde/graphite.net.git
+ git
+ graphite pickle metric tsdb
+ Copyright 2018
+ client implementation for sending and retrieving values from and to any graphite server.
+ Graphite
-
- true
- full
- false
- bin\Debug\
- DEBUG;TRACE
- prompt
- 4
-
-
+
+
+ true
+
+ bin\Release\ahd.Graphite.xml
-
- pdbonly
- true
- bin\Release\
- TRACE
- prompt
- 4
- true
- bin\Release\ahd.Graphite.XML
-
-
+
+
+ true
+
+
-
- ..\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dll
- True
-
-
- ..\packages\Razorvine.Pyrolite.4.16.0\lib\net40\Razorvine.Pyrolite.dll
- True
-
-
- ..\packages\Razorvine.Serpent.1.16.0\lib\net40\Razorvine.Serpent.dll
- True
-
-
-
-
- ..\packages\Microsoft.AspNet.WebApi.Client.5.2.3\lib\net45\System.Net.Http.Formatting.dll
- True
-
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-
-
- Designer
-
-
- Designer
-
-
- Designer
-
+
+
+
+
-
-
-
-
- Dieses Projekt verweist auf mindestens ein NuGet-Paket, das auf diesem Computer fehlt. Verwenden Sie die Wiederherstellung von NuGet-Paketen, um die fehlenden Dateien herunterzuladen. Weitere Informationen finden Sie unter "http://go.microsoft.com/fwlink/?LinkID=322105". Die fehlende Datei ist "{0}".
-
-
-
-
-
\ No newline at end of file
+
+
diff --git a/Graphite/Graphite.csproj.vspscc b/Graphite/Graphite.csproj.vspscc
deleted file mode 100644
index feffdec..0000000
--- a/Graphite/Graphite.csproj.vspscc
+++ /dev/null
@@ -1,10 +0,0 @@
-""
-{
-"FILE_VERSION" = "9237"
-"ENLISTMENT_CHOICE" = "NEVER"
-"PROJECT_FILE_RELATIVE_PATH" = ""
-"NUMBER_OF_EXCLUDED_FILES" = "0"
-"ORIGINAL_PROJECT_FILE_PATH" = ""
-"NUMBER_OF_NESTED_PROJECTS" = "0"
-"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROVIDER"
-}
diff --git a/Graphite/Graphite.nuspec b/Graphite/Graphite.nuspec
deleted file mode 100644
index 6255ab8..0000000
--- a/Graphite/Graphite.nuspec
+++ /dev/null
@@ -1,27 +0,0 @@
-
-
-
- ahd.Graphite
- Graphite client
- 1.1.0
- ahd GmbH & Co. KG
- ahd GmbH & Co. KG
- https://github.com/ahdde/graphite.net
- https://raw.github.com/ahdde/graphite.net/master/LICENSE.md
- https://raw.github.com/ahdde/graphite.net/master/icon.png
- false
- client implementation for sending and retrieving values from and to any graphite server.
- Copyright 2017
- graphite pickle metric tsdb
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/Graphite/HttpClientExtensions.cs b/Graphite/HttpClientExtensions.cs
new file mode 100644
index 0000000..f8f8d77
--- /dev/null
+++ b/Graphite/HttpClientExtensions.cs
@@ -0,0 +1,27 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+
+namespace ahd.Graphite
+{
+ internal static class HttpClientExtensions
+ {
+ private static readonly JsonSerializer Serializer = new JsonSerializer();
+
+ internal static async Task ReadAsAsync(this HttpContent content, CancellationToken cancellationToken)
+ {
+ using (var stream = await content.ReadAsStreamAsync().ConfigureAwait(false))
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ using (var sReader = new StreamReader(stream))
+ using (var jReader = new JsonTextReader(sReader))
+ {
+ return Serializer.Deserialize(jReader);
+ }
+ }
+ }
+ }
+}
diff --git a/Graphite/Properties/AssemblyInfo.cs b/Graphite/Properties/AssemblyInfo.cs
deleted file mode 100644
index 6ceb275..0000000
--- a/Graphite/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// Allgemeine Informationen über eine Assembly werden über die folgenden
-// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
-// die einer Assembly zugeordnet sind.
-[assembly: AssemblyTitle("Graphite")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("ahd GmbH & Co. KG")]
-[assembly: AssemblyProduct("MP")]
-[assembly: AssemblyCopyright("Copyright © 2016")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar
-// für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von
-// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen.
-[assembly: ComVisible(false)]
-
-// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
-[assembly: Guid("05530eed-1658-4f66-8e42-796ff449aea4")]
-
-// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
-//
-// Hauptversion
-// Nebenversion
-// Buildnummer
-// Revision
-//
-// Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern
-// übernehmen, indem Sie "*" eingeben:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/Graphite/app.config b/Graphite/app.config
deleted file mode 100644
index 44ccc4b..0000000
--- a/Graphite/app.config
+++ /dev/null
@@ -1,11 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/Graphite/packages.config b/Graphite/packages.config
deleted file mode 100644
index 67c749d..0000000
--- a/Graphite/packages.config
+++ /dev/null
@@ -1,8 +0,0 @@
-
-
-
-
-
-
-
-
\ No newline at end of file