internal static AppendOperation Parse(BlittableJsonReaderObject input)
{
if (input.TryGet(nameof(Timestamp), out DateTime ts) == false)
{
throw new InvalidDataException($"Missing '{nameof(Timestamp)}' property");
}
if (input.TryGet(nameof(Values), out BlittableJsonReaderArray values) == false || values == null)
{
throw new InvalidDataException($"Missing '{nameof(Values)}' property");
}
input.TryGet(nameof(Tag), out string tag); // optional
var doubleValues = new double[values.Length];
for (int i = 0; i < doubleValues.Length; i++)
{
doubleValues[i] = values.GetByIndex <double>(i);
}
var op = new AppendOperation
{
Timestamp = ts,
Values = doubleValues,
Tag = tag
};
return(op);
}
public void Prepare_InsertsEvents(
[Frozen] Mock <IBatchOperation> operationMock,
[Frozen] string streamName,
[Frozen] EventStreamHeader header,
JournaledEvent[] events,
AppendOperation operation)
{
operation.Prepare(events);
var version = header.Version;
foreach (var journaledEvent in events)
{
var e = journaledEvent;
version = version.Increment();
VerifyInsertOperation(
operationMock: operationMock,
partitionKey: streamName,
rowKey: version.ToString(),
verifyColumns: columns =>
columns["EventId"].Equals(e.EventId) &&
columns["EventType"].Equals(e.EventTypeName));
}
}
public void Prepare_CreatesBatchOperation(
[Frozen] Mock <ICloudTable> tableMock,
JournaledEvent[] events,
AppendOperation operation)
{
operation.Prepare(events);
tableMock.Verify(self => self.PrepareBatchOperation(), Times.Once());
}
public async Task Execute_ReturnsHeaderWithNewETag(
[Frozen] IReadOnlyList <OperationResult> batchResult,
JournaledEvent[] events,
AppendOperation operation)
{
operation.Prepare(events);
var result = await operation.ExecuteAsync();
Assert.Equal(batchResult[0].ETag, result.ETag);
}
public async Task Execute_ReturnsHeaderWithIncrementedVersion(
[Frozen] StreamVersion currentVersion,
JournaledEvent[] events,
AppendOperation operation)
{
var targetVersion = currentVersion.Increment(events.Count());
operation.Prepare(events);
var result = await operation.ExecuteAsync();
Assert.Equal(targetVersion, result.Version);
}
internal static TimeSeriesOperation Parse(BlittableJsonReaderObject input)
{
if (input.TryGet(nameof(Name), out string name) == false || name == null)
{
ThrowMissingProperty(nameof(Name));
}
var result = new TimeSeriesOperation
{
Name = name
};
if (input.TryGet(nameof(Appends), out BlittableJsonReaderArray operations) && operations != null)
{
var sorted = new SortedList <long, AppendOperation>();
foreach (var op in operations)
{
if (!(op is BlittableJsonReaderObject bjro))
{
ThrowNotBlittableJsonReaderObjectOperation(op);
return(null); //never hit
}
var append = AppendOperation.Parse(bjro);
sorted[append.Timestamp.Ticks] = append;
}
result._appends = sorted;
}
if (input.TryGet(nameof(Deletes), out operations) && operations != null)
{
result.Deletes = new List <DeleteOperation>();
foreach (var op in operations)
{
if (!(op is BlittableJsonReaderObject bjro))
{
ThrowNotBlittableJsonReaderObjectOperation(op);
return(null); //never hit
}
result.Deletes.Add(DeleteOperation.Parse(bjro));
}
}
return(result);
}
public void Prepare_ForUnknownHeader_InsertsHeaderRow(
[Frozen] Mock <IBatchOperation> operationMock,
[Frozen] string streamName,
[Frozen] EventStreamHeader header,
JournaledEvent[] events,
AppendOperation operation)
{
var targetVersion = (int)header.Version.Increment(events.Count());
operation.Prepare(events);
VerifyInsertOperation(
operationMock,
streamName,
"HEAD",
name => name.Equals("Version"),
value => value.Equals(targetVersion));
}
public void Append(AppendOperation appendOperation)
{
_appends ??= new SortedList <long, AppendOperation>();
appendOperation.Timestamp = appendOperation.Timestamp.EnsureUtc().EnsureMilliseconds();
_appends[appendOperation.Timestamp.Ticks] = appendOperation; // on duplicate values the last one overrides
}
internal static TimeSeriesOperation ParseForBulkInsert(BlittableJsonReaderObject input)
{
if (input.TryGet(nameof(Name), out string name) == false || name == null)
{
ThrowMissingProperty(nameof(Name));
}
input.TryGet(TimeSeriesFormat, out TimeFormat format);
var result = new TimeSeriesOperation
{
Name = name
};
if (input.TryGet(nameof(Appends), out BlittableJsonReaderArray operations) == false || operations == null)
{
ThrowMissingProperty(nameof(Appends));
}
var sorted = new SortedList <long, AppendOperation>();
foreach (var op in operations)
{
if (!(op is BlittableJsonReaderArray bjro))
{
ThrowNotBlittableJsonReaderArrayOperation(op);
return(null); //never hit
}
var time = GetLong(bjro[0]);
switch (format)
{
case TimeFormat.UnixTimeInMs:
time = FromUnixMs(time);
break;
case TimeFormat.UnixTimeInNs:
time = FromUnixNs(time);
break;
case TimeFormat.DotNetTicks:
break;
default:
throw new ArgumentException($"Unknown time-format '{format}'");
}
var append = new AppendOperation
{
Timestamp = new DateTime(time)
};
var numberOfValues = GetLong(bjro[1]);
var doubleValues = new double[numberOfValues];
for (var i = 0; i < numberOfValues; i++)
{
var obj = bjro[i + 2];
switch (obj)
{
case long l:
// when we send the number without the decimal point
// this is the same as what Convert.ToDouble is doing
doubleValues[i] = l;
break;
case LazyNumberValue lnv:
doubleValues[i] = lnv;
break;
default:
doubleValues[i] = Convert.ToDouble(obj);
break;
}
}
append.Values = doubleValues;
var tagIndex = 2 + numberOfValues;
if (bjro.Length > tagIndex)
{
if (BlittableJsonReaderObject.ChangeTypeToString(bjro[(int)tagIndex], out string tagAsString) == false)
{
ThrowNotString(bjro[0]);
}
append.Tag = tagAsString;
}
sorted[append.Timestamp.Ticks] = append;
}
result._appends = sorted;
return(result);
public async Task Execute_WhenOperationHasNotBeenPrepared_Throws(
AppendOperation operation)
{
await Assert.ThrowsAsync <InvalidOperationException>(operation.ExecuteAsync);
}
