public void CanGetAll_WithPaging()
{
const string documentId = "users/ayende";
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
session.SaveChanges();
}
var baseline = RavenTestHelper.UtcToday;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
for (int i = 0; i <= 360; i++)
{
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation
{
Tag = "watches/fitbit",
Timestamp = baseline.AddSeconds(i * 10),
Values = new[] { 59d }
});
}
var timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var re = store.GetRequestExecutor();
using (re.ContextPool.AllocateOperationContext(out var context))
{
var tsCommand = new GetMultipleTimeSeriesOperation.GetMultipleTimeSeriesCommand(documentId, new List <TimeSeriesRange>
{
new TimeSeriesRange
{
Name = "Heartrate",
From = DateTime.MinValue,
To = DateTime.MaxValue
}
}, start: 100, pageSize: 200);
re.Execute(tsCommand, context);
var res = tsCommand.Result;
Assert.Equal(1, res.Values.Count);
Assert.Equal(1, res.Values["Heartrate"].Count);
Assert.Equal(200, res.Values["Heartrate"][0].Entries.Length);
Assert.Equal(baseline.AddSeconds(100 * 10), res.Values["Heartrate"][0].Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddSeconds(299 * 10), res.Values["Heartrate"][0].Entries[199].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
}
}
}
public void CanParseUnixTimeFormat()
{
using (var ctx = new JsonOperationContext(4096, 4096, 32, SharedMultipleUseFlag.None))
{
var djv = new DynamicJsonValue
{
["Name"] = "CanParseUnixTimeFormat",
["TimeFormat"] = TimeSeriesOperation.TimeFormat.UnixTimeInMs,
["Appends"] = new DynamicJsonArray
{
new DynamicJsonArray
{
1588464000021
, 3, 1, 2, 3,
"SomeTag"
}
}
};
var input = ctx.ReadObject(djv, "CanParseUnixTimeFormat");
var op = TimeSeriesOperation.ParseForBulkInsert(input);
Assert.Equal("CanParseUnixTimeFormat", op.Name);
Assert.Equal("SomeTag", op.Appends[0].Tag);
Assert.Equal(new double[] { 1, 2, 3 }, op.Appends[0].Values);
Assert.Equal(new DateTime(2020, 5, 3, 0, 0, 0, 21), op.Appends[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
djv = new DynamicJsonValue
{
["Name"] = "CanParseUnixTimeFormat",
["TimeFormat"] = TimeSeriesOperation.TimeFormat.UnixTimeInNs,
["Appends"] = new DynamicJsonArray
{
new DynamicJsonArray
{
1257894000000000000
, 3, 3, 2, 1,
"SomeTag2"
}
}
};
input = ctx.ReadObject(djv, "CanParseUnixTimeFormat");
op = TimeSeriesOperation.ParseForBulkInsert(input);
Assert.Equal("CanParseUnixTimeFormat", op.Name);
Assert.Equal("SomeTag2", op.Appends[0].Tag);
Assert.Equal(new double[] { 3, 2, 1 }, op.Appends[0].Values);
Assert.Equal(new DateTime(2009, 11, 10, 23, 0, 0), op.Appends[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
}
}
public void GetMultipleTimeSeriesShouldThrowOnMissingNameFromRange()
{
using (var store = GetDocumentStore())
{
var documentId = "users/ayende";
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
session.SaveChanges();
}
var baseline = DateTime.Today;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
for (int i = 0; i <= 10; i++)
{
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation
{
Tag = "watches/fitbit",
Timestamp = baseline.AddMinutes(i * 10),
Values = new[] { 72d }
});
}
var timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var ex = Assert.Throws <InvalidOperationException>(() => store.Operations.Send(
new GetMultipleTimeSeriesOperation("users/ayende", new List <TimeSeriesRange>
{
new TimeSeriesRange
{
From = baseline,
To = DateTime.MaxValue
}
})));
Assert.Contains("'Name' cannot be null or empty", ex.Message);
}
}
public void ShouldThrowOnNullOrEmptyRanges()
{
using (var store = GetDocumentStore())
{
var documentId = "users/ayende";
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
session.SaveChanges();
}
var baseline = RavenTestHelper.UtcToday;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
for (int i = 0; i <= 10; i++)
{
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation
{
Tag = "watches/fitbit",
Timestamp = baseline.AddMinutes(i * 10),
Values = new[] { 72d }
});
}
var timeSeriesBatch = new TimeSeriesBatchOperation("users/ayende", timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var ex = Assert.Throws <ArgumentNullException>(() => store.Operations.Send(
new GetMultipleTimeSeriesOperation("users/ayende", null)));
Assert.Contains("Value cannot be null. (Parameter 'ranges')", ex.Message);
var ex2 = Assert.Throws <InvalidOperationException>(() => store.Operations.Send(
new GetMultipleTimeSeriesOperation("users/ayende", new List <TimeSeriesRange>())));
Assert.Contains("'ranges' cannot be null or empty", ex2.Message);
}
}
protected TimeSeriesCommandData(string documentId, string name)
{
if (string.IsNullOrWhiteSpace(documentId))
{
throw new ArgumentNullException(nameof(documentId));
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
Id = documentId;
Name = name;
TimeSeries = new TimeSeriesOperation
{
Name = name
};
}
public void ShouldThrowOnAttemptToCreateTimeSeriesOnMissingDocument()
{
using (var store = GetDocumentStore())
{
var baseline = DateTime.Today;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation {
Tag = "watches/fitbit", Timestamp = baseline.AddSeconds(1), Values = new[] { 59d }
});
var timeSeriesBatch = new TimeSeriesBatchOperation("users/ayende", timeSeriesOp);
var ex = Assert.Throws <DocumentDoesNotExistException>(() => store.Operations.Send(timeSeriesBatch));
Assert.Contains("Cannot operate on time series of a missing document", ex.Message);
}
}
public void GetTimeSeriesShouldThrowOnMissingName()
{
using (var store = GetDocumentStore())
{
var documentId = "users/ayende";
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
session.SaveChanges();
}
var baseline = RavenTestHelper.UtcToday;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
for (int i = 0; i <= 10; i++)
{
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation
{
Tag = "watches/fitbit",
Timestamp = baseline.AddMinutes(i * 10),
Values = new[] { 72d }
});
}
var timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var ex = Assert.Throws <ArgumentNullException>(() => store.Operations.Send(
new GetTimeSeriesOperation("users/ayende", string.Empty, baseline, DateTime.MaxValue)));
Assert.Contains("Value cannot be null", ex.Message);
}
}
public async Task IncomingReplicationShouldRejectIncrementalTimeSeriesFromOldServer()
{
const string version = "5.2.3";
const string incrementalTsName = Constants.Headers.IncrementalTimeSeriesPrefix + "HeartRate";
const string docId = "users/1";
using (var oldStore = await GetDocumentStoreAsync(version))
using (var store = GetDocumentStore())
{
using (var session = oldStore.OpenAsyncSession())
{
await session.StoreAsync(new User(), docId);
await session.SaveChangesAsync();
}
var tsOp = new TimeSeriesOperation
{
Name = incrementalTsName
};
tsOp.Append(new TimeSeriesOperation.AppendOperation
{
Timestamp = DateTime.UtcNow,
Values = new[] { 1d }
});
await oldStore.Operations.SendAsync(new TimeSeriesBatchOperation(docId, tsOp));
await ReplicationTests.SetupReplication(oldStore, store);
Assert.False(WaitForDocument(store, docId, timeout: 3000));
var notificationCenter = (await Databases.GetDocumentDatabaseInstanceFor(store)).NotificationCenter;
var msg = notificationCenter.GetStoredMessage("AlertRaised/Replication");
Assert.NotNull(msg);
Assert.Contains($"Detected an item of type Incremental-TimeSeries : '{incrementalTsName}' on document '{docId}", msg);
}
}
public void CanCreateAndGetSimpleTimeSeriesUsingStoreOperations()
{
const string documentId = "users/ayende";
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
session.SaveChanges();
}
var baseline = DateTime.Today;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation {
Tag = "watches/fitbit", Timestamp = baseline.AddSeconds(1), Values = new[] { 59d }
});
var timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var timeSeriesRangeResult = store.Operations.Send(
new GetTimeSeriesOperation(documentId, "Heartrate", DateTime.MinValue, DateTime.MaxValue));
Assert.Equal(1, timeSeriesRangeResult.Entries.Length);
var value = timeSeriesRangeResult.Entries[0];
Assert.Equal(59d, value.Values[0]);
Assert.Equal("watches/fitbit", value.Tag);
Assert.Equal(baseline.AddSeconds(1), value.Timestamp, RavenTestHelper.DateTimeComparer.Instance);
}
}
public TimeSeriesBatchCommandData(string documentId, string name, IList <TimeSeriesOperation.AppendOperation> appends, List <TimeSeriesOperation.DeleteOperation> deletes)
{
if (string.IsNullOrWhiteSpace(documentId))
{
throw new ArgumentNullException(nameof(documentId));
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
Id = documentId;
Name = name;
TimeSeries = new TimeSeriesOperation
{
Name = name,
};
if (appends != null)
{
foreach (var appendOperation in appends)
{
TimeSeries.Append(appendOperation);
}
}
if (deletes != null)
{
foreach (var deleteOperation in deletes)
{
TimeSeries.Delete(deleteOperation);
}
}
}
public void CanGetNonExistedRange()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), "users/ayende");
session.SaveChanges();
}
var baseline = DateTime.Today;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation {
Tag = "watches/fitbit", Timestamp = baseline.AddSeconds(1), Values = new[] { 59d }
});
var timeSeriesBatch = new TimeSeriesBatchOperation("users/ayende", timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var timeSeriesRangeResult = store.Operations.Send(
new GetTimeSeriesOperation("users/ayende", "Heartrate", baseline.AddMonths(-2), baseline.AddMonths(-1)));
Assert.Empty(timeSeriesRangeResult.Entries);
using (var session = store.OpenSession())
{
var query = session.Query <User>().Select(u => RavenQuery.TimeSeries(u, "Heartrate", baseline.AddMonths(-2), baseline.AddMonths(-1)).ToList()).ToList();
Assert.Equal(0, query[0].Results.Length);
}
}
}
public void CanGetMultipleRangesInSingleRequest()
{
const string documentId = "users/ayende";
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
session.SaveChanges();
}
var baseline = DateTime.Today;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
for (int i = 0; i <= 360; i++)
{
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation
{
Tag = "watches/fitbit",
Timestamp = baseline.AddSeconds(i * 10),
Values = new[] { 59d }
});
}
var timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var timesSeriesDetails = store.Operations.Send(
new GetMultipleTimeSeriesOperation(documentId, new List <TimeSeriesRange>
{
new TimeSeriesRange
{
Name = "Heartrate",
From = baseline.AddMinutes(5),
To = baseline.AddMinutes(10)
},
new TimeSeriesRange
{
Name = "Heartrate",
From = baseline.AddMinutes(15),
To = baseline.AddMinutes(30)
},
new TimeSeriesRange
{
Name = "Heartrate",
From = baseline.AddMinutes(40),
To = baseline.AddMinutes(60)
}
}));
Assert.Equal(documentId, timesSeriesDetails.Id);
Assert.Equal(1, timesSeriesDetails.Values.Count);
Assert.Equal(3, timesSeriesDetails.Values["Heartrate"].Count);
var range = timesSeriesDetails.Values["Heartrate"][0];
Assert.Equal(baseline.AddMinutes(5), range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(10), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(31, range.Entries.Length);
Assert.Equal(baseline.AddMinutes(5), range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(10), range.Entries[30].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
range = timesSeriesDetails.Values["Heartrate"][1];
Assert.Equal(baseline.AddMinutes(15), range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(30), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(91, range.Entries.Length);
Assert.Equal(baseline.AddMinutes(15), range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(30), range.Entries[90].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
range = timesSeriesDetails.Values["Heartrate"][2];
Assert.Equal(baseline.AddMinutes(40), range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(60), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(121, range.Entries.Length);
Assert.Equal(baseline.AddMinutes(40), range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(60), range.Entries[120].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
}
}
public void RavenDB_14877()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), "users/1-A");
session.SaveChanges();
}
var op = new TimeSeriesOperation.AppendOperation
{
Timestamp = DateTime.Now,
Tag = "as",
Values = new double[] { 73 }
};
var op2 = new TimeSeriesOperation.AppendOperation
{
Timestamp = DateTime.Now,
Tag = "as",
Values = new double[] { 78 }
};
var op3 = new TimeSeriesOperation.AppendOperation
{
Timestamp = new DateTime(2019, 4, 23) + TimeSpan.FromMinutes(5),
Tag = "as",
Values = new double[] { 798 }
};
var a = new TimeSeriesOperation
{
Name = "test",
};
a.Append(op3);
a.Append(op2);
a.Append(op);
store.Operations.Send(new TimeSeriesBatchOperation("users/1-A", a));
var opDelete = new TimeSeriesOperation.DeleteOperation
{
From = DateTime.Now - TimeSpan.FromDays(2),
To = DateTime.Now + TimeSpan.FromDays(2)
};
var ab = new TimeSeriesOperation
{
Name = "test",
};
ab.Delete(opDelete);
store.Operations.Send(new TimeSeriesBatchOperation("users/1-A", ab));
var abc = new TimeSeriesOperation
{
Name = "test",
};
abc.Delete(new TimeSeriesOperation.DeleteOperation {
From = DateTime.MinValue, To = DateTime.MaxValue
});
store.Operations.Send(new TimeSeriesBatchOperation("users/1-A", abc));
var ts = store.Operations.Send(new GetTimeSeriesOperation("users/1-A", "test", DateTime.MinValue, DateTime.MaxValue));
// GetTimeSeriesOperation should return null on non-existing timeseries
Assert.Null(ts);
}
}
public void GetRangesShouldReturnNotModifiedCode_WithPaging()
{
const string documentId = "users/ayende";
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
session.SaveChanges();
}
var baseline = DateTime.Today;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
for (int i = 0; i <= 360; i++)
{
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation
{
Tag = "watches/fitbit",
Timestamp = baseline.AddSeconds(i * 10),
Values = new[] { 59d }
});
}
var timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var re = store.GetRequestExecutor();
using (re.ContextPool.AllocateOperationContext(out var context))
{
var ranges = new List <TimeSeriesRange>
{
new TimeSeriesRange
{
Name = "Heartrate", From = baseline.AddMinutes(5), To = baseline.AddMinutes(10)
},
new TimeSeriesRange
{
Name = "Heartrate", From = baseline.AddMinutes(15), To = baseline.AddMinutes(30)
},
new TimeSeriesRange
{
Name = "Heartrate", From = baseline.AddMinutes(40), To = baseline.AddMinutes(60)
}
};
GetMultipleTimeSeriesOperation.GetMultipleTimeSeriesCommand tsCommand;
for (int i = 0; i < 3; i++)
{
tsCommand = new GetMultipleTimeSeriesOperation.GetMultipleTimeSeriesCommand(documentId, ranges, 10, 150);
re.Execute(tsCommand, context);
var timesSeriesDetails = tsCommand.Result;
if (i == 0)
{
Assert.Equal(HttpStatusCode.OK, tsCommand.StatusCode);
}
else
{
Assert.Equal(HttpStatusCode.NotModified, tsCommand.StatusCode);
}
Assert.Equal(documentId, timesSeriesDetails.Id);
Assert.Equal(1, timesSeriesDetails.Values.Count);
Assert.Equal(3, timesSeriesDetails.Values["Heartrate"].Count);
var range = timesSeriesDetails.Values["Heartrate"][0];
Assert.Equal(baseline.AddMinutes(6).AddSeconds(40), range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(10), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(21, range.Entries.Length);
Assert.Equal(baseline.AddMinutes(6).AddSeconds(40), range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(10), range.Entries[20].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
range = timesSeriesDetails.Values["Heartrate"][1];
Assert.Equal(baseline.AddMinutes(15), range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(30), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(91, range.Entries.Length);
Assert.Equal(baseline.AddMinutes(15), range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(30), range.Entries[90].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
range = timesSeriesDetails.Values["Heartrate"][2];
Assert.Equal(baseline.AddMinutes(40), range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(46).AddSeconds(10), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(38, range.Entries.Length);
Assert.Equal(baseline.AddMinutes(40), range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(46).AddSeconds(10), range.Entries[37].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
}
using (var session = store.OpenSession())
{
// add a new entry to the series
session.TimeSeriesFor(documentId, "Heartrate").Append(baseline.AddMinutes(15).AddMilliseconds(50), new[] { 1000d }, "watches/apple");
session.SaveChanges();
}
// verify that we don't get cached results
tsCommand = new GetMultipleTimeSeriesOperation.GetMultipleTimeSeriesCommand(documentId, ranges, 10, 150);
re.Execute(tsCommand, context);
Assert.Equal(HttpStatusCode.OK, tsCommand.StatusCode);
var newEntry = tsCommand.Result.Values["Heartrate"][1].Entries
.FirstOrDefault(e => e.Value == 1000d && e.Timestamp == baseline.AddMinutes(15).AddMilliseconds(50).ToUniversalTime());
Assert.NotNull(newEntry);
// request with a different 'start'
// verify that we don't get cached results
tsCommand = new GetMultipleTimeSeriesOperation.GetMultipleTimeSeriesCommand(documentId, new List <TimeSeriesRange>
{
new TimeSeriesRange()
{
Name = "Heartrate",
From = DateTime.MinValue,
To = DateTime.MaxValue
}
}, start: 12, pageSize: 150);
re.Execute(tsCommand, context);
Assert.Equal(HttpStatusCode.OK, tsCommand.StatusCode);
Assert.Equal(baseline.AddSeconds(12 * 10), tsCommand.Result.Values["Heartrate"][0].Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
}
}
}
public void CanGetRanges_WithPaging()
{
const string documentId = "users/ayende";
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
session.SaveChanges();
}
var baseline = DateTime.Today;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
for (int i = 0; i <= 360; i++)
{
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation
{
Tag = "watches/fitbit",
Timestamp = baseline.AddSeconds(i * 10),
Values = new[] { 59d }
});
}
var timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var re = store.GetRequestExecutor();
using (re.ContextPool.AllocateOperationContext(out var context))
{
var ranges = new List <TimeSeriesRange>
{
new TimeSeriesRange
{
Name = "Heartrate", From = baseline.AddMinutes(5), To = baseline.AddMinutes(10)
},
new TimeSeriesRange
{
Name = "Heartrate", From = baseline.AddMinutes(15), To = baseline.AddMinutes(30)
},
new TimeSeriesRange
{
Name = "Heartrate", From = baseline.AddMinutes(40), To = baseline.AddMinutes(60)
}
};
var tsCommand = new GetMultipleTimeSeriesOperation.GetMultipleTimeSeriesCommand(documentId, ranges, 10, 150);
re.Execute(tsCommand, context);
var timesSeriesDetails = tsCommand.Result;
Assert.Equal(documentId, timesSeriesDetails.Id);
Assert.Equal(1, timesSeriesDetails.Values.Count);
Assert.Equal(3, timesSeriesDetails.Values["Heartrate"].Count);
Assert.Null(timesSeriesDetails.Values["Heartrate"][0].TotalResults);
var range = timesSeriesDetails.Values["Heartrate"][0];
Assert.Equal(baseline.AddMinutes(6).AddSeconds(40), range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(10), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(21, range.Entries.Length);
Assert.Equal(baseline.AddMinutes(6).AddSeconds(40), range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(10), range.Entries[20].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
range = timesSeriesDetails.Values["Heartrate"][1];
Assert.Equal(baseline.AddMinutes(15), range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(30), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(91, range.Entries.Length);
Assert.Equal(baseline.AddMinutes(15), range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(30), range.Entries[90].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
range = timesSeriesDetails.Values["Heartrate"][2];
Assert.Equal(baseline.AddMinutes(40), range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(46).AddSeconds(10), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(38, range.Entries.Length);
Assert.Equal(baseline.AddMinutes(40), range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(46).AddSeconds(10), range.Entries[37].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
}
}
}
public void GetAllShouldReturnNotModifiedCode()
{
const string documentId = "users/ayende";
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
session.SaveChanges();
}
var baseline = DateTime.Today;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
for (int i = 0; i <= 360; i++)
{
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation
{
Tag = "watches/fitbit",
Timestamp = baseline.AddSeconds(i * 10),
Values = new[] { 59d }
});
}
var timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var re = store.GetRequestExecutor();
using (re.ContextPool.AllocateOperationContext(out var context))
{
for (int i = 0; i < 3; i++)
{
var tsCommand = new GetMultipleTimeSeriesOperation.GetMultipleTimeSeriesCommand(documentId, new List <TimeSeriesRange>
{
new TimeSeriesRange
{
Name = "Heartrate",
From = DateTime.MinValue,
To = DateTime.MaxValue
}
}, start: 0, pageSize: int.MaxValue);
re.Execute(tsCommand, context);
var res = tsCommand.Result;
Assert.Equal(361, res.Values["Heartrate"][0].TotalResults);
Assert.Equal(1, res.Values.Count);
Assert.Equal(1, res.Values["Heartrate"].Count);
Assert.Equal(361, res.Values["Heartrate"][0].Entries.Length);
var statusCode = tsCommand.StatusCode;
if (i == 0)
{
Assert.Equal(HttpStatusCode.OK, statusCode);
}
else
{
Assert.Equal(HttpStatusCode.NotModified, statusCode);
}
}
using (var session = store.OpenSession())
{
// add a new entry to the series
session.TimeSeriesFor(documentId, "Heartrate").Append(baseline.AddSeconds(100).AddMilliseconds(50), new[] { 1000d }, "watches/apple");
session.SaveChanges();
}
// verify that we don't get cached results
var command = new GetMultipleTimeSeriesOperation.GetMultipleTimeSeriesCommand(documentId,
new List <TimeSeriesRange>
{
new TimeSeriesRange
{
Name = "Heartrate",
From = DateTime.MinValue,
To = DateTime.MaxValue
}
}, 0, int.MaxValue);
re.Execute(command, context);
Assert.Equal(HttpStatusCode.OK, command.StatusCode);
Assert.Equal(362, command.Result.Values["Heartrate"][0].TotalResults);
Assert.Equal(1, command.Result.Values.Count);
Assert.Equal(1, command.Result.Values["Heartrate"].Count);
Assert.Equal(362, command.Result.Values["Heartrate"][0].Entries.Length);
var newEntry = command.Result.Values["Heartrate"][0].Entries
.FirstOrDefault(e => e.Value == 1000d && e.Timestamp == baseline.AddSeconds(100).AddMilliseconds(50).ToUniversalTime());
Assert.NotNull(newEntry);
}
}
}
public void CanDeleteWithoutProvidingFromAndToDates()
{
using (var store = GetDocumentStore())
{
var baseline = DateTime.Today.EnsureUtc();
var docId = "users/ayende";
using (var session = store.OpenSession())
{
session.Store(new User(), docId);
var tsf = session.TimeSeriesFor(docId, "HeartRate");
var tsf2 = session.TimeSeriesFor(docId, "BloodPressure");
var tsf3 = session.TimeSeriesFor(docId, "BodyTemperature");
for (int j = 0; j < 100; j++)
{
tsf.Append(baseline.AddMinutes(j), j);
tsf2.Append(baseline.AddMinutes(j), j);
tsf3.Append(baseline.AddMinutes(j), j);
}
session.SaveChanges();
}
var get = store.Operations.Send(new GetTimeSeriesOperation(docId, "HeartRate"));
Assert.Equal(100, get.Entries.Length);
// null From, To
var deleteOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
deleteOp.Delete(new TimeSeriesOperation.DeleteOperation());
store.Operations.Send(new TimeSeriesBatchOperation(docId, deleteOp));
get = store.Operations.Send(new GetTimeSeriesOperation(docId, "HeartRate"));
Assert.Null(get);
get = store.Operations.Send(new GetTimeSeriesOperation(docId, "BloodPressure"));
Assert.Equal(100, get.Entries.Length);
// null To
deleteOp = new TimeSeriesOperation
{
Name = "BloodPressure",
};
deleteOp.Delete(new TimeSeriesOperation.DeleteOperation {
From = baseline.AddMinutes(50), To = null
});
store.Operations.Send(new TimeSeriesBatchOperation(docId, deleteOp));
get = store.Operations.Send(new GetTimeSeriesOperation(docId, "BloodPressure"));
Assert.Equal(50, get.Entries.Length);
get = store.Operations.Send(new GetTimeSeriesOperation(docId, "BodyTemperature"));
Assert.Equal(100, get.Entries.Length);
// null From
deleteOp = new TimeSeriesOperation
{
Name = "BodyTemperature",
};
deleteOp.Delete(new TimeSeriesOperation.DeleteOperation {
To = baseline.AddMinutes(19)
});
store.Operations.Send(new TimeSeriesBatchOperation(docId, deleteOp));
get = store.Operations.Send(new GetTimeSeriesOperation(docId, "BodyTemperature"));
Assert.Equal(80, get.Entries.Length);
}
}
public void CanGetMultipleTimeSeriesInSingleRequest()
{
using (var store = GetDocumentStore())
{
var documentId = "users/ayende";
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
session.SaveChanges();
}
// append
var baseline = DateTime.Today;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
for (int i = 0; i <= 10; i++)
{
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation
{
Tag = "watches/fitbit",
Timestamp = baseline.AddMinutes(i * 10),
Values = new[] { 72d }
});
}
var timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
timeSeriesOp = new TimeSeriesOperation
{
Name = "BloodPressure",
};
for (int i = 0; i <= 10; i++)
{
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation
{
Timestamp = baseline.AddMinutes(i * 10),
Values = new[] { 80d }
});
}
timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
timeSeriesOp = new TimeSeriesOperation
{
Name = "Temperature",
};
for (int i = 0; i <= 10; i++)
{
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation
{
Timestamp = baseline.AddMinutes(i * 10),
Values = new[] { 37d + i * 0.15 }
});
}
timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
// get ranges from multiple time series in a single request
var timesSeriesDetails = store.Operations.Send(
new GetMultipleTimeSeriesOperation(documentId, new List <TimeSeriesRange>
{
new TimeSeriesRange
{
Name = "Heartrate",
From = baseline,
To = baseline.AddMinutes(15)
},
new TimeSeriesRange
{
Name = "Heartrate",
From = baseline.AddMinutes(30),
To = baseline.AddMinutes(45)
},
new TimeSeriesRange
{
Name = "BloodPressure",
From = baseline,
To = baseline.AddMinutes(30)
},
new TimeSeriesRange
{
Name = "BloodPressure",
From = baseline.AddMinutes(60),
To = baseline.AddMinutes(90)
},
new TimeSeriesRange
{
Name = "Temperature",
From = baseline,
To = baseline.AddDays(1)
}
}));
Assert.Equal("users/ayende", timesSeriesDetails.Id);
Assert.Equal(3, timesSeriesDetails.Values.Count);
Assert.Equal(2, timesSeriesDetails.Values["Heartrate"].Count);
var range = timesSeriesDetails.Values["Heartrate"][0];
Assert.Equal(baseline, range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(15), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(2, range.Entries.Length);
Assert.Equal(baseline, range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(10), range.Entries[1].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Null(range.TotalResults);
range = timesSeriesDetails.Values["Heartrate"][1];
Assert.Equal(baseline.AddMinutes(30), range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(45), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(2, range.Entries.Length);
Assert.Equal(baseline.AddMinutes(30), range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(40), range.Entries[1].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Null(range.TotalResults);
Assert.Equal(2, timesSeriesDetails.Values["BloodPressure"].Count);
range = timesSeriesDetails.Values["BloodPressure"][0];
Assert.Equal(baseline, range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(30), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(4, range.Entries.Length);
Assert.Equal(baseline, range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(30), range.Entries[3].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Null(range.TotalResults);
range = timesSeriesDetails.Values["BloodPressure"][1];
Assert.Equal(baseline.AddMinutes(60), range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(90), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(4, range.Entries.Length);
Assert.Equal(baseline.AddMinutes(60), range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(90), range.Entries[3].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Null(range.TotalResults);
Assert.Equal(1, timesSeriesDetails.Values["Temperature"].Count);
range = timesSeriesDetails.Values["Temperature"][0];
Assert.Equal(baseline, range.From, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddDays(1), range.To, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(11, range.Entries.Length);
Assert.Equal(baseline, range.Entries[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(baseline.AddMinutes(100), range.Entries[10].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(11, range.TotalResults); // full range
}
}
public ExecuteTimeSeriesBatchCommand(DocumentDatabase database, string documentId, TimeSeriesOperation operation, bool fromEtl)
{
_database = database;
_documentId = documentId;
_operation = operation;
_fromEtl = fromEtl;
}
public void CanAppendAndRemoveTimestampsInSingleBatch()
{
const string documentId = "users/ayende";
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User(), documentId);
session.SaveChanges();
}
var baseline = DateTime.Today;
var timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation {
Tag = "watches/fitbit", Timestamp = baseline.AddSeconds(1), Values = new[] { 59d }
});
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation {
Tag = "watches/fitbit", Timestamp = baseline.AddSeconds(2), Values = new[] { 61d }
});
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation {
Tag = "watches/fitbit", Timestamp = baseline.AddSeconds(3), Values = new[] { 61.5d }
});
var timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
var timeSeriesRangeResult = store.Operations.Send(
new GetTimeSeriesOperation(documentId, "Heartrate", DateTime.MinValue, DateTime.MaxValue));
Assert.Equal(3, timeSeriesRangeResult.Entries.Length);
timeSeriesOp = new TimeSeriesOperation
{
Name = "Heartrate",
};
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation {
Tag = "watches/fitbit", Timestamp = baseline.AddSeconds(4), Values = new[] { 60d }
});
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation {
Tag = "watches/fitbit", Timestamp = baseline.AddSeconds(5), Values = new[] { 62.5d }
});
timeSeriesOp.Append(new TimeSeriesOperation.AppendOperation {
Tag = "watches/fitbit", Timestamp = baseline.AddSeconds(6), Values = new[] { 62d }
});
timeSeriesOp.Delete(new TimeSeriesOperation.DeleteOperation {
From = baseline.AddSeconds(2), To = baseline.AddSeconds(3)
});
timeSeriesBatch = new TimeSeriesBatchOperation(documentId, timeSeriesOp);
store.Operations.Send(timeSeriesBatch);
timeSeriesRangeResult = store.Operations.Send(
new GetTimeSeriesOperation(documentId, "Heartrate", DateTime.MinValue, DateTime.MaxValue));
Assert.Equal(4, timeSeriesRangeResult.Entries.Length);
var value = timeSeriesRangeResult.Entries[0];
Assert.Equal(59d, value.Values[0]);
Assert.Equal(baseline.AddSeconds(1), value.Timestamp, RavenTestHelper.DateTimeComparer.Instance);
value = timeSeriesRangeResult.Entries[1];
Assert.Equal(60d, value.Values[0]);
Assert.Equal(baseline.AddSeconds(4), value.Timestamp, RavenTestHelper.DateTimeComparer.Instance);
value = timeSeriesRangeResult.Entries[2];
Assert.Equal(62.5d, value.Values[0]);
Assert.Equal(baseline.AddSeconds(5), value.Timestamp, RavenTestHelper.DateTimeComparer.Instance);
value = timeSeriesRangeResult.Entries[3];
Assert.Equal(62d, value.Values[0]);
Assert.Equal(baseline.AddSeconds(6), value.Timestamp, RavenTestHelper.DateTimeComparer.Instance);
}
using (var store = GetDocumentStore())
{
var baseline = DateTime.Today;
using (var session = store.OpenSession())
{
session.Store(new { Name = "Oren" }, documentId);
session.TimeSeriesFor(documentId, "Heartrate")
.Append(baseline.AddMinutes(1), new[] { 59d }, "watches/fitbit");
session.TimeSeriesFor(documentId, "Heartrate")
.Append(baseline.AddMinutes(2), new[] { 69d }, "watches/fitbit");
session.TimeSeriesFor(documentId, "Heartrate")
.Append(baseline.AddMinutes(3), new[] { 79d }, "watches/fitbit");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
session.Store(new { Name = "Oren" }, documentId);
session.TimeSeriesFor(documentId, "Heartrate")
.Delete(baseline.AddMinutes(2));
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var vals = session.TimeSeriesFor(documentId, "Heartrate")
.Get(DateTime.MinValue, DateTime.MaxValue)
.ToList();
Assert.Equal(2, vals.Count);
Assert.Equal(new[] { 59d }, vals[0].Values);
Assert.Equal("watches/fitbit", vals[0].Tag);
Assert.Equal(baseline.AddMinutes(1), vals[0].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
Assert.Equal(new[] { 79d }, vals[1].Values);
Assert.Equal("watches/fitbit", vals[1].Tag);
Assert.Equal(baseline.AddMinutes(3), vals[1].Timestamp, RavenTestHelper.DateTimeComparer.Instance);
}
}
}
