public void Execute()
{
var shopState = _initialState.GetShopState();
Assert.Empty(shopState.Products);
var avatarState = _initialState.GetAvatarState(_avatarAddress);
Assert.Single(avatarState.inventory.Equipments);
var equipment = avatarState.inventory.Equipments.FirstOrDefault();
Assert.NotNull(equipment);
var currencyState = _initialState.GetGoldCurrency();
var price = new FungibleAssetValue(currencyState, 100, 0);
var sellAction = new Sell
{
itemId = equipment.ItemId,
price = price,
sellerAvatarAddress = _avatarAddress,
};
var nextState = sellAction.Execute(new ActionContext
{
BlockIndex = 0,
PreviousStates = _initialState,
Rehearsal = false,
Signer = _agentAddress,
Random = new ItemEnhancementTest.TestRandom(),
});
var nextAvatarState = nextState.GetAvatarState(_avatarAddress);
Assert.Empty(nextAvatarState.inventory.Equipments);
var nextShopState = nextState.GetShopState();
Assert.Single(nextShopState.Products);
var(_, shopItem) = nextShopState.Products.FirstOrDefault();
Assert.NotNull(shopItem);
Assert.Equal(equipment.ItemId, shopItem.ItemUsable.ItemId);
Assert.Equal(price, shopItem.Price);
Assert.Equal(_agentAddress, shopItem.SellerAgentAddress);
Assert.Equal(_avatarAddress, shopItem.SellerAvatarAddress);
}
public void Execute(
ItemType itemType,
int itemCount,
bool backward
)
{
var avatarState = _initialState.GetAvatarState(_avatarAddress);
ITradableItem tradableItem;
switch (itemType)
{
case ItemType.Consumable:
tradableItem = ItemFactory.CreateItemUsable(
_tableSheets.ConsumableItemSheet.First,
Guid.NewGuid(),
0);
break;
case ItemType.Costume:
tradableItem = ItemFactory.CreateCostume(
_tableSheets.CostumeItemSheet.First,
Guid.NewGuid());
break;
case ItemType.Equipment:
tradableItem = ItemFactory.CreateItemUsable(
_tableSheets.EquipmentItemSheet.First,
Guid.NewGuid(),
0);
break;
case ItemType.Material:
var tradableMaterialRow = _tableSheets.MaterialItemSheet.OrderedList
.First(row => row.ItemSubType == ItemSubType.Hourglass);
tradableItem = ItemFactory.CreateTradableMaterial(tradableMaterialRow);
break;
default:
throw new ArgumentOutOfRangeException(nameof(itemType), itemType, null);
}
Assert.Equal(0, tradableItem.RequiredBlockIndex);
avatarState.inventory.AddItem((ItemBase)tradableItem, itemCount);
var previousStates = _initialState;
if (backward)
{
previousStates = previousStates.SetState(_avatarAddress, avatarState.Serialize());
}
else
{
previousStates = previousStates
.SetState(_avatarAddress.Derive(LegacyInventoryKey), avatarState.inventory.Serialize())
.SetState(_avatarAddress.Derive(LegacyWorldInformationKey), avatarState.worldInformation.Serialize())
.SetState(_avatarAddress.Derive(LegacyQuestListKey), avatarState.questList.Serialize())
.SetState(_avatarAddress, avatarState.SerializeV2());
}
var currencyState = previousStates.GetGoldCurrency();
var price = new FungibleAssetValue(currencyState, ProductPrice, 0);
var orderId = new Guid("6f460c1a755d48e4ad6765d5f519dbc8");
var orderAddress = Order.DeriveAddress(orderId);
var shardedShopAddress = ShardedShopStateV2.DeriveAddress(
tradableItem.ItemSubType,
orderId);
long blockIndex = 1;
Assert.Null(previousStates.GetState(shardedShopAddress));
var sellAction = new Sell
{
sellerAvatarAddress = _avatarAddress,
tradableId = tradableItem.TradableId,
count = itemCount,
price = price,
itemSubType = tradableItem.ItemSubType,
orderId = orderId,
};
var nextState = sellAction.Execute(new ActionContext
{
BlockIndex = blockIndex,
PreviousStates = previousStates,
Rehearsal = false,
Signer = _agentAddress,
Random = new TestRandom(),
});
long expiredBlockIndex = Order.ExpirationInterval + blockIndex;
// Check AvatarState and Inventory
var nextAvatarState = nextState.GetAvatarStateV2(_avatarAddress);
Assert.Single(nextAvatarState.inventory.Items);
Assert.True(nextAvatarState.inventory.TryGetLockedItem(new OrderLock(orderId), out var inventoryItem));
Assert.False(nextAvatarState.inventory.TryGetTradableItems(tradableItem.TradableId, blockIndex, itemCount, out _));
Assert.False(nextAvatarState.inventory.TryGetTradableItems(tradableItem.TradableId, expiredBlockIndex, itemCount, out _));
ITradableItem nextTradableItem = (ITradableItem)inventoryItem.item;
Assert.Equal(expiredBlockIndex, nextTradableItem.RequiredBlockIndex);
// Check ShardedShopState
var nextSerializedShardedShopState = nextState.GetState(shardedShopAddress);
Assert.NotNull(nextSerializedShardedShopState);
var nextShardedShopState =
new ShardedShopStateV2((Dictionary)nextSerializedShardedShopState);
Assert.Single(nextShardedShopState.OrderDigestList);
var orderDigest = nextShardedShopState.OrderDigestList.First(o => o.OrderId.Equals(orderId));
Assert.Equal(price, orderDigest.Price);
Assert.Equal(blockIndex, orderDigest.StartedBlockIndex);
Assert.Equal(expiredBlockIndex, orderDigest.ExpiredBlockIndex);
Assert.Equal(((ItemBase)tradableItem).Id, orderDigest.ItemId);
Assert.Equal(tradableItem.TradableId, orderDigest.TradableId);
var serializedOrder = nextState.GetState(orderAddress);
Assert.NotNull(serializedOrder);
var serializedItem = nextState.GetState(Addresses.GetItemAddress(tradableItem.TradableId));
Assert.NotNull(serializedItem);
var order = OrderFactory.Deserialize((Dictionary)serializedOrder);
ITradableItem orderItem = (ITradableItem)ItemFactory.Deserialize((Dictionary)serializedItem);
Assert.Equal(price, order.Price);
Assert.Equal(orderId, order.OrderId);
Assert.Equal(tradableItem.TradableId, order.TradableId);
Assert.Equal(blockIndex, order.StartedBlockIndex);
Assert.Equal(expiredBlockIndex, order.ExpiredBlockIndex);
Assert.Equal(_agentAddress, order.SellerAgentAddress);
Assert.Equal(_avatarAddress, order.SellerAvatarAddress);
Assert.Equal(expiredBlockIndex, orderItem.RequiredBlockIndex);
var receiptDict = nextState.GetState(OrderDigestListState.DeriveAddress(_avatarAddress));
Assert.NotNull(receiptDict);
var orderDigestList = new OrderDigestListState((Dictionary)receiptDict);
Assert.Single(orderDigestList.OrderDigestList);
OrderDigest orderDigest2 = orderDigestList.OrderDigestList.First();
Assert.Equal(orderDigest, orderDigest2);
}
public void Execute(ItemType itemType, bool shopItemExist, int blockIndex)
{
var shopState = _initialState.GetShopState();
Assert.Empty(shopState.Products);
var avatarState = _initialState.GetAvatarState(_avatarAddress);
List <Inventory.Item> inventoryItem = avatarState.inventory.Items.Where(i => i.item.ItemType == itemType).ToList();
Assert.Single(inventoryItem);
var previousStates = _initialState;
var currencyState = previousStates.GetGoldCurrency();
var price = new FungibleAssetValue(currencyState, ProductPrice, 0);
INonFungibleItem nonFungibleItem = (INonFungibleItem)inventoryItem.First().item;
nonFungibleItem.Update(blockIndex);
Assert.Equal(blockIndex, nonFungibleItem.RequiredBlockIndex);
if (shopItemExist)
{
var si = new ShopItem(
_agentAddress,
_avatarAddress,
Guid.NewGuid(),
new FungibleAssetValue(currencyState, 100, 0),
blockIndex,
nonFungibleItem);
shopState.Register(si);
previousStates = previousStates.SetState(Addresses.Shop, shopState.Serialize());
Assert.Single(shopState.Products);
}
else
{
Assert.Empty(shopState.Products);
}
var sellAction = new Sell
{
itemId = nonFungibleItem.ItemId,
price = price,
sellerAvatarAddress = _avatarAddress,
};
var nextState = sellAction.Execute(new ActionContext
{
BlockIndex = 1,
PreviousStates = previousStates,
Rehearsal = false,
Signer = _agentAddress,
Random = new TestRandom(),
});
const long expiredBlockIndex = Sell.ExpiredBlockIndex + 1;
var nextAvatarState = nextState.GetAvatarState(_avatarAddress);
Assert.True(nextAvatarState.inventory.TryGetNonFungibleItem(nonFungibleItem.ItemId, out var nextItem));
INonFungibleItem nextNonFungibleItem = (INonFungibleItem)nextItem.item;
Assert.Equal(expiredBlockIndex, nextNonFungibleItem.RequiredBlockIndex);
var nextShopState = nextState.GetShopState();
Assert.Single(nextShopState.Products);
var products = nextShopState.Products.Values;
var shopItem = products.First();
INonFungibleItem item = itemType == ItemType.Costume ? (INonFungibleItem)shopItem.Costume : shopItem.ItemUsable;
Assert.Equal(price, shopItem.Price);
Assert.Equal(expiredBlockIndex, shopItem.ExpiredBlockIndex);
Assert.Equal(expiredBlockIndex, item.RequiredBlockIndex);
Assert.Equal(_agentAddress, shopItem.SellerAgentAddress);
Assert.Equal(_avatarAddress, shopItem.SellerAvatarAddress);
var mailList = nextAvatarState.mailBox.Where(m => m is SellCancelMail).ToList();
Assert.Single(mailList);
Assert.Equal(expiredBlockIndex, mailList.First().requiredBlockIndex);
}
