public void TestRequestAccountRelations()
{
var deferred = new Task(() => { });
_remote = new Remote(ServerUrl);
MessageResult <AccountRelationsResponse> response = null;
_remote.Connect(r =>
{
var options = new AccountRelationsOptions();
options.Limit = 1;
options.Account = "j9FGhAW9dSzL3RjbXkyW6Z6bHGxFk8cmB1";
var req = _remote.RequestAccountRelations(options);
req.Submit(r1 =>
{
response = r1;
deferred.Start();
});
});
Assert.IsTrue(deferred.Wait(DeferredWaitingTime));
Assert.IsNotNull(response);
var result = response.Result;
Assert.IsNotNull(result);
Assert.AreEqual("j9FGhAW9dSzL3RjbXkyW6Z6bHGxFk8cmB1", result.Account);
Assert.IsNotNull(result.Lines);
}
private void InitRequestAccountRelationsOptions()
{
var options = new AccountRelationsOptions();
options.Account = "j9FGhAW9dSzL3RjbXkyW6Z6bHGxFk8cmB1";
options.Ledger = new LedgerSettings();
pgRequestAccountRelationsOptions.SelectedObject = options;
}
public void TestRequestAccountRelationsResponse()
{
var remote = new Remote("");
remote.SetMockServer(new MockServer(remote, "RequestAccountRelations.json"));
MessageResult <AccountRelationsResponse> response = null;
var deferred = new Task(() => { });
var options = new AccountRelationsOptions();
options.Account = "jJ3KZo6Zr3BVLiXBBKqMfQoQZHiYFZKNFT";
remote.RequestAccountRelations(options).Submit(r =>
{
response = r;
deferred.Start();
});
Assert.IsTrue(deferred.Wait(DeferredWaitingTime));
Assert.IsNotNull(response);
var result = response.Result;
Assert.IsNotNull(result);
Assert.AreEqual("85D1BA494D44582FBDA5F3D51BCB8C55435FF764E23292074A9F7493DD7E0FE9", result.Marker);
Assert.AreEqual("jMw3xrkX2ySwdQiEorymyuTLUSSa85wvSr", result.Account);
Assert.AreEqual("A7C9D84B7FAD0AE7DA7A835AA74FAAF02CF69042735E32EA13EEB30C00CD972E", result.LedgerHash);
Assert.AreEqual((uint)9646353, result.LedgerIndex);
Assert.IsNotNull(result.Lines);
Assert.AreEqual(3, result.Lines.Length);
var line0 = result.Lines[0];
Assert.AreEqual("jGa9J9TkqtBcUoHe2zqhVFFbgUVED6o9or", line0.Account);
Assert.AreEqual("1.18017", line0.Balance);
Assert.AreEqual("CNY", line0.Currency);
Assert.AreEqual("10000000000", line0.Limit);
Assert.AreEqual("0", line0.LimitPeer);
Assert.IsTrue(line0.NoSkywell);
Assert.AreEqual(0, line0.QualityIn);
Assert.AreEqual(0, line0.QualityOut);
var line1 = result.Lines[1];
Assert.AreEqual("CCA", line1.Currency);
Assert.AreEqual("js7M6x28mYDiZVJJtfJ84ydrv2PthY9W9u", line1.Issuer);
Assert.AreEqual("0.01", line1.Limit);
Assert.AreEqual("jJ3KZo6Zr3BVLiXBBKqMfQoQZHiYFZKNFT", line1.LimitPeer);
Assert.AreEqual(1, line1.RelationType);
var line2 = result.Lines[2];
Assert.AreEqual("CCA", line2.Currency);
Assert.AreEqual("js7M6x28mYDiZVJJtfJ84ydrv2PthY9W9u", line2.Issuer);
Assert.AreEqual("0.02", line2.Limit);
Assert.AreEqual("jJ3KZo6Zr3BVLiXBBKqMfQoQZHiYFZKNFT", line2.LimitPeer);
Assert.AreEqual(3, line2.RelationType);
}
public void TestRequestAccountRelations_Invalid()
{
var deferred = new Task(() => { });
MessageResult <AccountRelationsResponse> response = null;
var options = new AccountRelationsOptions();
options.Account = "abcxyz";
_remote.RequestAccountRelations(options).Submit(r =>
{
response = r;
deferred.Start();
});
Assert.IsTrue(deferred.Wait(DeferredWaitingTime));
Assert.IsNotNull(response);
Assert.IsInstanceOfType(response.Exception, typeof(InvalidAddressException));
deferred = new Task(() => { });
response = null;
options = new AccountRelationsOptions();
options.Ledger = new LedgerSettings();
options.Ledger.LedgerHash = "abcxyz";
_remote.RequestAccountRelations(options).Submit(r =>
{
response = r;
deferred.Start();
});
Assert.IsTrue(deferred.Wait(DeferredWaitingTime));
Assert.IsNotNull(response);
Assert.IsInstanceOfType(response.Exception, typeof(InvalidHashException));
deferred = new Task(() => { });
response = null;
options = new AccountRelationsOptions();
options.Type = RelationType.Authorize;
options.Peer = "abcxyz";
_remote.RequestAccountRelations(options).Submit(r =>
{
response = r;
deferred.Start();
});
Assert.IsTrue(deferred.Wait(DeferredWaitingTime));
Assert.IsNotNull(response);
Assert.IsInstanceOfType(response.Exception, typeof(InvalidAddressException));
var ex = response.Exception as InvalidAddressException;
Assert.AreEqual("Peer", ex.Name);
}
public static Task GetBalance(Remote remote, Options options, MessageCallback <Response> callback = null)
{
Func <Exception, Task> onException = (ex =>
{
callback(new MessageResult <Response>(null, ex));
return(Task.FromResult(0));
});
if (remote == null || !remote.IsConnected)
{
return(onException(new ArgumentException("Remote is disconnected.")));
}
if (options == null)
{
return(onException(new ArgumentNullException("options")));
}
if (!Utils.IsValidAddress(options.Account))
{
return(onException(new Exception("Invalid account address.")));
}
var condition = new Amount();
if (options.Currency != null)
{
if (!Utils.IsValidCurrency(options.Currency))
{
return(onException(new Exception("Invalid currency.")));
}
condition.Currency = options.Currency;
}
if (options.Issuer != null)
{
if (!Utils.IsValidAddress(options.Issuer))
{
return(onException(new Exception("Invalid issuer address.")));
}
condition.Issuer = options.Issuer;
}
var results = new Results();
var opt1 = new AccountInfoOptions();
opt1.Account = options.Account;
var t1 = remote.RequestAccountInfo(opt1).SubmitAsync(r1 =>
{
if (r1.Exception != null)
{
results.Exception = r1.Exception;
}
results.Native = r1.Result;
});
var opt2 = new AccountRelationsOptions();
opt2.Account = options.Account;
opt2.Type = RelationType.Trust;
var t2 = remote.RequestAccountRelations(opt2).SubmitAsync(r2 =>
{
if (r2.Exception != null)
{
results.Exception = r2.Exception;
}
results.Lines = r2.Result;
});
var opt3 = new AccountRelationsOptions();
opt3.Account = options.Account;
opt3.Type = RelationType.Freeze;
var t3 = remote.RequestAccountRelations(opt3).SubmitAsync(r3 =>
{
if (r3.Exception != null)
{
results.Exception = r3.Exception;
}
results.Lines2 = r3.Result;
});
var opt4 = new AccountOffersOptions();
opt4.Account = options.Account;
Func <Task> getOffers = null;
getOffers = () =>
{
var t4 = remote.RequestAccountOffers(opt4).SubmitAsync(r4 =>
{
if (r4.Exception != null)
{
results.Exception = r4.Exception;
}
else
{
if (r4.Result.Offers != null)
{
results.Offers = r4.Result.Offers.Concat(results.Offers ?? new Offer[0]).ToArray();
}
if (r4.Result.Marker != null)
{
opt4.Marker = r4.Result.Marker;
var childTask = getOffers();
childTask.Wait();
}
}
});
return(t4);
};
var t5 = getOffers();
var task = new Task(() =>
{
if (!Task.WaitAll(new Task[] { t1, t2, t3, t5 }, Global.Timeout))
{
onException(new Exception("Time out."));
return;
}
if (results.Exception != null)
{
onException(results.Exception);
return;
}
var balances = ProcessBalance(results, condition);
var response = new Response {
Balances = balances, Sequence = results.Native.AccountData.Sequence
};
callback(new MessageResult <Response>(null, null, response));
return;
});
task.Start();
return(task);
}
