public void Can_put_with_tag() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Bytes = new byte[] { 1, 2, 3, 4 }, Key = "test", Tag = 1 }); actions.Commit(); }); table.Batch(actions => { var values = actions.Get(new GetRequest() { Key = "test", }); Assert.Equal(1, values[0].Tag); actions.Commit(); }); } }
public void Save_several_items_for_same_version_will_save_all_of_them() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } }); actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 2 } }); Value[] values = actions.Get(new GetRequest { Key = "test" }); Assert.Equal(2, values.Length); Assert.Equal(1, values[0].Version.Number); Assert.Equal(new byte[] { 1 }, values[0].Data); Assert.Equal(2, values[1].Version.Number); Assert.Equal(new byte[] { 2 }, values[1].Data); }); } }
public void Can_check_existance_of_tag() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Bytes = new byte[] { 1, 2, 3, 4 }, Key = "test", Tag = 1 }); actions.Commit(); }); table.Batch(actions => { Assert.True(actions.HasTag(1)); Assert.False(actions.HasTag(2)); actions.Commit(); }); } }
public void Can_use_optimistic_concurrency() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } }); PutResult put = actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 2 }, OptimisticConcurrency = true }); Assert.True(put.ConflictExists); actions.Commit(); Assert.Equal(1, actions.Get(new GetRequest { Key = "test" }).Length); }); } }
public void Writing_identical_data_to_existing_vlaue_will_not_create_conflict() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { PutResult put1 = actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } }); PutResult put2 = actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } }); Value[] values = actions.Get(new GetRequest { Key = "test" }); Assert.Equal(1, values.Length); Assert.Equal(put1.Version.Number, put2.Version.Number); Assert.Equal(put1.Version.InstanceId, put2.Version.InstanceId); }); } }
public void Can_get_item_in_specific_version() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { PutResult version1 = actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } }); actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 2 } }); Value[] value = actions.Get(new GetRequest { Key = "test", SpecifiedVersion = version1.Version }); Assert.Equal(new byte[] { 1 }, value[0].Data); }); } }
public void After_item_expires_it_will_be_removed_on_next_commit() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Key = "abc1", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 }, ExpiresAt = DateTime.Now, }); actions.Commit(); }); table.Batch(actions => actions.Commit()); int numRecords = -1; table.Batch(actions => { Api.JetSetCurrentIndex(actions.Session, actions.Keys, null); //primary Api.JetIndexRecordCount(actions.Session, actions.Keys, out numRecords, 0); }); Assert.Equal(0, numRecords); } }
public DistributedHashTable( string database, Uri url, IEndpointRouter endpointRouter, IServiceBus bus, Node metadata) { Url = url; this.endpointRouter = endpointRouter; this.bus = bus; Metadata = metadata; if (Metadata != null) // sole node in the network, probably { Metadata.ExecuteSync(uri => { ServiceUtil.Execute<IDistributedHashTableMetaDataProvider>(uri, srv => { failOver = srv.GetNodeByUri(url); }); }); } try { hashTable = new PersistentHashTable(database); hashTable.Initialize(); } catch (Exception) { hashTable.Dispose(); throw; } }
public void FillUpTableTest() { const string tableName = "FillUpHashTable"; const int tableSize = 25; const int keySize = 4; const int valueSize = 4; const int userHeaderSize = 6; PersistentHashTable hashTable = InitTable(tableName, tableSize, keySize, valueSize, userHeaderSize); try { // fill the hash table for (int i = 1; i < tableSize + 1; i++) { hashTable.Put(i.ToBytes(), i.ToBytes()); } //add one more than allowed try { hashTable.Put(new byte[] { byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue }, new byte[] { byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue }); Assert.Fail("Should throw exception"); } catch (IndexOutOfRangeException) {} } finally { hashTable.Close(); } }
public void Can_get_hash_from_cache() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { byte[] bytes = Encoding.UTF8.GetBytes("abcdefgiklmnqrstwxyz"); actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = bytes }); Value[] values = actions.Get(new GetRequest { Key = "test" }); Assert.Equal( SHA256.Create().ComputeHash(bytes), values[0].Sha256Hash ); }); } }
public void Cannot_query_with_partial_item_key() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Key = "abc1", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } }); Value[] values = actions.Get(new GetRequest { Key = "abc10" }); Assert.Equal(0, values.Length); values = actions.Get(new GetRequest { Key = "abc1" }); Assert.NotEqual(0, values.Length); }); } }
public void RemoveTest() { const int keySize = 4; const int valueSize = 4; PersistentHashTable hashTable = InitTable("HashTableRemove", 15, keySize, valueSize, 6); try { RemoveTestAssert(hashTable, valueSize, new byte[keySize] { 1, 2, 3, 4 }); RemoveTestAssert(hashTable, valueSize, new byte[keySize] { 1, 0, 0, 0 }); RemoveTestAssert(hashTable, valueSize, new byte[keySize] { 0, 0, 0, 1 }); RemoveTestAssert(hashTable, valueSize, new byte[keySize] { byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue }); } finally { hashTable.Close(); } }
public void Can_remove_without_version() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Bytes = new byte[] { 1, 2, }, Key = "test", ParentVersions = new ValueVersion[0] }); actions.Commit(); }); table.Batch(actions => { actions.Remove(new RemoveRequest { Key = "test" }); Value[] values = actions.Get(new GetRequest { Key = "test" }); Assert.Empty(values); actions.Commit(); }); } }
public void When_setting_the_same_value_on_the_key_twice_will_not_create_new_version() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { PutResult version1 = actions.Put(new PutRequest { Key = "abc1", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 6 } }); var version2 = actions.Put(new PutRequest { Key = "abc1", ParentVersions = new[] { version1.Version }, Bytes = new byte[] { 6 } }); Assert.False(version2.ConflictExists); Assert.Equal(version1.Version.InstanceId, version2.Version.InstanceId); Assert.Equal(version1.Version.Number, version2.Version.Number); }); } }
public void will_generate_sha256_for_new_values() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Bytes = new byte[] { 1, 2, }, Key = "test", ParentVersions = new ValueVersion[0] }); actions.Commit(); }); table.Batch(actions => { Value[] values = actions.Get(new GetRequest { Key = "test" }); Assert.NotNull(values[0].Sha256Hash); Assert.NotEmpty(values[0].Sha256Hash); actions.Commit(); }); } }
public void Can_insert_same_value_to_pht_in_two_seperate_instances() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Key = "test", Bytes = new byte[] { 1 } }); actions.Commit(); }); } using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Key = "test", Bytes = new byte[] { 1 } }); actions.Commit(); }); } }
public void Can_remove_item_from_table_when_there_is_more_than_single_item() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); ValueVersion versionOfA = null, versionOfC = null; table.Batch(actions => { versionOfA = actions.Put( new PutRequest { Key = "a", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } } ).Version; actions.Put(new PutRequest { Key = "b", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } }); versionOfC = actions.Put( new PutRequest { Key = "c", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } }).Version; actions.Put( new PutRequest { Key = "d", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } }); actions.Commit(); }); table.Batch(actions => { bool removed = actions.Remove(new RemoveRequest { Key = "a", SpecificVersion = versionOfA }); Assert.True(removed); removed = actions.Remove(new RemoveRequest { Key = "c", SpecificVersion = versionOfC }); Assert.True(removed); actions.Commit(); }); } }
public void Can_get_timestamp_from_pht() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Bytes = new byte[] { 1, 2, }, Key = "test", ParentVersions = new ValueVersion[0] }); actions.Commit(); }); table.Batch(actions => { Value[] values = actions.Get(new GetRequest { Key = "test" }); Assert.NotEqual(DateTime.MinValue, values[0].Timestamp); actions.Commit(); }); } }
public void Can_set_the_replication_version_and_get_it_back() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); Guid guid = Guid.NewGuid(); table.Batch(actions => { PutResult result = actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 3 }, ReplicationVersion = new ValueVersion { InstanceId = guid, Number = 53 } }); Assert.Equal(53, result.Version.Number); Assert.Equal(guid, result.Version.InstanceId); actions.Commit(); }); } }
private static void RemoveTestAssert(PersistentHashTable hashTable, int valueSize, byte[] key) { hashTable.Put(key, new byte[valueSize]); hashTable.Remove(key); try { hashTable.Get(key); } catch (KeyNotFoundException) {} }
public void CanPutDifferentKeysIntoPHTConcurrently() { var exceptions = new List <Exception>(); using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); int count = 0; const int threadCount = 50; for (int i = 0; i < threadCount; i++) { new Thread(state => { var j = (int)state; try { for (int k = 0; k < 10; k++) { table.Batch(actions => { actions.Put(new PutRequest { Key = k + "-" + j.ToString(), Bytes = new byte[] { 4, 3, 5 } }); actions.Commit(); }); } } catch (Exception e) { lock (exceptions) exceptions.Add(e); } finally { Interlocked.Increment(ref count); } }, i) { IsBackground = true }.Start(i); } while (Thread.VolatileRead(ref count) != threadCount) { Thread.Sleep(100); } Assert.Empty(exceptions); } }
public void CanPutDifferentKeysIntoPHTConcurrently() { var exceptions = new List<Exception>(); using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); int count = 0; const int threadCount = 50; for (int i = 0; i < threadCount; i++) { new Thread(state => { var j = (int) state; try { for (int k = 0; k < 10; k++) { table.Batch(actions => { actions.Put(new PutRequest { Key = k + "-" + j.ToString(), Bytes = new byte[] { 4, 3, 5 } }); actions.Commit(); }); } } catch (Exception e) { lock(exceptions) exceptions.Add(e); } finally { Interlocked.Increment(ref count); } },i) { IsBackground = true }.Start(i); } while(Thread.VolatileRead(ref count) != threadCount) { Thread.Sleep(100); } Assert.Empty(exceptions); } }
public void Can_query_for_item_history() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { PutResult version1 = actions.Put(new PutRequest { Key = "abc1", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 6 } }); actions.Put(new PutRequest { Key = "abc1", ParentVersions = new[] { version1.Version }, Bytes = new byte[] { 1 } }); actions.Put(new PutRequest { Key = "abc1", ParentVersions = new[] { version1.Version }, Bytes = new byte[] { 2 } }); actions.Put(new PutRequest { Key = "abc1", ParentVersions = new[] { new ValueVersion { InstanceId = version1.Version.InstanceId, Number = 3 }, }, Bytes = new byte[] { 3 } }); Value[] values = actions.Get(new GetRequest { Key = "abc1" }); Assert.Equal(3, values.Length); Assert.Equal(new[] { 1 }, values[0].ParentVersions.Select(x => x.Number).ToArray()); Assert.Equal(new[] { 1 }, values[1].ParentVersions.Select(x => x.Number).ToArray()); Assert.Equal(new[] { 3 }, values[2].ParentVersions.Select(x => x.Number).ToArray()); }); } }
public void CloseTest() { PersistentHashTable hashTable = InitTable("Close", 88, 3, 10, 6); try { hashTable.Close(); } finally { hashTable.Close(); } }
public void GetUserHeaderSizeTest() { const int userHeaderSize = 6; PersistentHashTable hashTable = InitTable("GetHashTableUserHeaderSize", 3, 2, 2, userHeaderSize); try { Assert.AreEqual(userHeaderSize, hashTable.GetUserHeaderSize()); } finally { hashTable.Close(); } }
public void Can_get_item_in_specific_version() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { var version1 = actions.Put("test", new int[0], new byte[] { 1 }); actions.Put("test", new int[0], new byte[] { 2 }); var value = actions.Get("test", version1); Assert.Equal(new byte[]{1}, value.Data); }); } }
public void ExportToCsv_exports_database_table_contents_to_csv_file_to_specified_path() { var dbRootPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, testDatabase); var dbFilePath = Path.Combine(dbRootPath, Path.GetFileName(testDatabase)); var exportPath = Path.Combine(dbRootPath, "export"); //Clear previous test results. if (Directory.Exists(exportPath)) { Directory.Delete(exportPath); } Directory.CreateDirectory(exportPath); using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Key = "abc1", Bytes = new byte[] { 1 } }); actions.Put(new PutRequest { Key = "abc2", Bytes = new byte[] { 2 } }); actions.Commit(); }); } var export = new ExportToCsv(dbFilePath, exportPath); export.Execute(); Assert.True(Directory.Exists(exportPath)); Assert.True(File.Exists(Path.Combine(exportPath, "keys.csv"))); Assert.True(File.Exists(Path.Combine(exportPath, "data.csv"))); Assert.True(File.Exists(Path.Combine(exportPath, "details.csv"))); Assert.True(File.Exists(Path.Combine(exportPath, "lists.csv"))); var linesInKeys = File.ReadAllLines(Path.Combine(exportPath, "keys.csv")); var linesInData = File.ReadAllLines(Path.Combine(exportPath, "data.csv")); Assert.True(linesInKeys.Length > 0); Assert.True(linesInData.Length > 0); }
public void After_resolving_conflict_will_remove_old_version_of_data() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { PutResult version1 = actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } }); PutResult version2 = actions.Put(new PutRequest { Key = "test", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 2 } }); Value[] value = actions.Get(new GetRequest { Key = "test", SpecifiedVersion = version1.Version }); Assert.Equal(new byte[] { 1 }, value[0].Data); actions.Put(new PutRequest { Key = "test", ParentVersions = new[] { version1.Version, version2.Version }, Bytes = new byte[] { 3 } }); actions.Commit(); Assert.Empty(actions.Get(new GetRequest { Key = "test", SpecifiedVersion = version1.Version })); }); } }
public void Can_add_item_to_list() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { var id = actions.AddItem(new AddItemRequest { Data = new byte[] { 1, 2, 4 }, Key = "test" }); }); } }
private PersistentHashTable InitTable(string hashtableName, int tableSize, int keySize, int valueSize, int userHeaderSize) { PersistentHashTable ht; try { ht = new PersistentHashTable(hashtableName, tableSize, keySize, valueSize, userHeaderSize); } catch (FileNameConflictException) { ht = new PersistentHashTable(hashtableName); ht.Delete(); ht = new PersistentHashTable(hashtableName, tableSize, keySize, valueSize, userHeaderSize); } return(ht); }
public void Can_get_all_rows_with_tag() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Bytes = new byte[] { 1, 2, 3, 4 }, Key = "test", Tag = 1 }); actions.Put(new PutRequest { Bytes = new byte[] { 1, 2, 3, 4 }, Key = "test2", Tag = 1 }); actions.Put(new PutRequest { Bytes = new byte[] { 1, 2, 3, 4 }, Key = "test3", Tag = 2 }); actions.Commit(); }); table.Batch(actions => { var results = actions.GetKeysForTag(1).ToArray(); Assert.Equal(2, results.Length); Assert.Equal("test", results[0].Key); Assert.Equal("test2", results[1].Key); results = actions.GetKeysForTag(2).ToArray(); Assert.Equal(1, results.Length); Assert.Equal("test3", results[0].Key); actions.Commit(); }); } }
public void Cannot_query_with_partial_item_key() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put("abc1", new int[0], new byte[] { 1 }); var values = actions.Get("abc10"); Assert.Equal(0, values.Length); values = actions.Get("abc1"); Assert.NotEqual(0, values.Length); }); } }
public DistributedHashTable(string database, Action<InstanceParameters> configure) { try { hashTable = new PersistentHashTable(database) { Configure = configure }; hashTable.Initialize(); } catch (Exception) { if (hashTable != null) hashTable.Dispose(); throw; } }
public void Unloading_app_domain_will_free_esent() { var domain = AppDomain.CreateDomain("test",null,new AppDomainSetup { ApplicationBase = AppDomain.CurrentDomain.BaseDirectory }); var unwrap = (UncleanAndUnpleasant)domain.CreateInstanceAndUnwrap( typeof(UncleanAndUnpleasant).Assembly.GetName().Name, typeof(UncleanAndUnpleasant).FullName); unwrap.Start(); AppDomain.Unload(domain); using(var table = new PersistentHashTable("test.esent")) { table.Initialize(); } }
public void CtorTest() { const int tableSize = 88; const int keySize = 3; const int valueSize = 10; PersistentHashTable hashTable = InitTable("ctor", tableSize, keySize, valueSize, 4); try { Assert.AreEqual(tableSize, hashTable.GetTableSize()); Assert.AreEqual(keySize, hashTable.GetKeySize()); Assert.AreEqual(valueSize, hashTable.GetValueSize()); } finally { hashTable.Close(); } }
public void RemoveCollisionTest() { PersistentHashTable hashTable = InitTable("HashTableRemove", 20, 4, 4, 6); try { //fill the table up with collisions byte[] lastCollisionKey = FillTableWithCollisions(5, hashTable); hashTable.Remove(lastCollisionKey); hashTable.Put(lastCollisionKey, new byte[hashTable.GetValueSize()]); } finally { hashTable.Close(); } }
public void After_resolving_conflict_will_remove_old_version_of_data() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { var version1 = actions.Put("test", new int[0], new byte[] { 1 }); actions.Put("test", new int[0], new byte[] { 2 }); var value = actions.Get("test", version1); Assert.Equal(new byte[] { 1 }, value.Data); actions.Put("test", new[] {1, 2}, new byte[] {3}); actions.Commit(); Assert.Null(actions.Get("test", version1)); }); } }
public void After_item_expires_it_cannot_be_retrieved() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Key = "abc1", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 }, ExpiresAt = DateTime.Now.AddYears(-1), OptimisticConcurrency = false }); Value[] values = actions.Get(new GetRequest { Key = "abc1" }); Assert.Equal(0, values.Length); }); } }
public void Can_list_items() { int item2 = 0; int item1 = 0; using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { item1 = actions.AddItem(new AddItemRequest { Data = new byte[] { 1, 2, 4 }, Key = "test" }); item2 = actions.AddItem(new AddItemRequest { Data = new byte[] { 5, 3, 1 }, Key = "test" }); actions.Commit(); }); table.Batch(actions => { var items = actions.GetItems(new GetItemsRequest { Key = "test" }); Assert.Equal(item1, items[0].Key); Assert.Equal(item2, items[1].Key); Assert.Equal(new byte[] { 1, 2, 4 }, items[0].Value); Assert.Equal(new byte[] { 5, 3, 1 }, items[1].Value); }); } }
public void Can_remove_items() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { int item1 = actions.AddItem(new AddItemRequest { Data = new byte[] { 1, 2, 4 }, Key = "test" }); actions.AddItem(new AddItemRequest { Data = new byte[] { 3, 6, 4 }, Key = "test" }); actions.RemoveItem(new RemoveItemRequest { Id = item1, Key = "test" }); actions.Commit(); }); table.Batch(actions => { var items = actions.GetItems(new GetItemsRequest { Key = "test" }); Assert.Equal(1, items.Length); }); } }
public void ExportToCsv_exports_database_table_contents_to_csv_file_to_specified_path() { var dbRootPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, testDatabase); var dbFilePath = Path.Combine(dbRootPath, Path.GetFileName(testDatabase)); var exportPath = Path.Combine(dbRootPath, "export"); //Clear previous test results. if (Directory.Exists(exportPath)) Directory.Delete(exportPath); Directory.CreateDirectory(exportPath); using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Key = "abc1", Bytes = new byte[] { 1 } }); actions.Put(new PutRequest { Key = "abc2", Bytes = new byte[] { 2 } }); actions.Commit(); }); } var export = new ExportToCsv(dbFilePath, exportPath); export.Execute(); Assert.True(Directory.Exists(exportPath)); Assert.True(File.Exists(Path.Combine(exportPath, "keys.csv"))); Assert.True(File.Exists(Path.Combine(exportPath, "data.csv"))); Assert.True(File.Exists(Path.Combine(exportPath, "details.csv"))); Assert.True(File.Exists(Path.Combine(exportPath, "lists.csv"))); var linesInKeys = File.ReadAllLines(Path.Combine(exportPath, "keys.csv")); var linesInData = File.ReadAllLines(Path.Combine(exportPath, "data.csv")); Assert.True(linesInKeys.Length > 0); Assert.True(linesInData.Length > 0); }
public void Id_of_table_is_persistent() { Guid id; using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); id = table.Id; Assert.NotEqual(Guid.Empty, id); } using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); Assert.NotEqual(Guid.Empty, table.Id); Assert.Equal(id, table.Id); } }
public void Can_remove_item_from_table_when_there_is_more_than_single_item() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); int versionOfA = 0, versionOfC = 0; table.Batch(actions => { versionOfA = actions.Put("a", new int[0], new byte[] {1}); actions.Put("b", new int[0], new byte[] { 1 }); versionOfC = actions.Put("c", new int[0], new byte[] {1}); actions.Put("d", new int[0], new byte[] { 1 }); actions.Commit(); }); table.Batch(actions => { var removed = actions.Remove("a", new []{ versionOfA }); Assert.True(removed); removed = actions.Remove("c", new[] { versionOfC }); Assert.True(removed); actions.Commit(); }); } }
public void Interleaved() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Key = "abc1", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 1 } }); table.Batch(actions2 => { actions2.Put(new PutRequest { Key = "dve", ParentVersions = new ValueVersion[0], Bytes = new byte[] { 3 } }); actions2.Commit(); }); actions.Commit(); }); table.Batch(actions => { Assert.NotEmpty(actions.Get(new GetRequest { Key = "abc1" })); Assert.NotEmpty(actions.Get(new GetRequest { Key = "dve" })); }); } }
public void Can_save_and_load_item_from_cache() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put("test", new int[0], new byte[] { 1 }); var values = actions.Get("test"); Assert.Equal(1, values[0].Version); Assert.Equal(new byte[] { 1 }, values[0].Data); }); } }
public void Can_resolve_conflict() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put("test", new int[0], new byte[] { 1 }); actions.Put("test", new int[0], new byte[] { 2 }); var values = actions.Get("test"); Assert.Equal(2, values.Length); actions.Put("test", new[] {1, 2}, new byte[] {3}); values = actions.Get("test"); Assert.Equal(1, values.Length); Assert.Equal(new byte[] {3}, values[0].Data); Assert.Equal(3, values[0].Version); }); } }
public void Start() { table = new PersistentHashTable("test.esent"); table.Initialize(); }
public void will_get_items_from_current_list_only() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.AddItem(new AddItemRequest { Data = new byte[] { 1, 2, 4 }, Key = "test" }); actions.AddItem(new AddItemRequest { Data = new byte[] { 5, 3, 1 }, Key = "test" }); actions.AddItem(new AddItemRequest { Data = new byte[] { 5, 3, 1 }, Key = "test2" }); actions.Commit(); }); table.Batch(actions => { var items = actions.GetItems(new GetItemsRequest { Key = "test" }); Assert.Equal(2, items.Length); }); } }
public void ExpireDataFromPhtByTimestamp_removes_data_whose_expiration_is_lesser_or_equal_than_specified() { var dbRootPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, testDatabase); var dbFilePath = Path.Combine(dbRootPath, Path.GetFileName(testDatabase)); using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Key = "expire1", Bytes = new byte[] { 1 }, ReplicationTimeStamp = DateTime.Now.AddHours(-1) }); var parent = actions.Put(new PutRequest { Key = "expire2", Bytes = new byte[] { 2 }, ReplicationTimeStamp = DateTime.Now.AddMinutes(-20) }); actions.Put(new PutRequest { Key = "expire2", Bytes = new byte[] { 2, 1 }, ParentVersions = new[] { parent.Version }, ReplicationTimeStamp = DateTime.Now.AddMinutes(-10) }); actions.Put(new PutRequest { Key = "shouldnotexpire", Bytes = new byte[] { 3 }, ReplicationTimeStamp = DateTime.Now.AddMinutes(30) }); actions.Commit(); }); } var expiryUtil = new ExpireDataFromPhtByTimestamp(dbFilePath, DateTime.Now); expiryUtil.Excute(); using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { var results1 = actions.Get(new GetRequest { Key = "expire1", SpecifiedVersion = null }); Assert.True(results1.Length == 0); var results2 = actions.Get(new GetRequest { Key = "expire2", SpecifiedVersion = null }); Assert.True(results2.Length == 0); var results3 = actions.Get(new GetRequest { Key = "shouldnotexpire", SpecifiedVersion = null }); Assert.True(results3.Length > 0); }); } }
public void Can_put_with_tag() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put(new PutRequest { Bytes = new byte[]{1,2,3,4}, Key = "test", Tag = 1 }); actions.Commit(); }); table.Batch(actions => { var values = actions.Get(new GetRequest() { Key = "test", }); Assert.Equal(1, values[0].Tag); actions.Commit(); }); } }
public void Save_several_items_for_same_version_will_save_all_of_them() { using (var table = new PersistentHashTable(testDatabase)) { table.Initialize(); table.Batch(actions => { actions.Put("test", new int[0], new byte[] { 1 }); actions.Put("test", new int[0], new byte[] { 2 }); var values = actions.Get("test"); Assert.Equal(2, values.Length); Assert.Equal(1, values[0].Version); Assert.Equal(new byte[] { 1 }, values[0].Data); Assert.Equal(2, values[1].Version); Assert.Equal(new byte[] { 2 }, values[1].Data); }); } }