Making tests for custm functions

[dweezymonae]

Hey, i want to know how my smart contracts methods will function when simulated an x couple of time, like the average transaction fee, change in gasPrice etc, but i do not really know how to implement it correctly, here is the smart contract`// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

/** Smart contract to list products */
contract Listing {
struct Item {
address seller;
string name;
string description;
uint256 price;
bool isAvailable;
}

// Mapping items to unique identifiers
mapping(uint256 => Item) public items;

// Counter to generate unique id
uint256 public itemIdCounter;

// Event emitted when a new product is listed
event ItemListed(
    uint256 itemId,
    address indexed seller,
    string name,
    uint256 price
);

// Event emitted when item is deleted
event ItemDeleted(uint256 itemId, address indexed seller);

// Modifier to ensure only the seller can perform certain actions
modifier onlySeller(uint256 itemId) {
    require(msg.sender == items[itemId].seller, "You are not the seller");
    _;
}

// Function to list a new item
function listNewItem(
    string memory itemName,
    string memory itemDescription,
    uint256 price
) external {
    require(price > 0, "Price must be greater than 0");

    // Increment item id counter to generate a unique id for the new item
    itemIdCounter++;

    // Create a new item and store it in the mapping
    items[itemIdCounter] = Item({
        seller: msg.sender,
        name: itemName,
        description: itemDescription,
        price: price,
        isAvailable: true
    });

    // Emit an event to notify a new item has been listed
    emit ItemListed(itemIdCounter, msg.sender, itemName, price);
}

// Function to get details of a listed item
function getItemDetails(
    uint256 itemId
) external view returns (Item memory) {
    return items[itemId];
}

// Function to purchase a listed item
function purchaseItem(uint256 itemId) external payable {
    // Check item availability
    require(items[itemId].isAvailable, "Item is not available");

    // Check if the sent value matches the item's price
    require(
        msg.value == items[itemId].price,
        "Incorrect payment amount for item"
    );

    // Transfer funds to the seller
    payable(items[itemId].seller).transfer(msg.value);

    // Mark the item as sold
    items[itemId].isAvailable = false;
}

// Function to update details of a listed item
function updateItemDetails(
    uint256 itemId,
    string memory newItemName,
    string memory newItemDescription,
    uint256 newPrice
) external onlySeller(itemId) {
    require(newPrice > 0, "Price must be greater than zero");

    // Update details of the item
    items[itemId].name = newItemName;
    items[itemId].description = newItemDescription;
    items[itemId].price = newPrice;
}

// Function to delete a listed item
function deleteItem(uint256 itemId) external onlySeller(itemId) {
    // Mark the item as no longer available
    items[itemId].isAvailable = false;

    // Emit an event to notify deletion
    emit ItemDeleted(itemId, msg.sender);
}

}
` thank you in advance

[eum602]

Hi @dweezymonae , a couple of points before answering:

• This repo doesn't measure the transaction fee, gasPrice changes, etc
• This repo actually measures the sustained response of transactions given a certain rate of incoming transaction requests.

Having said that, it may really depend on what you want to achieve with your contract. Actually if you deploy it in some mainnet the conditions of gas price and thus transaction fees will depend not only of how much transactions your contract is receiving but in general it will depend on the whole network demand. Actually what you could do in that regard is to estimate the maximums, minimums and average values for your transaction given the historic gas prices and even more if you want to simulate the cost in dollars also play with the different values of the native cryptocurrency in dollars (eth, avax, ftm, etc).

Hope this helps.