public async Task ShouldFailSubNamespaceExists()
{
var signer =
KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var transaction = RegisterNamespaceTransaction.CreateSubNamespace(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
"happy",
"yooo")
.SignWith(signer);
listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST))
.Subscribe(
e =>
{
Assert.Fail("Success");
});
await new TransactionHttp(host).Announce(transaction);
var status = await listener.TransactionStatus(Address.CreateFromPublicKey(signer.PublicKeyString, NetworkType.Types.MIJIN_TEST)).Where(e => e.Hash == transaction.Hash).Take(1);
Assert.AreEqual("Failure_Namespace_Already_Exists", status.Status);
}
private async Task <NamespaceInfo> GenerateNamespace(Account account, string namespaceName, NamespaceId parentId)
{
RegisterNamespaceTransaction registerNamespaceTransaction;
if (parentId == null)
{
registerNamespaceTransaction = RegisterNamespaceTransaction.CreateRootNamespace(
Deadline.Create(),
namespaceName,
100,
Fixture.NetworkType
);
}
else
{
registerNamespaceTransaction = RegisterNamespaceTransaction.CreateSubNamespace(
Deadline.Create(),
namespaceName,
parentId,
Fixture.NetworkType
);
}
var signedTransaction = account.Sign(registerNamespaceTransaction, Fixture.GenerationHash);
var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
Log.WriteLine(
$"Registered namespace {namespaceName} for account {account.Address.Plain} with transaction {signedTransaction.Hash}");
var result = await tx;
Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}");
var expectedId = parentId != null?NamespaceId.CreateFromParent(namespaceName, parentId) : new NamespaceId(namespaceName);
var namespaceInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(expectedId);
Log.WriteLine(
$"Retrieved namespace {namespaceName} successfully. The namespace HexId {namespaceInfo.Id.HexId}");
return(namespaceInfo);
}
public async Task Should_Create_Aggregate_Root_And_SubNamespace()
{
var bobAccount = await Fixture.GenerateAccountWithCurrency(500);
var rootNs = "nsp" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 6);
var subNs = "subnp" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 6);
var rootId = new NamespaceId(rootNs);
var childId = new NamespaceId(rootNs + "." + subNs);
Log.WriteLine($"Going to create aggregate root {rootId} and child namespace {childId}");
var registerRootTransaction = RegisterNamespaceTransaction.CreateRootNamespace(
Deadline.Create(),
rootNs,
100,
Fixture.NetworkType
);
var registerChildTransaction = RegisterNamespaceTransaction.CreateSubNamespace(
Deadline.Create(),
subNs,
rootId,
Fixture.NetworkType
);
var aggregateTransaction = AggregateTransaction.CreateComplete(
Deadline.Create(),
new List <Transaction>
{
registerRootTransaction.ToAggregate(bobAccount.PublicAccount),
registerChildTransaction.ToAggregate(bobAccount.PublicAccount)
}, Fixture.NetworkType);
var signedTransaction = bobAccount.Sign(aggregateTransaction, Fixture.GenerationHash);
Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}");
var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(bobAccount.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}");
result.TransactionType.Should().BeEquivalentTo(EntityType.AGGREGATE_COMPLETE);
/*
* var rootNsInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(rootId).Timeout(_fixture.DefaultTimeout);
* rootNsInfo.Should().NotBeNull();
* rootNsInfo.IsRoot.Should().BeTrue();
*
* var subNsInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(childId).Timeout(_fixture.DefaultTimeout);
* subNsInfo.Should().NotBeNull();
* subNsInfo.IsSubNamespace.Should().BeTrue();
*/
//Verify the root namespace and sub namespace owned by the account
var nsInfos = await Fixture.SiriusClient.NamespaceHttp.GetNamespacesFromAccount(bobAccount.Address, null);
nsInfos.Should().HaveCount(2);
nsInfos.Single(ns => ns.Id.HexId == rootId.HexId).Should().NotBeNull();
nsInfos.Single(ns => ns.Id.HexId == childId.HexId).Should().NotBeNull();
//Verify the name of the namespaces
var nsNames = await Fixture.SiriusClient.NamespaceHttp.GetNamespacesNames(new List <NamespaceId>
{
rootId,
childId
});
nsNames.Should().HaveCount(2);
nsNames.Select(ns => ns.Name == rootId.Name).Should().NotBeNull();
nsNames.Select(ns => ns.Name == childId.Name).Should().NotBeNull();
}