public void RefreshKeyWithUniquePrefix_Success() { string defaultPrefix = "unique"; // We need to simulate the Timeguid logic to derive at the initial key value. TimeGuid stGuid = new TimeGuid(DateTime.Now); UniqueKeys uniqueKey = new UniqueKeys(); string key = uniqueKey.GetKey(defaultPrefix); string expKey = defaultPrefix + uniqueKey.WhatIsKeySeparator + stGuid.ToString; Assert.AreEqual( expKey, key, "A1: Expected initial key value was not correct. Note: On Failures run a second time. There is a very slight chance that due to a second rollover the values could be different. Expected: " + expKey + " Actual: " + key); // Now get a new key. Note the TimeGuid portion should be updated and the increment should be updated. Thread.Sleep(1000); string key2 = uniqueKey.RefreshKey(defaultPrefix); TimeGuid stGuid2 = new TimeGuid(DateTime.Now); string expKey2 = defaultPrefix + uniqueKey.WhatIsKeySeparator + stGuid2; Assert.AreEqual( expKey2, key2, "A2: Expected key after Refresh was not equal to the value returned by UniqueKeys. Exp: " + expKey2 + " Actual: " + key2); TestContext.WriteLine("Unique Key Value: {0}", key2); TestContext.WriteLine("Expected Key Value: {0}", expKey2); }
public void ReadAll() { var idLarge = LargeBlobId(); var id11 = RegularBlobId(); var id12 = RegularBlobId(); var shift = Timestamp.Now.AddDays(1); var id21 = RegularBlobId(TimeGuid.NewGuid(shift)); var id22 = RegularBlobId(TimeGuid.NewGuid(shift)); WriteByte(idLarge, 255); WriteByte(id11, 11); WriteByte(id12, 12); WriteByte(id21, 21); WriteByte(id22, 22); timeBasedBlobStorage.ReadAll(1) .Select(x => Tuple.Create(x.Item1, x.Item2.Single())) .Should() .BeEquivalentTo(new[] { new Tuple <BlobId, byte>(idLarge, 255), new Tuple <BlobId, byte>(id11, 11), new Tuple <BlobId, byte>(id12, 12), new Tuple <BlobId, byte>(id21, 21), new Tuple <BlobId, byte>(id22, 22), }); }
public void ToByteArray() { var timeGuid = TimeGuid.NowGuid(); var bytes = timeGuid.ToByteArray(); Assert.That(new TimeGuid(bytes), Is.EqualTo(timeGuid)); }
public void KeyIncrementer_Increments_Success() { string defaultPrefix = "ABC"; KeepWithinSingleSecond(); // We need to simulate the Timeguid logic to derive at the initial key value. TimeGuid stGuid = new TimeGuid(DateTime.Now); UniqueKeys uniqueKey = new UniqueKeys(); string key = uniqueKey.GetKey(defaultPrefix); string expKey = defaultPrefix + uniqueKey.WhatIsKeySeparator + stGuid; Assert.AreEqual( expKey, key, "A10: Expected initial key value was not correct. Note: On Failures run a second time. There is a very slight chance that due to a second rollover the values could be different. Expected: " + expKey + " Actual: " + key); // Now create 2 more keys. They should have incrementers attched to them. string key2 = uniqueKey.GetKey(defaultPrefix); string key3 = uniqueKey.GetKey(defaultPrefix); Assert.AreNotEqual(key, key2, "A20: Expected Key1 and Key2 to be different."); Assert.AreNotEqual(key2, key3, "A30: Expected Key2 and Key3 to be different."); Assert.IsTrue(key2.EndsWith(uniqueKey.WhatIsIncrementSeparator + "1"), "A40: Key2 should have ended with a 1."); Assert.IsTrue(key3.EndsWith(uniqueKey.WhatIsIncrementSeparator + "2"), "A50: Key3 should have ended with a 2."); }
public void KeyValueSeparator_CanBeSet_Success() { string defaultPrefix = "ABC"; string sep = "^"; KeepWithinSingleSecond(); // We need to simulate the Timeguid logic to derive at the initial key value. TimeGuid stGuid = new TimeGuid(DateTime.Now); // Set separator to be carat. UniqueKeys uniqueKey = new UniqueKeys(sep); string key = uniqueKey.GetKey(defaultPrefix); string expKey = defaultPrefix + sep + stGuid.ToString; Assert.AreEqual( expKey, key, "A10: Expected initial key value was not correct. Note: On Failures run a second time. There is a very slight chance that due to a second rollover the values could be different. Expected: " + expKey + " Actual: " + key); TestContext.WriteLine("Unique Key Value: {0}", key); TestContext.WriteLine("Expected Key Value: {0}", expKey); }
public void CompareTo_ByNode() { var timestamp = Timestamp.Now; var clockSequence = TimeGuidGenerator.GenerateRandomClockSequence(); var timeGuid1 = new TimeGuid(timestamp, clockSequence, new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }); var timeGuid2 = new TimeGuid(timestamp, clockSequence, new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 }); var timeGuid3 = new TimeGuid(timestamp, clockSequence, new byte[] { 0x12, 0x34, 0x56, 0x78, 0xfe, 0xff }); var timeGuid4 = new TimeGuid(timestamp, clockSequence, new byte[] { 0x12, 0x34, 0x56, 0x78, 0xff, 0x00 }); var timeGuid5 = new TimeGuid(timestamp, clockSequence, new byte[] { 0x12, 0x34, 0x56, 0x78, 0xff, 0xff }); var timeGuid6 = new TimeGuid(timestamp, clockSequence, new byte[] { 0x12, 0x34, 0x56, 0x79, 0x00, 0x00 }); var timeGuid7 = new TimeGuid(timestamp, clockSequence, new byte[] { 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00 }); var timeGuid8 = new TimeGuid(timestamp, clockSequence, new byte[] { 0x7f, 0x01, 0x00, 0x00, 0x00, 0x00 }); var timeGuid9 = new TimeGuid(timestamp, clockSequence, new byte[] { 0xff, 0x00, 0x00, 0x00, 0x00, 0x00 }); var timeGuid10 = new TimeGuid(timestamp, clockSequence, new byte[] { 0xff, 0x00, 0x12, 0x34, 0x00, 0x00 }); var timeGuid11 = new TimeGuid(timestamp, clockSequence, new byte[] { 0xff, 0x00, 0x12, 0x35, 0x00, 0x00 }); var timeGuid12 = new TimeGuid(timestamp, clockSequence, new byte[] { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01 }); var timeGuid13 = new TimeGuid(timestamp, clockSequence, new byte[] { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }); Assert.That(timeGuid1.CompareTo(timeGuid2), Is.Negative); Assert.That(timeGuid2.CompareTo(timeGuid3), Is.Negative); Assert.That(timeGuid3.CompareTo(timeGuid4), Is.Negative); Assert.That(timeGuid4.CompareTo(timeGuid5), Is.Negative); Assert.That(timeGuid5.CompareTo(timeGuid6), Is.Negative); Assert.That(timeGuid6.CompareTo(timeGuid7), Is.Negative); Assert.That(timeGuid7.CompareTo(timeGuid8), Is.Negative); Assert.That(timeGuid8.CompareTo(timeGuid9), Is.Negative); Assert.That(timeGuid9.CompareTo(timeGuid10), Is.Negative); Assert.That(timeGuid10.CompareTo(timeGuid11), Is.Negative); Assert.That(timeGuid11.CompareTo(timeGuid12), Is.Negative); Assert.That(timeGuid12.CompareTo(timeGuid13), Is.Negative); }
// Validates that the first key has a value of 1 and each subsequent call is increasing by 1. public void KeyNumberShouldIncrement_EachCall_Success() { string defaultPrefix = "Key"; // We need to simulate the Timeguid logic to derive at the initial key value. TimeGuid stGuid = new TimeGuid(DateTime.Now); UniqueKeys uniqueKey = new UniqueKeys(); string key = uniqueKey.GetKey(); string expKey = defaultPrefix + stGuid + "1"; Assert.AreEqual( expKey, key, "A1: Expected initial key value was not correct. Note: On Failures run a second time. There is a very slight chance that due to a second rollover the values could be different. Expected: " + expKey + " Actual: " + key); // Now generate another key: string key2 = uniqueKey.GetKey(); string expKey2 = defaultPrefix + stGuid + "2"; Assert.AreEqual( expKey2, key2, "A2: Expected initial key value was not correct. Note: On Failures run a second time. There is a very slight chance that due to a second rollover the values could be different. Expected: " + expKey + " Actual: " + key); }
public void RefreshKeyWorks() { string defaultPrefix = "Key"; KeepWithinSingleSecond(); // We need to simulate the Timeguid logic to derive at the initial key value. TimeGuid stGuid = new TimeGuid(DateTime.Now); UniqueKeys uniqueKey = new UniqueKeys(constantTimeGuid: true); string key = uniqueKey.GetKey(defaultPrefix); string expKey = defaultPrefix + uniqueKey.WhatIsKeySeparator + stGuid + uniqueKey.WhatIsIncrementSeparator + "1"; Assert.AreEqual(expKey, key, "A10: Expected initial key value was not correct. Expected: " + expKey + " Actual: " + key); string key2 = uniqueKey.GetKey(defaultPrefix); // Now refresh the key. string key3 = uniqueKey.RefreshKey(defaultPrefix); // Because key3 requested RefreshKey, we should get a new TimeGuid as it would have made the thread sleep for at least 1 second. TimeGuid newGuid = new TimeGuid(DateTime.Now); Assert.IsTrue(key2.EndsWith(uniqueKey.WhatIsIncrementSeparator + "2"), "A20: Key2 should have ended with a 2."); Assert.IsTrue(key3.EndsWith(newGuid.ToString), "A21: Key3 should have ended with a 1 as it was called with the RefreshKey."); string expKey3 = defaultPrefix + uniqueKey.WhatIsKeySeparator + newGuid; Assert.AreEqual( expKey3, key3, "A30: Expected key after Refresh was not equal to the value returned by UniqueKeys. Exp: " + expKey3 + " Actual: " + key3); }
public bool TryAddNewExceptionInfo([NotNull] TaskMetaInformation taskMeta, [NotNull] Exception exception, out List <TimeGuid> newExceptionInfoIds) { if (!taskMeta.IsTimeBased()) { throw new InvalidOperationException(string.Format("TaskMeta is not time-based: {0}", taskMeta)); } newExceptionInfoIds = null; var newExceptionInfo = new TaskExceptionInfo(exception); var lastExceptionInfo = TryGetLastExceptionInfo(taskMeta); if (lastExceptionInfo != null && lastExceptionInfo.ExceptionMessageInfo == newExceptionInfo.ExceptionMessageInfo) { return(false); } var newExceptionInfoId = TimeGuid.NowGuid(); var timestamp = newExceptionInfoId.GetTimestamp().Ticks; TimeGuid oldExceptionInfoId; newExceptionInfoIds = taskMeta.AddExceptionInfoId(newExceptionInfoId, out oldExceptionInfoId); var newExceptionInfoBytes = serializer.Serialize(newExceptionInfo); timeBasedBlobStorage.Write(taskMeta.Id, newExceptionInfoId, newExceptionInfoBytes, timestamp, taskMeta.GetTtl()); if (oldExceptionInfoId != null) { timeBasedBlobStorage.Delete(taskMeta.Id, oldExceptionInfoId, timestamp); } return(true); }
public void NowGuid() { var nowDateTime = DateTime.UtcNow; var nowGuid = TimeGuid.NowGuid(); Assert.That(TimeSpan.FromTicks(nowGuid.GetTimestamp().Ticks - nowDateTime.Ticks), Is.LessThan(TimeSpan.FromTicks(100 * 10_000))); Assert.That(TimeSpan.FromMilliseconds((nowGuid.GetTimestamp().ToDateTime() - nowDateTime).TotalMilliseconds), Is.LessThan(TimeSpan.FromMilliseconds(100))); }
public void InvalidV1Guid() { Assert.Throws <InvalidOperationException>(() => new TimeGuid(Guid.NewGuid())); Assert.Throws <InvalidOperationException>(() => new TimeGuid(minGuid)); Assert.Throws <InvalidOperationException>(() => new TimeGuid(maxGuid)); Assert.Throws <InvalidOperationException>(() => new TimeGuid(new byte[0])); Assert.Throws <InvalidOperationException>(() => new TimeGuid(TimeGuid.NowGuid().ToByteArray().Take(15).ToArray())); Assert.Throws <InvalidOperationException>(() => new TimeGuid(TimeGuid.NowGuid().ToByteArray().Concat(new byte[] { 0xff }).ToArray())); }
public void MaxForTimestamp() { var timestamp = Timestamp.Now; var maxGuidForTimestamp = TimeGuid.MaxForTimestamp(timestamp); Assert.That(maxGuidForTimestamp.GetTimestamp(), Is.EqualTo(timestamp)); Assert.That(maxGuidForTimestamp.GetClockSequence(), Is.EqualTo(TimeGuidBitsLayout.MaxClockSequence)); Assert.That(maxGuidForTimestamp.GetNode(), Is.EqualTo(TimeGuidBitsLayout.MaxNode)); }
public void SetUp() { var now = Timestamp.Now; g1 = TimeGuid.NewGuid(now); g2 = TimeGuid.NewGuid(now); g11 = new TimeGuid(g1.ToByteArray()); g1PlusDelta = TimeGuid.NewGuid(now + TimeSpan.FromSeconds(1)); }
public void Equals_2TimeGuids_SameTime_EqualEachOther() { DateTime today = DateTime.Now; TimeGuid x = new TimeGuid(today); TimeGuid y = new TimeGuid(today); Assert.True(x.Equals(y), "A10: The two values were the same and should have equaled each other"); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (reader.TokenType == JsonToken.String) { var readAsString = (string)reader.Value; return(TimeGuid.Parse(readAsString)); } return(null); }
public void CompareTo_FirstLessThanSecond() { DateTime today = DateTime.Now; TimeGuid x = new TimeGuid(today); TimeGuid y = new TimeGuid(today.AddMinutes(2)); Assert.Less(x.CompareTo(y), 0, "A10: First value should have indicated it was less than second value."); }
public void Equals_2TimeGuids_FirstMoreThanSecond_NotEqual() { DateTime today = DateTime.Now; TimeGuid x = new TimeGuid(today.AddMinutes(3)); TimeGuid y = new TimeGuid(today); Assert.False(x.Equals(y), "A10: The two values were not the same and should NOT have equaled each other"); }
public void ValidateMinuteSorting([Range(0, 58)] int minute) { DateTime d = new DateTime(2019, 01, 11, 0, minute, 5); TimeGuid x = new TimeGuid(d); TimeGuid y = new TimeGuid(d.AddMinutes(1)); Assert.True(y > x, "Expected the comparison of y[" + y.ToString + "] > x[" + x.ToString + "] to be true. It was not. Something Wrong! "); TestContext.WriteLine("Comparing y[" + y.ToString + "] > x[" + x.ToString + "] was successful"); }
public void ToGuid() { var timeGuid = TimeGuid.NowGuid(); Console.Out.WriteLine(timeGuid); var guid = timeGuid.ToGuid(); Assert.That(new TimeGuid(guid), Is.EqualTo(timeGuid)); Assert.That(new TimeGuid(guid).ToGuid(), Is.EqualTo(guid)); }
public void Before() { var timestamp = Timestamp.Now; Assert.That(TimeGuid.MaxForTimestamp(timestamp).Before(), Is.LessThan(TimeGuid.MaxForTimestamp(timestamp))); Assert.That(TimeGuid.MinForTimestamp(timestamp).Before(), Is.EqualTo(TimeGuid.MaxForTimestamp(timestamp - TimeSpan.FromTicks(1)))); Assert.That(new TimeGuid(timestamp, 1, TimeGuidBitsLayout.MinNode).Before(), Is.EqualTo(new TimeGuid(timestamp, 0, TimeGuidBitsLayout.MaxNode))); Assert.That(new TimeGuid(timestamp, 1, TimeGuidBitsLayout.MaxNode).Before(), Is.EqualTo(new TimeGuid(timestamp, 1, TimeGuidBitsLayout.DecrementNode(TimeGuidBitsLayout.MaxNode)))); Assert.Throws <InvalidOperationException>(() => TimeGuid.MinForTimestamp(new Timestamp(DateTime.MinValue))); }
public void CompareTo_LessThanSymbol() { DateTime today = DateTime.Now; TimeGuid x = new TimeGuid(today); TimeGuid y = new TimeGuid(today.AddMinutes(2)); Assert.True(x < y, "A10: x should have been less than y"); Assert.False(y < x, "A20: Comparison should have been false."); }
public void CompareTo_GreaterThanSymbol() { DateTime today = DateTime.Now; TimeGuid x = new TimeGuid(today); TimeGuid y = new TimeGuid(today.AddMinutes(-2)); Assert.True(x > y, "A10: x should have been greater than y"); Assert.False(y > x, "A20: Comparison should have been false."); }
public void TimeGuidWorks() { var nextSeq = TimeGuid.NextSeq; var target = TimeGuid.New(); var target2 = TimeGuid.New(); var target3 = TimeGuid.New(); Guid g1 = target; //target.Seq.ShouldBe(); }
private static TimeGuid GetTimeGuidFromRowKey([NotNull] string rowKey) { TimeGuid timeGuid; if (!TimeGuid.TryParse(rowKey, out timeGuid)) { throw new InvalidOperationException(string.Format("Invalid rowKey: {0}", rowKey)); } return(timeGuid); }
private static TimeGuid GetTimeGuidFromColumnName([NotNull] string columnName) { TimeGuid timeGuid; if (!TimeGuid.TryParse(columnName.Split('_')[1], out timeGuid)) { throw new InvalidOperationException(string.Format("Invalid regular column name: {0}", columnName)); } return(timeGuid); }
private static BlobId GetBlobId([NotNull] string taskId) { TimeGuid timeGuid; if (!TimeGuid.TryParse(taskId, out timeGuid)) { throw new InvalidOperationException(string.Format("Task is not time-based: {0}", taskId)); } return(new BlobId(timeGuid, BlobType.Regular)); }
public void EqualitySigns_2TimeGuides_DifferentValues() { DateTime today = DateTime.Now; TimeGuid x = new TimeGuid(today); TimeGuid y = new TimeGuid(today.AddMinutes(2)); Assert.True((x != y), "A10: The two values were not the same and should have returned true"); Assert.False((x == y), "A20: The two values were different and should have returned false for == comparison"); }
public void EqualitySigns_2TimeGuides_SameValue() { DateTime today = DateTime.Now; TimeGuid x = new TimeGuid(today); TimeGuid y = new TimeGuid(today); Assert.True((x == y), "A10: The two values were the same and should have equaled each other"); Assert.False((x != y), "A20: The two values were the same and should have returned False for the != test"); }
public void MinuteConversion_Works([Range(0, 59)] int minute) { string val = CalculateTimeGuidPositionalValue(minute, "m"); DateTime d = new DateTime(2000, 01, 01, 0, minute, 0); string guidValue = TimeGuid.ConvertDateTimeToTimeGuid(d); string guidChar = guidValue.Substring(1, 1); Assert.AreEqual(val, guidChar, "A1: The minute did not convert to the expected ascii character. Exp: " + val + " Actual: " + guidValue); }
public void SecondConversion_Works([Range(0, 59)] int second) { string val = CalculateTimeGuidPositionalValue(second, "s"); DateTime d = new DateTime(2000, 01, 01, 0, 0, second); string guidValue = TimeGuid.ConvertDateTimeToTimeGuid(d); string guidChar = guidValue.Substring(2, 1); Assert.AreEqual(val, guidChar, "A1: The second did not convert to the expected ascii character. Exp: " + val + " Actual: " + guidValue); }