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 TestMDSBloomberg()
{
// test basic start, request snapshot, and stop functions
// - create a MDS client with direct connection to provider
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
IModuleInfo clientInfo = new V131ModuleInfo(new V131ClientInfo());
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv(BuildConst.BuildEnv).Create())
{
const string curveName = "Orion.V5r3.Configuration.PricingStructures.QR_LIVE.RateCurve.AUD-BBR-BBSW-3M";
ICoreItem marketItem = client.LoadItem <Market>(curveName);
if (marketItem == null)
{
throw new ApplicationException("Market '" + curveName + "' not found!");
}
var market = (Market)marketItem.Data;
//PricingStructure ps = market.Items[0];
PricingStructureValuation psv = market.Items1[0];
QuotedAssetSet quotedAssetSet = ((YieldCurveValuation)psv).inputs;
using (IMarketDataClient mdc = new MarketDataRealtimeClient(
loggerRef, null, client,
MDSProviderId.Bloomberg))//MDSProviderId.GlobalIB
{
QuotedAssetSet data = mdc.GetMarketQuotes(
MDSProviderId.Bloomberg, clientInfo, Guid.NewGuid(), true,
null,
quotedAssetSet).Result;
Assert.IsNotNull(data);
}
}
}
}
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 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);
}
}
}
static void Main(string[] args)
{
Reference <ILogger> loggerRef = Reference <ILogger> .Create(new ConsoleLogger("TestWebMdc: "));
loggerRef.Target.LogInfo("Running...");
try
{
// get some market quotes from for a Highlander FX curve
// and get a Highlander volatility matrix
const string curveName = "Orion.V5r3.Configuration.PricingStructures.QR_LIVE.FxCurve.AUD-USD";
QuotedAssetSet quotedAssetSet;
using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv(BuildConst.BuildEnv).Create())
{
ICoreItem marketItem = client.LoadItem <Market>(curveName);
if (marketItem == null)
{
throw new ApplicationException("Market '" + curveName + "' not found!");
}
var market = (Market)marketItem.Data;
//PricingStructure ps = market.Items[0];
PricingStructureValuation psv = market.Items1[0];
var valuation = psv as YieldCurveValuation;
if (valuation != null)
{
quotedAssetSet = valuation.inputs;
}
else
{
var curveValuation = psv as FxCurveValuation;
if (curveValuation != null)
{
quotedAssetSet = new QuotedAssetSet
{
instrumentSet = curveValuation.spotRate.instrumentSet,
assetQuote = curveValuation.spotRate.assetQuote
}
}
;
else
{
throw new NotSupportedException("Unsupported PricingStructureValuation type: " + psv.GetType().Name);
}
}
}
//Copied from the working version
const int port = 9123;
// create MDS client
using (IMarketDataClient mdc = MarketDataFactory.Create(loggerRef, null, "localhost:" + port.ToString(CultureInfo.InvariantCulture)))//This was null in the 3rd parameter.
{
{
const MDSProviderId providerId = MDSProviderId.Bloomberg;
loggerRef.Target.LogInfo("----- {0} Market Quotes -----", providerId);
QuotedAssetSet quotes = mdc.GetMarketQuotes(
providerId, null, Guid.NewGuid(), true, null,
quotedAssetSet).Result;
LogResults(loggerRef.Target, quotes);
}
{
const MDSProviderId providerId = MDSProviderId.GlobalIB;
loggerRef.Target.LogInfo("----- {0} Volatility Matrix -----", providerId);
var matrixProps = new NamedValueSet();
matrixProps.Set("Function", "MarketData");
matrixProps.Set("Market", "EOD");
matrixProps.Set("CurveName", "AUD-Swap");
matrixProps.Set("PricingStructureType", "RateATMVolatilityMatrix");
QuotedAssetSet matrix = mdc.GetPricingStructure(
providerId, null, Guid.NewGuid(), true, null,
matrixProps).Result;
LogResults(loggerRef.Target, matrix);
}
}
}
catch (Exception e)
{
loggerRef.Target.Log(e);
}
loggerRef.Target.LogInfo("Completed.");
loggerRef.Target.LogInfo("Press ENTER to exit.");
Console.ReadLine();
}
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();
}
}
}
