public void PropertyBagTwoWayObjectSerializationTest()
{
var bag = new PropertyBag();
bag.Add("key", "Value");
bag.Add("Key2", 100.10M);
bag.Add("Key3", Guid.NewGuid());
bag.Add("Key4", DateTime.Now);
bag.Add("Key5", true);
bag.Add("Key7", new byte[3] {
42, 45, 66
});
bag.Add("Key8", null);
bag.Add("Key9", new ComplexObject()
{
Name = "Rick",
Entered = DateTime.Now,
Count = 10
});
string xml = bag.ToXml();
TestContext.WriteLine(bag.ToXml());
bag.Clear();
bag.FromXml(xml);
Assert.IsTrue(bag["key"] as string == "Value");
Assert.IsInstanceOfType(bag["Key3"], typeof(Guid));
Assert.IsNull(bag["Key8"]);
//Assert.IsNull(bag["Key10"]);
Assert.IsInstanceOfType(bag["Key9"], typeof(ComplexObject));
}
public async void TestCreateUpdateUsers()
{
// create users.
PropertyBag bag = new PropertyBag();
string password = "";
List <User> list = new List <User>();
for (int n = 0; n < 10; ++n)
{
// generate using an easily reproducible safe-key.
// the username, role and email help us identify these users later.
bag["username"] = $"{CardsavrSession.e2e_identifier}_{CardsavrSession.random.Next(1000)}_{n}";
password = $"{CardsavrSession.e2e_identifier}_{CardsavrSession.random.Next(1000)}_{n}";
bag["password"] = password;
bag["role"] = "customer_agent";
bag["first_name"] = $"Otto_{n}";
bag["last_name"] = $"Matic_{n}";
bag["email"] = $"cardsavr_e2e_{CardsavrSession.random.Next(1000)}@gmail.com";
CardSavrResponse <User> result = await this.session.http.CreateUserAsync(bag);
}
CardSavrResponse <List <User> > users = await this.session.http.GetUsersAsync(null, new Paging()
{
PageLength = 100
});
foreach (User user in users.Body)
{
if (!user.username.StartsWith(CardsavrSession.e2e_identifier))
{
continue;
}
bag.Clear();
bag["id"] = user.id;
bag["email"] = "new_" + user.email;
CardSavrResponse <List <User> > updated_users = await this.session.http.UpdateUserAsync(user.id, bag);
//log.Info(JsonConvert.SerializeObject(updated_users.Body[0], Formatting.Indented));
Assert.Equal(bag["email"], updated_users.Body[0].email);
list.Add(user);
}
Assert.Equal(10, list.Count);
CardsavrHelper helper = new CardsavrHelper();
CardsavrSession.InstanceConfig config = session.getConfig();
helper.SetAppSettings(config.cardsavr_server, config.app_name, config.app_key, CardsavrSession.rejectUnauthorized);
//use the latest user
string testing_agent = list[list.Count - 1].username;
await helper.LoginAndCreateSession(testing_agent, password);
string new_password = await helper.RotateAgentPassword(testing_agent);
await helper.CloseSession(testing_agent);
ClientSession login = await helper.LoginAndCreateSession(testing_agent, new_password);
Assert.NotNull(login);
}
internal void Set1033Default(object sender, System.EventArgs e)
{
PropertyBag.Clear();
string[] lines = Default1033.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
foreach (string line in lines)
{
int position = line.IndexOf("=");
string name = line.Substring(0, position);
string value = line.Substring(position + 1);
PropertyBag.Add(name, value);
}
RaisePropertyChanged("");
}
public void ItShouldBehaveLikeASafeDictionary()
{
var bag = new PropertyBag
{
["foo"] = 1,
["bar"] = "foobar"
};
bag["foo"].Should().Be(1);
bag["bar"].Should().Be("foobar");
bag["unknown"].Should().BeNull();
bag.Should().HaveCount(2);
bag.Clear();
bag["foo"].Should().BeNull();
}
public void PropertyBagTwoWayValueTypeSerializationTest()
{
var bag = new PropertyBag <decimal>();
bag.Add("key", 10M);
bag.Add("Key1", 100.10M);
bag.Add("Key2", 200.10M);
bag.Add("Key3", 300.10M);
string xml = bag.ToXml();
TestContext.WriteLine(bag.ToXml());
bag.Clear();
bag.FromXml(xml);
Assert.IsTrue(bag["Key1"] == 100.10M);
Assert.IsTrue(bag["Key3"] == 300.10M);
}
// TODO: Should merge with implementation for the general connection so that it is 100% compatible
/// <summary>
///
/// </summary>
/// <param name="graph"></param>
/// <param name="token"></param>
public void ReconnectClient(NetGraph graph, ProxyToken token)
{
IDataAdapter client = null;
bool connected = false;
PropertyBag networkService = graph.ConnectionProperties.GetRelativeBag("NetworkService");
PropertyBag clientProperties = graph.ConnectionProperties.GetRelativeBag("Client");
PropertyBag tokenProperties = graph.ConnectionProperties.GetRelativeBag("Token");
try
{
while (graph.Parent != null)
{
graph = graph.Parent;
}
if (token != null)
{
// If passed in a token we need to apply filters to it
token = FilterToken(token);
}
else
{
// Use original post-filtered
token = (ProxyToken)networkService.GetRelativeValue("Token");
}
if (token.Status == NetStatusCodes.Success)
{
clientProperties.Clear();
if (token.Client == null)
{
client = _proxyClient.Connect(token, _logger, graph.Meta, _globalMeta, clientProperties);
}
else
{
client = token.Client.Connect(token, _logger, graph.Meta, _globalMeta, clientProperties);
}
tokenProperties.Clear();
token.PopulateBag(tokenProperties);
// Negotiate SSL or other bespoke encryption mechanisms
if (token.Layers != null)
{
// Bind but disabling server layer
NetworkLayerBinding binding = DefaultBinding & ~NetworkLayerBinding.Server;
foreach (INetworkLayer layer in token.Layers)
{
IDataAdapter server = null;
layer.Negotiate(ref server, ref client, token, _logger, graph.Meta, _globalMeta, graph.ConnectionProperties, binding);
}
}
graph.BindEndpoint((Guid)networkService.GetRelativeValue("ClientId"), client);
IDataAdapter serverAdapter = networkService.GetRelativeValue("ServerAdapter");
if (token.NetworkDescription != null)
{
graph.NetworkDescription = token.NetworkDescription;
}
else
{
graph.NetworkDescription = String.Format("{0} <=> {1}",
serverAdapter.Description, client.Description);
}
IDataAdapter oldClient = networkService.GetRelativeValue("ClientAdapter");
networkService.AddValue("ClientAdapter", client);
networkService.AddValue("Token", token);
oldClient.Dispose();
connected = true;
}
else
{
_logger.LogVerbose(Properties.Resources.ProxyNetworkService_ConnectionFiltered);
}
}
catch (Exception ex)
{
_logger.LogException(ex);
}
finally
{
if (!connected)
{
try
{
if (client != null)
{
client.Dispose();
}
}
catch (Exception ex)
{
Logger.SystemLogger.LogException(ex);
}
}
}
}
public void Refresh(UTinyType type, UTinyObject defaultValue, bool skipTypeCheck = false)
{
Assert.IsNotNull(type);
var fields = type.Fields;
Assert.IsTrue(type.TypeCode == UTinyTypeCode.Struct ||
type.TypeCode == UTinyTypeCode.Component ||
type.TypeCode == UTinyTypeCode.Enum ||
type.TypeCode == UTinyTypeCode.Configuration);
// Rebuild all fields and re-map the indicies correctly
MigrateFields(fields, m_FieldValues);
// Dynamically rebuild the property bag
m_PropertyBag.Clear();
// Migrate dynamic values
if (null != m_DynamicValues)
{
for (var i = 0; i < fields.Count; i++)
{
object dynamicValue;
if (!m_DynamicValues.TryGetValue(fields[i].Name, out dynamicValue))
{
continue;
}
m_FieldValues[i].Value = dynamicValue;
m_FieldValues[i].Overridden = true;
}
m_DynamicValues = null;
}
for (var i = 0; i < fields.Count; i++)
{
var field = fields[i];
var fieldName = field.Name;
var fieldType = field.FieldType.Dereference(type.Registry);
var fieldValue = m_FieldValues[i];
if (null == fieldType)
{
continue;
}
// Force the field type to be refreshed if needed
if (!skipTypeCheck)
{
fieldType.Refresh();
}
// The default value for this field
var fieldDefaultValue = defaultValue?[fieldName];
if (!fieldValue.Overridden && fieldType.IsPrimitive && !field.Array)
{
fieldValue.Value = fieldDefaultValue;
}
else
{
fieldValue.Value = MigrateFieldValue(m_Object.Registry, this, fieldValue.Value, fieldType, field.Array, fieldDefaultValue);
}
// @HACK
if (fieldValue.Value is UTinyObject)
{
(fieldValue.Value as UTinyObject).Name = fieldName;
}
else if (fieldValue.Value is UTinyList)
{
(fieldValue.Value as UTinyList).Name = fieldName;
}
m_PropertyBag.AddProperty(CreateFieldProperty(field.Id, i, fieldName, fieldType, field.Array));
IncrementVersion(null, this);
}
}
public void TestPropertyBagBehavior()
{
PropertyBag bag = new PropertyBag(new MessageObjectSchema());
Assert.IsFalse(bag.IsNew);
Assert.IsNotNull(bag["ToRecipients"]);
Assert.IsNotNull(bag["CcRecipients"]);
bag.MarkAsNew();
Assert.IsTrue(bag.IsNew);
bag["Subject"] = "Test";
Assert.IsTrue(bag.GetChangedPropertyNames().Count == 1);
Assert.AreEqual("Test", bag["Subject"]);
bag.Clear();
Assert.IsNotNull(bag["ToRecipients"]);
Assert.IsNotNull(bag["CcRecipients"]);
Assert.IsNull(bag["Subject"]);
Assert.ThrowsException <KeyNotFoundException>(() => { bag["SomeNonExistingKey"] = "value"; });
Assert.ThrowsException <KeyNotFoundException>(() =>
{
object obj = bag["SomeNonExistingKey"];
});
Assert.ThrowsException <InvalidOperationException>(() => { bag["Subject"] = 546; });
bag["Body"] = new ItemBody()
{
Content = "a"
};
Assert.IsTrue(bag.IsPropertyChanged("Body"));
bag["Body"] = null;
Assert.IsNull(bag["Body"]);
// Value types are set to default values upon
// assigning null.
bag["IsRead"] = true;
Assert.IsTrue((bool)bag["IsRead"]);
bag["IsRead"] = null;
Assert.IsFalse((bool)bag["IsRead"]);
Assert.ThrowsException <KeyNotFoundException>(() =>
{
// Message doesn't have that property and should throw
// key not found exception.
object totalItemCount = bag["TotalItemCount"];
});
Assert.ThrowsException <KeyNotFoundException>(() =>
{
// Message doesn't have that property and should throw
// key not found exception.
object totalItemCount = bag[MailFolderObjectSchema.TotalItemCount];
});
Assert.ThrowsException <KeyNotFoundException>(() =>
{
// Message doesn't have that property and should throw
// key not found exception.
bag[MailFolderObjectSchema.TotalItemCount] = 8;
});
Assert.ThrowsException <ArgumentNullException>(() => { bag = new PropertyBag(null); });
}
public void PropertyBagTwoWayObjectSerializationTest()
{
var bag = new PropertyBag();
bag.Add("key", "Value");
bag.Add("Key2", 100.10M);
bag.Add("Key3", Guid.NewGuid());
bag.Add("Key4", DateTime.Now);
bag.Add("Key5", true);
bag.Add("Key7", new byte[3] { 42, 45, 66 } );
bag.Add("Key8", null);
bag.Add("Key9", new ComplexObject() { Name = "Rick",
Entered = DateTime.Now,
Count = 10 });
string xml = bag.ToXml();
TestContext.WriteLine(bag.ToXml());
bag.Clear();
bag.FromXml(xml);
Assert.IsTrue(bag["key"] as string == "Value");
Assert.IsInstanceOfType( bag["Key3"], typeof(Guid));
Assert.IsNull(bag["Key8"]);
//Assert.IsNull(bag["Key10"]);
Assert.IsInstanceOfType(bag["Key9"], typeof(ComplexObject));
}
public void PropertyBagTwoWayValueTypeSerializationTest()
{
var bag = new PropertyBag<decimal>();
bag.Add("key", 10M);
bag.Add("Key1", 100.10M);
bag.Add("Key2", 200.10M);
bag.Add("Key3", 300.10M);
string xml = bag.ToXml();
TestContext.WriteLine(bag.ToXml());
bag.Clear();
bag.FromXml(xml);
Assert.IsTrue(bag["Key1"] == 100.10M);
Assert.IsTrue(bag["Key3"] == 300.10M);
}
public async void TestCreateJob()
{
List <Cardholder> cardholders = new List <Cardholder>();
// create cardholders.
PropertyBag bag = new PropertyBag();
int count = 2;
string[] safeKeys = new string[count];
for (int n = 0; n < count; ++n)
{
// generate using an easily reproducible safe-key.
bag["cuid"] = $"{CardsavrSession.e2e_identifier}_job_tests_{CardsavrSession.random.Next(10000)}_{n}";
bag["first_name"] = $"Otto_{n}_cardholder";
bag["last_name"] = $"Matic_{n}_cardholder";
bag["email"] = $"cardsavr_e2e_{CardsavrSession.random.Next(10000)}@gmail.com";
safeKeys[n] = n % 2 == 0 ? null : CardsavrSession.GenerateBogus32BitPassword(bag.GetString("cuid"));
CardSavrResponse <Cardholder> result = await this.session.http.CreateCardholderAsync(bag, safeKeys[n]);
cardholders.Add(result.Body);
}
Assert.Equal(cardholders.Count, count);
for (int n = 0; n < count; ++n)
{
bag.Clear();
bag["cardholder_id"] = cardholders[n].id;
bag["merchant_site_id"] = 1;
bag["username"] = "******";
bag["password"] = "";
CardSavrResponse <Account> account = await this.session.http.CreateAccountAsync(bag, safeKeys[n]);
Assert.Equal(HttpStatusCode.Created, account.StatusCode);
bag.Clear();
bag = new PropertyBag()
{
{ "cardholder_id", cardholders[n].id },
{ "requesting_brand", "mbudos" },
{ "status", "INITIATED" },
{ "account_id", account.Body.id }
};
CardSavrResponse <SingleSiteJob> job = await this.session.http.CreateSingleSiteJobAsync(bag, safeKeys[n]);
Assert.Equal(HttpStatusCode.Created, job.StatusCode);
CardSavrResponse <List <SingleSiteJob> > singleJobs = await this.session.http.GetSingleSiteJobsAsync(
new NameValueCollection()
{
{ "ids", job.Body.id.ToString() }
}
);
log.Info($"retrieved {singleJobs.Body.Count} single-site jobs.");
foreach (SingleSiteJob sj in singleJobs.Body)
{
Assert.Equal(job.Body.id, sj.id);
}
bag.Clear();
bag["status"] = "CANCEL_REQUESTED";
// NOT BACKWARD COMPATIBLE - Only using agent now
job = await this.session.http.UpdateSingleSiteJobAsync(job.Body.id, bag, null);
log.Info($"{job.Body.id}: {job.Body.status}");
Assert.Equal(job.Body.status, bag["status"]);
}
CardSavrResponse <List <Cardholder> > cardholderResponse = await this.session.http.GetCardholdersAsync(null);
foreach (Cardholder c in cardholderResponse.Body)
{
if (c.cuid.StartsWith($"{CardsavrSession.e2e_identifier}_job_tests"))
{
await this.session.http.DeleteCardholderAsync(c.id);
count--;
}
}
Assert.Equal(0, count);
}
public async void TestCreateAccounts()
{
List <Cardholder> cardholders = new List <Cardholder>();
// create cardholders.
PropertyBag bag = new PropertyBag();
int count = 10;
string[] safeKeys = new string[count];
for (int n = 0; n < count; ++n)
{
// generate using an easily reproducible safe-key.
bag["cuid"] = $"{CardsavrSession.e2e_identifier}_account_tests_{CardsavrSession.random.Next(10000)}_{n}";
bag["first_name"] = $"Otto_{n}_cardholder";
bag["last_name"] = $"Matic_{n}_cardholder";
bag["email"] = $"cardsavr_e2e_{CardsavrSession.random.Next(10000)}@gmail.com";
safeKeys[n] = n % 2 == 0 ? null : CardsavrSession.GenerateBogus32BitPassword(bag.GetString("cuid"));
CardSavrResponse <Cardholder> result = await this.session.http.CreateCardholderAsync(bag, safeKeys[n]);
cardholders.Add(result.Body);
}
Assert.Equal(cardholders.Count, count);
//MerchantSite site = ctx.GetSyntheticSite();
CardSavrResponse <List <MerchantSite> > sites = await this.session.http.GetMerchantSitesAsync(new NameValueCollection()
{
{ "host", "dynamic-synthetic.herokuapp.com/index.html" }
});
for (int n = 0; n < count; ++n)
{
// create an account.
bag.Clear();
bag["cardholder_id"] = cardholders[n].id;
bag["merchant_site_id"] = sites.Body[0].id;
bag["username"] = "******";
bag["password"] = "";
CardSavrResponse <Account> result = await this.session.http.CreateAccountAsync(bag, safeKeys[n]);
Assert.Equal(HttpStatusCode.Created, result.StatusCode);
log.Info($"created account {result.Body.id} for cardholder-id={cardholders[n].id} ({cardholders[n].cuid})");
// update it.
bag.Clear();
bag["password"] = $"{CardsavrSession.e2e_identifier}-{CardsavrSession.e2e_identifier}";
result = await this.session.http.UpdateAccountAsync(result.Body.id, bag, null, safeKeys[n]);
Assert.Equal(HttpStatusCode.Created, result.StatusCode);
log.Info($"updated account-id={result.Body.id}");
if (safeKeys[n] != null)
{
Exception ex = await Assert.ThrowsAsync <RequestException>(async() => {
result = await this.session.http.UpdateAccountAsync(result.Body.id, bag, null, null);
});
Assert.True(ex.Message.IndexOf("No safe_key for this cardholder_id") >= 0);
}
}
CardSavrResponse <List <Cardholder> > cardholderResponse = await this.session.http.GetCardholdersAsync(null);
foreach (Cardholder c in cardholderResponse.Body)
{
if (c.cuid.StartsWith($"{CardsavrSession.e2e_identifier}_account_tests"))
{
await this.session.http.DeleteCardholderAsync(c.id);
count--;
}
}
Assert.Equal(0, count);
}
public async void TestCreateCards()
{
List <Cardholder> cardholders = new List <Cardholder>();
// create cardholders.
PropertyBag bag = new PropertyBag();
int count = 2;
string[] safeKeys = new string[count];
for (int n = 0; n < count; ++n)
{
// generate using an easily reproducible safe-key.
bag["cuid"] = $"{CardsavrSession.e2e_identifier}_account_tests_{CardsavrSession.random.Next(10000)}_{n}";
bag["first_name"] = $"Otto_{n}_cardholder";
bag["last_name"] = $"Matic_{n}_cardholder";
bag["email"] = $"cardsavr_e2e_{CardsavrSession.random.Next(10000)}@gmail.com";
safeKeys[n] = n % 2 == 0 ? null : CardsavrSession.GenerateBogus32BitPassword(bag.GetString("cuid"));
CardSavrResponse <Cardholder> result = await this.session.http.CreateCardholderAsync(bag, safeKeys[n]);
cardholders.Add(result.Body);
}
Assert.Equal(cardholders.Count, count);
for (int n = 0; n < count; ++n)
{
bag.Clear();
// create an address.
bag["cardholder_id"] = cardholders[n].id;
bag["is_primary"] = true;
bag["address1"] = $"{CardsavrSession.random.Next(1000, 9000)} SDK Ave NE";
bag["address2"] = CardsavrSession.e2e_identifier;
bag["city"] = "Seattle";
bag["subnational"] = "Washington";
bag["country"] = "USA";
bag["postal_code"] = "98119";
Address addr = (await this.session.http.CreateAddressAsync(bag)).Body;
Assert.Equal(addr.address1, bag["address1"]);
log.Info($"created primary address {addr.id} for cardholder: {cardholders[n].first_name} {cardholders[n].last_name} ({cardholders[n].id})");
// update it.
bag.Clear();
bag["address1"] = $"{CardsavrSession.random.Next(1000, 9000)} CSharp-SDK Ave NE";
addr = (await this.session.http.UpdateAddressAsync(addr.id, bag)).Body[0];
Assert.Equal(addr.address1, bag["address1"]);
log.Info($"updated primary address {addr.id} for cardholder: {cardholders[n].first_name} {cardholders[n].last_name} ({cardholders[n].id})");
// the card we create uses our (possibly truncated) special identifier as the color
// so we can identify it later if needed.
DateTime expire = DateTime.Now.AddYears(1);
string expYear = (expire.Year % 2000).ToString();
string expMonth = expire.Month.ToString();
string pan = "4111111111111111";
PropertyBag body = new PropertyBag()
{
{ "cardholder_id", cardholders[n].id },
{ "address_id", addr.id },
{ "pan", pan },
{ "cvv", "345" },
{ "par", ApiUtil.GenerateRandomPAR(pan, expMonth, expYear, cardholders[n].cuid) },
{ "first_name", cardholders[n].first_name },
{ "last_name", cardholders[n].last_name },
{ "name_on_card", "BOGUS CARD" },
{ "expiration_month", expMonth },
{ "expiration_year", expYear }
};
// our test cardholders sometimes have a known safe-key.
// NOT BACKWARD COMPATIBLE - client is now always the agent
CardSavrResponse <Card> card = await this.session.http.CreateCardAsync(body, safeKeys[n]);
log.Info($"created card-id={card.Body.id}");
// update it: just change the address.
body.Clear();
body.Add("id", card.Body.id);
body.Add("name_on_card", "REALLY BOGUS CARD");
CardSavrResponse <List <Card> > upd = await this.session.http.UpdateCardAsync(null, body);
Assert.Equal(upd.Body[0].name_on_card, body["name_on_card"]);
log.Info($"update card for cardholder \"{cardholders[n].cuid}\"");
}
CardSavrResponse <List <Cardholder> > cardholderResponse = await this.session.http.GetCardholdersAsync(null);
foreach (Cardholder c in cardholderResponse.Body)
{
if (c.cuid.StartsWith($"{CardsavrSession.e2e_identifier}_account_tests"))
{
await this.session.http.DeleteCardholderAsync(c.id);
count--;
}
}
Assert.Equal(0, count);
}
