public void TestMutationDetection() { // tests the object mutation detector using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router)) { // start server server.Start(); using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) { // create reference object TestData data0 = new TestData("Zero", 0); client.SaveObject(data0, "Item0", null); ICoreItem item = client.LoadItem <TestData>("Item0"); string text = item.Text; TestData data = item.GetData <TestData>(false); // - assert not mutated Assert.AreEqual(text, XmlSerializerHelper.SerializeToString(item.GetData <TestData>(false))); // - mutate the object data.field1 = "One"; data.field2 = 1; // - assert mutated Assert.AreNotEqual(text, XmlSerializerHelper.SerializeToString(item.GetData <TestData>(false))); } // shutdown server.Stop(); } } }
public void TestBasicEncryption() { // tests key creation and exchange // - between 2 clients using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router)) { server.Start(); using (ICoreClient sender = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) using (ICoreClient recver = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) { // check un-encrypted traffic Guid evtId1 = sender.SaveObject <TestData>(new TestData("1", 1), "test", null, TimeSpan.MaxValue); List <ICoreItem> recdList1 = recver.LoadItems <TestData>(Expr.ALL); Assert.AreEqual <int>(1, recdList1.Count); ICoreItem recdItem1 = recdList1[0]; Assert.AreEqual <Guid>(evtId1, recdItem1.Id); Assert.IsNull(recdItem1.TranspKeyId); Assert.IsNull(recdItem1.SenderKeyId); Assert.IsNull(recdItem1.RecverKeyId); // generate keys string senderKeyId = sender.CryptoManager.GenerateNewKeys(); string recverKeyId = recver.CryptoManager.GenerateNewKeys(); // send encrypted message and check receiver fails to decrypt ICoreItem sentItem2 = sender.MakeObject <TestData>(new TestData("2", 2), "test", null); sentItem2.TranspKeyId = senderKeyId; sentItem2.SenderKeyId = senderKeyId; Guid evtId2 = sender.SaveItem(sentItem2); List <ICoreItem> recdList2 = recver.LoadItems <TestData>(Expr.ALL); Assert.AreEqual <int>(1, recdList2.Count); ICoreItem recdItem2 = recdList2[0]; Assert.AreEqual <Guid>(evtId2, recdItem2.Id); Assert.AreEqual <Guid>(evtId2, recdItem2.Id); Assert.AreEqual <string>(senderKeyId, recdItem2.TranspKeyId); Assert.AreEqual <string>(senderKeyId, recdItem2.SenderKeyId); Assert.IsNull(recver.CryptoManager.GetTranspKey(senderKeyId)); // set public key at receiver and check authentication recver.CryptoManager.SetPublicKey(senderKeyId, sender.CryptoManager.GetPublicKey(senderKeyId)); Assert.IsTrue(recdItem2.IsSigned); Assert.IsFalse(recdItem2.IsSecret); // set transport key at receiver and recheck decryption recver.CryptoManager.SetTranspKey(senderKeyId, sender.CryptoManager.GetTranspKey(senderKeyId)); object data2 = recdItem2.Data; Assert.IsNotNull(data2); Assert.AreEqual <Type>(typeof(TestData), data2.GetType()); } server.Stop(); } } }
public void TestSerialisingInterfaceTypes() { // tests control of the serialisation type // - interface types using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router)) { // start server server.Start(); using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) { AssetMeasureValue codeValueInstance = new AssetMeasureValue() { Code = "Test", Description = "This is a test", Source = "UnitTest" }; IFpMLCodeValue codeValueInterface = codeValueInstance; // save reference item client.SaveObject(codeValueInstance, "Test0", null, TimeSpan.MaxValue); ICoreItem itemA = client.LoadItem("Test0"); Assert.AreEqual(typeof(AssetMeasureValue).FullName, itemA.DataTypeName); // test interface and instance both serialise identically { client.SaveUntypedObject(codeValueInterface, "Test1", null); ICoreItem itemB = client.LoadItem("Test1"); Assert.AreEqual(typeof(AssetMeasureValue).FullName, itemB.DataTypeName); Assert.AreEqual(itemA.Text, itemB.Text); } { client.SaveObject((AssetMeasureValue)codeValueInterface, "Test2", null, TimeSpan.MaxValue); ICoreItem itemB = client.LoadItem("Test2"); Assert.AreEqual(typeof(AssetMeasureValue).FullName, itemB.DataTypeName); Assert.AreEqual(itemA.Text, itemB.Text); } { // this should fail because interfaces cant be serialised UnitTestHelper.AssertThrows <ArgumentException>("Cannot be an interface type!\r\nParameter name: dataType", () => { client.SaveObject(codeValueInterface, "Test3", null, TimeSpan.MaxValue); }); } { // note: this silently binds to SaveObject<IFpMLCodeValue>(...) which should fail UnitTestHelper.AssertThrows <ArgumentException>("Cannot be an interface type!\r\nParameter name: dataType", () => { client.SaveObject(codeValueInterface, "Test4", null, TimeSpan.MaxValue); }); } } // shutdown server.Stop(); } } }
public void TestWebServiceStartStop() { using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { using (var coreServer = new CoreServer(loggerRef, "UTT", NodeType.Router)) { coreServer.Start(); using (Reference <ICoreClient> clientRef = Reference <ICoreClient> .Create(new CoreClientFactory(loggerRef).SetEnv("UTT").Create())) using (var httpServer = new WebProxyServer()) { httpServer.LoggerRef = loggerRef; httpServer.Client = clientRef; httpServer.Start(); } } } }
public void TestSaveLoadPrivateCacheItems() { using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router)) { server.Start(); using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) using (ICoreCache cacheA = client.CreateCache()) { Guid id = cacheA.SavePrivateObject("data", "name1", null); //ICoreItem item = cacheA.LoadPrivateItem<string>("name1"); ICoreItem item = cacheA.LoadItem <string>("name1"); string data = (string)item.Data; Assert.AreEqual <string>("data", data); } } }
public void CreateHost(int port) { Server = new CoreServer(port, connectionInfo.secretKey); Server.RegisterNestedType <ConnectedPeer>(); Server.OnPeerDisconnected() .Subscribe(OnPeerDisconnected) .AddTo(this); Server.OnReceivedSerializedComponent() .Subscribe(OnReceivedSerializedComponent) .AddTo(this); Server.RegisterToPacket <PlayerJoinRequestPacket, NetPeer>() .Subscribe(OnPlayerJoinRequestPacketReceived) .AddTo(this); Server.Start(); _onHostCreated.OnNext(Unit.Default); }
public CurveUnitTestEnvironment(string nameSpace) { NameSpace = nameSpace; string env = EnvHelper.EnvName(EnvId.Utt_UnitTest); var stopwatch = new Stopwatch(); stopwatch.Start(); var random = new Random(Environment.TickCount); int port = random.Next(8000, 8099); _server = new CoreServer(_logRef, env, NodeType.Router, port, WcfConst.NetTcp); _server.Start(); _client = new CoreClientFactory(_logRef) .SetEnv(env) .SetServers("localhost:" + port.ToString(CultureInfo.InvariantCulture)) .SetProtocols(WcfConst.NetTcp) .Create(); Cache = _client.CreateCache(); LoadConfigDataHelper.LoadCurveConfigurationData(_logRef.Target, Cache, nameSpace); stopwatch.Stop(); Debug.Print("Initialized test environment, in {0} seconds", stopwatch.Elapsed.TotalSeconds); }
public void TestRequestThrottling() { const int numberOfAsyncRequests = 1000; const int serverPort = 9001; string hostAddress = $"localhost:{serverPort}"; using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { NamedValueSet serverSettings = new NamedValueSet(); serverSettings.Set(CfgPropName.EnvName, "UTT"); serverSettings.Set(CfgPropName.Port, serverPort); serverSettings.Set(CfgPropName.Endpoints, WcfConst.NetTcp); using (CoreServer server = new CoreServer(loggerRef, serverSettings)) { server.Start(); using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").SetServers(hostAddress).Create()) { List <IAsyncResult> completions = new List <IAsyncResult>(); try { for (int i = 0; i < numberOfAsyncRequests; i++) { completions.Add(client.SaveObjectBegin(new TestData("Test", i), "Test", null, false, TimeSpan.MaxValue)); //loggerRef.Target.LogDebug("[{0}] save begun...", i.ToString("0000")); } } finally { for (int i = 0; i < numberOfAsyncRequests; i++) { client.SaveEnd(completions[i]); //loggerRef.Target.LogDebug("[{0}] save done.", i.ToString("0000")); } } } } } }
public void TestManualRecovery() { // demonstrates how an application should use the client in its simplest (transient) mode: // - exceptions should be handled by the application; // - client must be disposed and recreated after an exception has occurred; // - subscriptions are not supported. //TimeSpan outageDuration = TimeSpan.FromMinutes(1); //TimeSpan requestTimeout = TimeSpan.FromSeconds(30); using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { loggerRef.Target.LogDebug("----------> test commenced"); // create unit test storage IStoreEngine unitTestStore = new UnitTestStoreEngine(loggerRef.Target); CoreServer server = null; try { var serverSettings = new NamedValueSet(); serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Server); serverSettings.Set(CfgPropName.EnvName, "UTT"); server = new CoreServer(loggerRef, serverSettings) { StoreEngine = unitTestStore }; loggerRef.Target.LogDebug("----------> starting server"); server.Start(); // create 1st client and save object - should succeed Guid id1; using (ICoreClient client1 = new CoreClientFactory(loggerRef) .SetEnv("UTT") .Create()) { id1 = client1.SaveObject(new TestData("Test1", 1), "Test1", null, TimeSpan.MaxValue); // stop server and begin save - should fail with timeout loggerRef.Target.LogDebug("----------> stopping server"); server.Stop(); DisposeHelper.SafeDispose(ref server); client1.RequestTimeout = TimeSpan.FromSeconds(10); UnitTestHelper.AssertThrows <TimeoutException>(() => { client1.SaveObject(new TestData("Test2a", 2), "Test2", null, TimeSpan.MaxValue); }); // further use of client throws more timeout errors UnitTestHelper.AssertThrows <TimeoutException>(() => { client1.LoadObject <TestData>("Test2a"); }); } // create 2nd client - should fail to connect UnitTestHelper.AssertThrows <EndpointNotFoundException>("No server in list 'localhost:8113' found!", () => { using (ICoreClient client2 = new CoreClientFactory(loggerRef) .SetEnv("UTT") .Create()) { client2.SaveObject <TestData>(new TestData("Test2b", 2), "Test2", null, TimeSpan.MaxValue); } }); // restart server server = new CoreServer(loggerRef, serverSettings) { StoreEngine = unitTestStore }; loggerRef.Target.LogDebug("----------> restarting server"); server.Start(); // load 1st object - should succeed ICoreItem item1; ICoreItem item2; using (ICoreClient client3 = new CoreClientFactory(loggerRef) .SetEnv("UTT") .Create()) { item1 = client3.LoadItem <TestData>("Test1"); item2 = client3.LoadItem <TestData>("Test2"); } Assert.IsNotNull(item1); Assert.AreEqual(id1, item1.Id); Assert.IsNull(item2); // done loggerRef.Target.LogDebug("----------> test completed"); server.Stop(); DisposeHelper.SafeDispose(ref server); } finally { DisposeHelper.SafeDispose(ref server); } } }
public void TestServerBridge() { // required environment: // - local env (eg. DEV) server // - lower env (eg. UTT) server // creates the bridge, and check all messages published // in local env are re-published correctly in lower env EnvId localEnvId = EnvId.Dev_Development; string localEnvName = EnvHelper.EnvName(localEnvId); EnvId lowerEnvId = (localEnvId - 1); string lowerEnvName = EnvHelper.EnvName(lowerEnvId); int localPort = 9214; int lowerPort = 9114; using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { CoreClientFactory clientfactory = new CoreClientFactory(loggerRef); using (CoreServer localServer = new CoreServer(loggerRef, localEnvName, NodeType.Router, localPort)) using (CoreServer lowerServer = new CoreServer(loggerRef, lowerEnvName, NodeType.Router, lowerPort)) { // start servers localServer.Start(); lowerServer.Start(); // create clients using (Reference <ICoreClient> localClientRef = Reference <ICoreClient> .Create(clientfactory.SetEnv(localEnvName).SetServers("localhost:" + localPort).Create())) using (ICoreClient lowerClient = clientfactory.SetEnv(lowerEnvName).SetServers("localhost:" + lowerPort).Create()) { using (ServerBridge bridge = new ServerBridge()) { bridge.LoggerRef = loggerRef; bridge.Client = localClientRef; bridge.TargetClient = lowerClient; // test begins here // - start the bridge bridge.Start(); const int sendCount = 500; const int maxWaitSeconds = 5; long excpCount = 0; long recdCount = 0; // subscribe to objects on downstream server ISubscription subs = lowerClient.Subscribe <TestData>(Expr.ALL, delegate(ISubscription subscription, ICoreItem item) { // receiver long count = Interlocked.Increment(ref recdCount); try { TestData data = (TestData)item.Data; //loggerRef.Target.LogDebug("Recd[{0}]", data.field2); Assert.AreEqual <long>(count, data.field2); } catch (Exception) { Interlocked.Increment(ref excpCount); } }, null); long sentCount = 0; // publish n Server events for (int i = 1; i <= sendCount; i++) { Interlocked.Increment(ref sentCount); localClientRef.Target.SaveObject <TestData>(new TestData("Test", i), "Test", null, TimeSpan.MaxValue); } // wait for a short period DateTimeOffset waitStart = DateTimeOffset.Now; DateTimeOffset waitExpiry = waitStart.AddSeconds(maxWaitSeconds); while ((Interlocked.Add(ref recdCount, 0) < Interlocked.Add(ref sentCount, 0)) && (DateTimeOffset.Now < waitExpiry) && (Interlocked.Add(ref excpCount, 0) == 0)) { Thread.Sleep(TimeSpan.FromSeconds(1.0)); loggerRef.Target.LogDebug("Recd/Sent: {0}/{1} items...", Interlocked.Add(ref recdCount, 0), Interlocked.Add(ref sentCount, 0)); } loggerRef.Target.LogDebug("Duration: {0}", (DateTimeOffset.Now - waitStart)); Assert.AreEqual <long>(0, excpCount); Assert.AreEqual <long>(sendCount, recdCount); // done Assert.IsTrue(true); } } } } }
public void TestPagingTechniques() { const bool debugRequests = true; // loads/saves a very large number of objects const int maxLoopCount = 5; const int itemsPerLoop = 400; const int itemsPerPage = 154; const int totalItems = maxLoopCount * itemsPerLoop; using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { NamedValueSet serverSettings = new NamedValueSet(); serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Router); serverSettings.Set(CfgPropName.EnvName, "UTT"); using (CoreServer server = new CoreServer(loggerRef, serverSettings)) { server.Start(); // save using (ICoreClient client1 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) { for (int loop = 0; loop < maxLoopCount; loop++) { ICoreItem[] items = new ICoreItem[itemsPerLoop]; for (int i = 0; i < itemsPerLoop; i++) { client1.DebugRequests = i == 0; int n = loop * itemsPerLoop + i; TestData data = new TestData(n.ToString(), n); NamedValueSet props = new NamedValueSet(new NamedValue("n", n)); items[i] = client1.MakeObject(data, "Test." + n, props); } client1.SaveItems(items); } } // load (using original paging technique) loggerRef.Target.LogDebug("---------- multi page load"); // - slow because it scans and sort the entire data set for each page using (ICoreClient client3 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) { // count the items int itemCount1 = client3.CountObjects <TestData>(null); // now get the items in pages IExpression orderExpr = Expr.Prop("n"); client3.DebugRequests = debugRequests; int itemCount2 = 0; int startRow = 0; List <ICoreItem> page; do { page = client3.LoadItems <TestData>(null, orderExpr, startRow, itemsPerPage); itemCount2 += page.Count; startRow += page.Count; }while (page.Count == itemsPerPage); Assert.AreEqual(totalItems, itemCount1); Assert.AreEqual(totalItems, itemCount2); } // paged load (using pre-load of item header info) loggerRef.Target.LogDebug("---------- header pre-load"); // - faster because it only scans sorts the entire data set once and sorting // can use local compiled methods instead of server-side expression evaluation. using (ICoreClient client4 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) { // get all the items (without data) List <ICoreItemInfo> itemInfoList = client4.LoadItemInfos <TestData>(null); int itemCount1 = itemInfoList.Count; // optionally sort the list here //IExpression orderExpr = Expr.Prop("n"); // now get the items in pages client4.DebugRequests = debugRequests; int itemCount2 = 0; int maxPages = ((itemCount1 / itemsPerPage) + 1); for (int pageNum = 0; pageNum < maxPages; pageNum++) { // get the item names/ids for the current page int startRow = itemsPerPage * pageNum; List <string> itemNames = new List <string>(); for (int i = 0; i < itemsPerPage; i++) { int n = startRow + i; if (n < itemCount1) { itemNames.Add(itemInfoList[n].Name); } } // now get the objects (with data) var page = client4.LoadItems <TestData>(itemNames); itemCount2 += page.Count; } Assert.AreEqual(totalItems, itemCount1); Assert.AreEqual(totalItems, itemCount2); } } } }
public void TestStressServerLoadAndSubscribe() { // return an increasing number of trades until failure // on a 4GB workstation, the limit is about 13,000 trades. Trade trade = XmlSerializerHelper.DeserializeFromString <Trade>( ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.xml")); NamedValueSet tradeProps = new NamedValueSet( ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.nvs")); using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { NamedValueSet serverSettings = new NamedValueSet(); serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Router); serverSettings.Set(CfgPropName.EnvName, "UTT"); using (CoreServer server = new CoreServer(loggerRef, serverSettings)) { server.Start(); using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").SetServers("localhost:8113").Create()) //using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv(EnvId.DEV_Development).Create()) { // delete the test trades IExpression deleteExpr = Expr.StartsWith(Expr.SysPropItemName, "Test."); client.DeleteObjects <Trade>(deleteExpr); const int maxLoops = 6; const int loopRepeat = 1; const int incrementPerLoop = 1024; int itemsPerLoop = 8192; int itemsSaved = 0; for (int loop = 0; loop < maxLoops; loop++) { string loopName = $"Test.{loop}."; for (int repeat = 0; repeat < loopRepeat; repeat++) { // create trades loggerRef.Target.LogDebug("[{0}-{1}] Creating {2} trades...", loop, repeat, itemsPerLoop); ICoreItem[] items = new ICoreItem[itemsPerLoop]; for (int i = 0; i < itemsPerLoop; i++) { string tradeName = $"Test.{loop}.{i}"; items[i] = client.MakeObject(trade, tradeName, tradeProps); itemsSaved++; } client.SaveItems(items); // start subscription loggerRef.Target.LogDebug("[{0}-{1}] Receiving {2} trades...", loop, repeat, itemsPerLoop); long itemsReceived = 0; DateTime testStartedTime = DateTime.Now; DateTime lastReceiveTime = testStartedTime; ISubscription subscription = client.CreateSubscription <Trade>(Expr.StartsWith(Expr.SysPropItemName, loopName)); subscription.UserCallback = delegate { Interlocked.Increment(ref itemsReceived); lastReceiveTime = DateTime.Now; }; //subscription.ExcludeDataBody = true; subscription.Start(); // wait a bit to ensure subscription is up to date while ((Interlocked.Add(ref itemsReceived, 0) < itemsPerLoop) && ((DateTime.Now - testStartedTime) < TimeSpan.FromSeconds(10))) { Thread.Sleep(100); } Thread.Sleep(100); subscription.Cancel(); // load all that have been saved loggerRef.Target.LogDebug("[{0}-{1}] Received {2} trades in {3} seconds.", loop, repeat, itemsReceived, (lastReceiveTime - testStartedTime).TotalSeconds); Assert.AreEqual(itemsPerLoop, Interlocked.Add(ref itemsReceived, 0)); // delete the test trades client.DeleteObjects <Trade>(deleteExpr); GC.Collect(); } // next loop itemsPerLoop += incrementPerLoop; } // for loop } } } }
public void TestStressServerLoadAndRetrieve() { // return an increasing number of trades until failure Trade trade = XmlSerializerHelper.DeserializeFromString <Trade>( ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.xml")); NamedValueSet tradeProps = new NamedValueSet( ResourceHelper.GetResourceWithPartialName(Assembly.GetExecutingAssembly(), "SampleSwap.nvs")); using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { NamedValueSet serverSettings = new NamedValueSet(); serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Router); serverSettings.Set(CfgPropName.EnvName, "UTT"); using (CoreServer server = new CoreServer(loggerRef, serverSettings)) { server.Start(); using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").SetServers("localhost:8113").Create()) //using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv(EnvId.DEV_Development).Create()) { // delete the test trades IExpression deleteExpr = Expr.StartsWith(Expr.SysPropItemName, "Test."); client.DeleteObjects <Trade>(deleteExpr); const int maxLoops = 1; const int loopRepeat = 1; const int incrementPerLoop = 1024; int itemsPerLoop = 8192 - 1024; int itemsSaved = 0; for (int loop = 0; loop < maxLoops; loop++) { for (int repeat = 0; repeat < loopRepeat; repeat++) { // create trades loggerRef.Target.LogDebug("[{0}-{1}] Making {2} trades...", loop, repeat, itemsPerLoop); List <IAsyncResult> completions = new List <IAsyncResult>(); ICoreItem[] items = new ICoreItem[itemsPerLoop]; for (int i = 0; i < itemsPerLoop; i++) { string tradeName = $"Test.{loop}.{i}"; ICoreItem item = client.MakeObject(trade, tradeName, tradeProps); item.Freeze(); // serialises items[i] = item; } loggerRef.Target.LogDebug("[{0}-{1}] Commencing save of {2} trades...", loop, repeat, itemsPerLoop); for (int i = 0; i < itemsPerLoop; i++) { completions.Add(client.SaveItemBegin(items[i])); itemsSaved++; } loggerRef.Target.LogDebug("[{0}-{1}] Completing save of {2} trades...", loop, repeat, itemsPerLoop); foreach (IAsyncResult ar in completions) { client.SaveEnd(ar); } // load all that have been saved string loopName = $"Test.{loop}."; loggerRef.Target.LogDebug("[{0}-{1}] Loading {2} trades...", loop, repeat, itemsPerLoop); List <ICoreItem> tradeItems = client.LoadItems <Trade>(Expr.StartsWith(Expr.SysPropItemName, loopName)); Assert.AreEqual(itemsPerLoop, tradeItems.Count); loggerRef.Target.LogDebug("[{0}-{1}] Unpacking {2} trades...", loop, repeat, itemsPerLoop); List <Trade> trades = new List <Trade>(); foreach (ICoreItem item in tradeItems) { trades.Add((Trade)item.Data); } loggerRef.Target.LogDebug("[{0}-{1}] Retrieved {2} trades.", loop, repeat, itemsPerLoop); // delete the test trades client.DeleteObjects <Trade>(deleteExpr); GC.Collect(); } // next loop itemsPerLoop += incrementPerLoop; } // for loop } } } }
public void TestFailingExpressions() { // tests expressions that fail to evaluate on the server using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { NamedValueSet serverSettings = new NamedValueSet(); serverSettings.Set(CfgPropName.NodeType, (int)NodeType.Router); serverSettings.Set(CfgPropName.EnvName, "UTT"); using (CoreServer server = new CoreServer(loggerRef, serverSettings)) { server.Start(); // save using (ICoreClient client1 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) { client1.SaveObject(new TestData(), "AllValuesNotNull", new NamedValueSet("StrValue/String=A|NumValue/Int32=0"), TimeSpan.MaxValue); client1.SaveObject(new TestData(), "NumValueIsNull", new NamedValueSet("StrValue/String=A"), TimeSpan.MaxValue); client1.SaveObject(new TestData(), "StrValueIsNull", new NamedValueSet("NumValue/Int32=0"), TimeSpan.MaxValue); client1.SaveObject(new TestData(), "AllValuesAreNull", null, TimeSpan.MaxValue); } // load using expression using (ICoreClient client2 = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) { client2.DebugRequests = true; { var items = client2.LoadObjects <TestData>(Expr.BoolAND(Expr.IsEQU("StrValue", "A"), Expr.IsEQU("NumValue", 0))); Assert.AreEqual(1, items.Count); } { var items = client2.LoadObjects <TestData>(Expr.BoolOR(Expr.IsEQU("StrValue", "A"), Expr.IsEQU("NumValue", 0))); Assert.AreEqual(3, items.Count); } { // unknown/missing string property var items = client2.LoadObjects <TestData>(Expr.BoolOR(Expr.IsEQU("StrValue", "A"), Expr.IsEQU("XValue", "X"))); Assert.AreEqual(2, items.Count); } { // unknown/missing non-string property var items = client2.LoadObjects <TestData>(Expr.BoolOR(Expr.IsEQU("StrValue", "A"), Expr.IsEQU("YValue", 1))); Assert.AreEqual(2, items.Count); } { // property missing var items = client2.LoadObjects <TestData>(Expr.IsNull("StrValue")); Assert.AreEqual(2, items.Count); } { // property has value var items = client2.LoadObjects <TestData>(Expr.IsNotNull("StrValue")); Assert.AreEqual(2, items.Count); } { var items = client2.LoadObjects <TestData>(Expr.StartsWith("StrValue", "A")); Assert.AreEqual(2, items.Count); } { var items = client2.LoadObjects <TestData>(Expr.BoolOR(Expr.StartsWith("StrValue", "A"), Expr.IsEQU("NumValue", 0))); Assert.AreEqual(3, items.Count); } } } } }
public void TestCoreCaching() { using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router)) { server.Start(); using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) using (ICoreCache cacheA = client.CreateCache()) using (ICoreCache cacheB = client.CreateCache()) { using (cacheA.SubscribeNoWait <TestData>(Expr.ALL, null, null)) { using (cacheB.SubscribeNoWait <TestData>(Expr.ALL, null, null)) { // publish an item and check all caches are consistent Guid id0 = cacheA.SaveObject <TestData>(new TestData("Zero", 0), "Item0", null, TimeSpan.MaxValue); // cacheA is publisher - should be immediately consistent Assert.AreEqual <int>(1, cacheA.ItemCount); ICoreItem item0a = cacheA.Items[0]; Assert.IsNotNull(item0a); TestData data0a = (TestData)item0a.Data; Assert.IsNotNull(data0a); Assert.AreEqual <string>("Zero", (data0a.field1)); // cacheB is not publisher - allow for propagation delay Thread.Sleep(500); // both caches should now be consistent Assert.AreEqual <int>(1, cacheA.ItemCount); Assert.AreEqual <int>(1, cacheB.ItemCount); ICoreItem item0b = cacheA.Items[0]; Assert.IsNotNull(item0b); TestData data0b = (TestData)item0b.Data; Assert.IsNotNull(data0b); Assert.AreEqual <string>("Zero", (data0b.field1)); Assert.AreEqual <Guid>(item0a.Id, item0b.Id); } // cacheB unsubscribed - should not receive updates from cacheA Guid id1 = cacheA.SaveObject <TestData>(new TestData("One", 1), "Item1", null); ICoreItem data1a = cacheA.LoadItem <TestData>("Item1"); Guid id2 = cacheB.SaveObject <TestData>(new TestData("Two", 2), "Item2", null); ICoreItem data2b = cacheB.LoadItem <TestData>("Item2"); // object is immediately available in local cache but not others Assert.IsNotNull(data1a); Assert.AreEqual <Guid>(id1, data1a.Id); Assert.IsNotNull(data2b); Assert.AreEqual <Guid>(id2, data2b.Id); // wait a bit for propagation Thread.Sleep(500); // both caches should now be 'up-to-date' // - A should receive from B, but not vice versa Assert.AreEqual <int>(3, cacheA.ItemCount); ICoreItem data2a = cacheA.LoadItem <TestData>("Item2"); Assert.IsNotNull(data2a); Assert.AreEqual <Guid>(id2, data2a.Id); // - B should be inconsistent with A Assert.AreEqual <int>(2, cacheB.ItemCount); // - but becomes consistent as soon as we load the missing item ICoreItem data1b = cacheB.LoadItem <TestData>("Item1"); Assert.AreEqual <int>(3, cacheB.ItemCount); Assert.IsNotNull(data1b); Assert.AreEqual <Guid>(id1, data1b.Id); } } } }
public void TestFileImportServer() { // start the server, connect a client1, and shutdown using (ILogger logger = new TraceLogger(true)) { const EnvId env = EnvId.Utt_UnitTest; var logRef = Reference <ILogger> .Create(logger); var random = new Random(Environment.TickCount); int port = random.Next(8000, 8099); using (var server = new CoreServer(logRef, env.ToString(), NodeType.Router, port, WcfConst.NetTcp)) { // start server server.Start(); // connect client using (ICoreClient client = new CoreClientFactory(logRef).SetEnv(env.ToString()).Create()) { // create test import rule var rule = new FileImportRule { RuleName = "UnitTest", SourceLocation = @"C:\windows\system32", TargetLocation = @"c:\temp", CopyFilePatterns = "notep*.exe" }; var name = rule.RuleName; // start the file import server //DateTimeOffset waitCompleted; var target = new FileImportServer { Client = Reference <ICoreClient> .Create(client) }; client.SaveObject(rule, "UnitTest", null, true, TimeSpan.MaxValue); using (target)//logger, env { target.Start(); Thread.Sleep(TimeSpan.FromSeconds(5)); //waitCompleted = DateTimeOffset.Now; target.Stop(); } { var results1 = client.LoadItem <FileImportRule>(name); Assert.IsNotNull(results1); //List<ImportRuleResult> results = client.LoadObjects<ImportRuleResult>(Expr.ALL);//IRuleObject ImportRuleResult //Assert.AreEqual(1, results.Count); //ImportRuleResult result = results[0]; //Assert.AreEqual("UnitTest", result.RuleName); //Assert.AreEqual("Completed", result.ImportResult); //Assert.AreEqual(1, result.FileNames.Length); //Assert.AreEqual("notepad.exe", result.FileNames[0].ToLower()); } //{ // List<ImportFileResult> results = client.LoadObjects<ImportFileResult>(Expr.ALL); // Assert.AreEqual(1, results.Count); // ImportFileResult result = results[0]; // Assert.AreEqual("UnitTest", result.RuleName); // Assert.AreEqual("Completed", result.ImportResult); // Assert.AreEqual("notepad.exe", result.FileName.ToLower()); //} } // explicit shutdown // - not necessary in a "using" block but run it anyway server.Stop(); } } }
public void TestSerialisingDerivedTypes() { // tests control of the serialisation type // - type b (derived from a) is saved as b, loaded as b; // - type b (derived from a) is saved as a, loaded as a (but is type b). // (in this example a = PricingStructure, b = YieldCurve) using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router)) { // start server server.Start(); using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) { { YieldCurve dataA = new YieldCurve { currency = new Currency { Value = "USD" }, algorithm = "FastCubicSpline" }; // - save as derived type client.SaveObject(dataA, "TestA", null, TimeSpan.MaxValue); ICoreItem test1 = client.LoadItem <YieldCurve>("TestA"); Assert.IsNotNull(test1); Assert.IsNotNull(test1.Text); Assert.AreEqual( "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<yieldCurve xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"http://www.fpml.org/FpML-5/reporting\">\r\n <currency>USD</currency>\r\n <algorithm>FastCubicSpline</algorithm>\r\n</yieldCurve>", test1.Text); Assert.AreEqual(typeof(YieldCurve).FullName, test1.DataTypeName); Assert.AreEqual(typeof(YieldCurve), test1.DataType); Assert.IsNotNull(test1.Data); Assert.AreEqual(typeof(YieldCurve), test1.Data.GetType()); // - save as base type client.SaveObject <PricingStructure>(dataA, "TestA", null, TimeSpan.MaxValue); ICoreItem test2 = client.LoadItem <PricingStructure>("TestA"); Assert.IsNotNull(test2); Assert.IsNotNull(test2.Text); Assert.AreEqual( "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<PricingStructure xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:q1=\"http://www.fpml.org/FpML-5/reporting\" xsi:type=\"q1:YieldCurve\">\r\n <q1:currency>USD</q1:currency>\r\n <q1:algorithm>FastCubicSpline</q1:algorithm>\r\n</PricingStructure>", test2.Text); Assert.AreEqual(typeof(PricingStructure).FullName, test2.DataTypeName); Assert.AreEqual(typeof(PricingStructure), test2.DataType); Assert.IsNotNull(test2.Data); Assert.AreEqual(typeof(YieldCurve), test2.Data.GetType()); } { FxCurve dataB = new FxCurve() { quotedCurrencyPair = new QuotedCurrencyPair() { currency1 = new Currency() { Value = "USD" }, currency2 = new Currency() { Value = "JPY" }, quoteBasis = QuoteBasisEnum.Currency2PerCurrency1 } }; // - save as derived type client.SaveObject(dataB, "TestB", null, TimeSpan.MaxValue); ICoreItem test1 = client.LoadItem <FxCurve>("TestB"); Assert.IsNotNull(test1); Assert.IsNotNull(test1.Text); Assert.AreEqual( "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<fxCurve xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"http://www.fpml.org/FpML-5/reporting\">\r\n <quotedCurrencyPair>\r\n <currency1>USD</currency1>\r\n <currency2>JPY</currency2>\r\n </quotedCurrencyPair>\r\n</fxCurve>", test1.Text); Assert.AreEqual(typeof(FxCurve).FullName, test1.DataTypeName); Assert.AreEqual(typeof(FxCurve), test1.DataType); Assert.IsNotNull(test1.Data); Assert.AreEqual(typeof(FxCurve), test1.Data.GetType()); // - save as base type client.SaveObject <PricingStructure>(dataB, "TestB", null, TimeSpan.MaxValue); ICoreItem test2 = client.LoadItem <PricingStructure>("TestB"); Assert.IsNotNull(test2); Assert.IsNotNull(test2.Text); Assert.AreEqual( "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<PricingStructure xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:q1=\"http://www.fpml.org/FpML-5/reporting\" xsi:type=\"q1:FxCurve\">\r\n <q1:quotedCurrencyPair>\r\n <q1:currency1>USD</q1:currency1>\r\n <q1:currency2>JPY</q1:currency2>\r\n </q1:quotedCurrencyPair>\r\n</PricingStructure>", test2.Text); Assert.AreEqual(typeof(PricingStructure).FullName, test2.DataTypeName); Assert.AreEqual(typeof(PricingStructure), test2.DataType); Assert.IsNotNull(test2.Data); Assert.AreEqual(typeof(FxCurve), test2.Data.GetType()); } { // load a collection of the base type and verify specific types List <ICoreItem> items = client.LoadItems <PricingStructure>(Expr.ALL); Assert.AreEqual(2, items.Count); Dictionary <string, PricingStructure> index = new Dictionary <string, PricingStructure>(); foreach (ICoreItem item in items) { index[item.Name] = (PricingStructure)item.Data; } Assert.AreEqual(typeof(YieldCurve), index["TestA"].GetType()); Assert.AreEqual(typeof(FxCurve), index["TestB"].GetType()); } } // shutdown server.Stop(); } } }
public void TestSecretKeyExchange() { // tests key creation and exchange // - between 2 clients using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) { using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router)) { server.Start(); using (ICoreClient sender = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) using (ICoreClient recver = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) { // generate keys string senderKeyId = sender.CryptoManager.GenerateNewKeys(); string recverKeyId = recver.CryptoManager.GenerateNewKeys(); // hardcode the public key exchange sender.CryptoManager.SetPublicKey(recverKeyId, recver.CryptoManager.GetPublicKey(recverKeyId)); recver.CryptoManager.SetPublicKey(senderKeyId, sender.CryptoManager.GetPublicKey(senderKeyId)); sender.DefaultLifetime = TimeSpan.FromMinutes(5); // send secret message containing transport key ICoreItem item1 = sender.MakeObject <string>("", "key", null); TestData sendXKey = new TestData(); sendXKey.field1 = senderKeyId; sendXKey.array1 = new string[1] { sender.CryptoManager.GetTranspKey(senderKeyId) }; item1.SetData(sendXKey); //evt1.ItemName = "key"; item1.SenderKeyId = senderKeyId; item1.RecverKeyId = recverKeyId; Guid evtIdXKey = sender.SaveItem(item1); // send encrypted message ICoreItem item2 = sender.MakeObject <string>("", "data", null); string text2 = XmlSerializerHelper.SerializeToString(new TestData("data", 1)); item2.SetText(text2, typeof(TestData)); item2.TranspKeyId = senderKeyId; item2.SenderKeyId = senderKeyId; Guid evtIdData = sender.SaveItem(item2); // check sender // note: // - although sender published the key, sender cannot see it // - however, sender can see the data ICoreItem sentItemXKey = sender.LoadItem <TestData>("key"); Assert.IsNotNull(sentItemXKey); Assert.AreEqual <Guid>(evtIdXKey, sentItemXKey.Id); Assert.AreEqual <string>("key", sentItemXKey.Name); Assert.IsTrue(sentItemXKey.IsSigned); Assert.IsTrue(sentItemXKey.IsSecret); //object sentTempXKey = sentItemXKey.Data; // this will fail ICoreItem sentItemData = sender.LoadItem <TestData>("data"); Assert.IsNotNull(sentItemData); Assert.AreEqual <Guid>(evtIdData, sentItemData.Id); Assert.AreEqual <string>("data", sentItemData.Name); Assert.IsTrue(sentItemData.IsSigned); Assert.IsFalse(sentItemData.IsSecret); object sentTempData = sentItemData.Data; Assert.IsNotNull(sentTempData); Assert.AreEqual <Type>(typeof(TestData), sentTempData.GetType()); TestData sentTestData = (TestData)sentTempData; Assert.AreEqual <string>("data", sentTestData.field1); Assert.AreEqual <int>(1, sentTestData.field2); // check that secret transport key is received by recver ICoreItem recdItemXKey = recver.LoadItem <TestData>("key"); Assert.IsNotNull(recdItemXKey); Assert.AreEqual <Guid>(evtIdXKey, recdItemXKey.Id); Assert.AreEqual <string>("key", recdItemXKey.Name); Assert.IsTrue(recdItemXKey.IsSigned); Assert.IsTrue(recdItemXKey.IsSecret); object recdTempXKey = recdItemXKey.Data; Assert.IsNotNull(recdTempXKey); Assert.AreEqual <Type>(typeof(TestData), recdTempXKey.GetType()); TestData recdTestXKey = (TestData)recdTempXKey; Assert.AreEqual <string>(recdTestXKey.field1, senderKeyId); Assert.IsNotNull(recdTestXKey.array1); Assert.AreEqual <int>(1, recdTestXKey.array1.Length); Assert.AreEqual <string>(recdTestXKey.array1[0], sender.CryptoManager.GetTranspKey(senderKeyId)); // set the transport key and receive the 2nd data message recver.CryptoManager.SetTranspKey(recdTestXKey.field1, recdTestXKey.array1[0]); ICoreItem recdItemData = recver.LoadItem <TestData>("data"); Assert.IsNotNull(recdItemData); Assert.AreEqual <Guid>(evtIdData, recdItemData.Id); Assert.AreEqual <string>("data", recdItemData.Name); Assert.IsTrue(recdItemData.IsSigned); Assert.IsFalse(recdItemData.IsSecret); object recdTempData = recdItemData.Data; Assert.IsNotNull(recdTempData); Assert.AreEqual <Type>(typeof(TestData), recdTempData.GetType()); TestData recdTestData = (TestData)recdTempData; Assert.AreEqual <string>("data", recdTestData.field1); Assert.AreEqual <int>(1, recdTestData.field2); } server.Stop(); } } }