tests for NftCollection class

.gitignore

@@ -2,3 +2,4 @@ node_modules
 temp
 build
 
+.env

package.json

@@ -20,5 +20,8 @@
  "ts-jest": "^29.1.2",
  "ts-node": "^10.9.2",
  "typescript": "^5.3.3"
+ },
+ "dependencies": {
+ "dotenv": "^16.4.5"
  }
 }

scripts/deployNftCollection.ts

@@ -2,6 +2,8 @@ import { Address, toNano } from '@ton/core';
 import { NftCollection } from '../wrappers/NftCollection';
 import { compile, NetworkProvider } from '@ton/blueprint';
 import { buildCollectionContentCell, setItemContentCell } from './nftContent/onChain';
+import * as dotenv from 'dotenv';
+dotenv.config();
 
 const randomSeed= Math.floor(Math.random() * 10000);
 
@@ -11,21 +13,20 @@ export async function run(provider: NetworkProvider) {
  ownerAddress: provider.sender().address!!, 
  nextItemIndex: 0,
  collectionContent: buildCollectionContentCell({
- name: "OnChain collection",
- description: "Collection of items with onChain metadata",
- image: "https://raw.githubusercontent.com/Cosmodude/Nexton/main/Nexton_Logo.jpg"
+ name: process.env.COLLECTION_NAME!,
+ description: process.env.COLLECTION_DESCRIPTION!,
+ image: process.env.COLLECTION_IMAGE!
  }),
  nftItemCode: await compile("NftItem"),
  royaltyParams: {
- royaltyFactor: Math.floor(Math.random() * 500), 
- royaltyBase: 1000,
+ royaltyFactor: parseInt(process.env.COLLECTION_ROYALTY_PERCENT!), 
+ royaltyBase: 100,
  royaltyAddress: provider.sender().address as Address
  }
  }, await compile('NftCollection')));
 
  console.log(provider.sender().address as Address)
  await nftCollection.sendDeploy(provider.sender(), toNano('0.05'));
- console.log()
  await provider.waitForDeploy(nftCollection.address);
 
  const mint = await nftCollection.sendMintNft(provider.sender(),{

tests/NftCollection.spec.ts

@@ -1,23 +1,53 @@
-import { Blockchain, SandboxContract } from '@ton/sandbox';
-import { Cell, toNano } from '@ton/core';
+import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox';
+import { Address, Cell, toNano } from '@ton/core';
 import { NftCollection } from '../wrappers/NftCollection';
+import { buildCollectionContentCell, setItemContentCell } from '../scripts/nftContent/onChain';
 import '@ton/test-utils';
 import { compile } from '@ton/blueprint';
+import { flattenTransaction } from '@ton/test-utils';
+import * as dotenv from 'dotenv';
+dotenv.config();
 
 describe('NftCollection', () => {
- let code: Cell;
+ let collectionCode: Cell;
+ let item: Cell;
+ let collectionContent: Cell;
+ let nftItemContent: Cell;
 
  beforeAll(async () => {
- code = await compile('NftCollection');
+ collectionCode = await compile('NftCollection');
+ item = await compile('NftItem');
  });
 
  let blockchain: Blockchain;
  let nftCollection: SandboxContract<NftCollection>;
+ let collectionOwner: SandboxContract<TreasuryContract>;
 
  beforeEach(async () => {
  blockchain = await Blockchain.create();
+ collectionOwner = await blockchain.treasury("ownerWallet");
+ collectionContent = buildCollectionContentCell({
+ name: process.env.COLLECTION_NAME!,
+ description: process.env.COLLECTION_DESCRIPTION!,
+ image: process.env.COLLECTION_IMAGE!
+ });
+ nftItemContent = setItemContentCell({
+ name: "OnChain",
+ description: "Holds onchain metadata",
+ image: "https://raw.githubusercontent.com/Cosmodude/Nexton/main/Nexton_Logo.jpg",
+ });
 
- nftCollection = blockchain.openContract(NftCollection.createFromConfig({}, code));
+ nftCollection = blockchain.openContract(NftCollection.createFromConfig({
+ ownerAddress: collectionOwner.address,
+ nextItemIndex: 0,
+ collectionContent: collectionContent,
+ nftItemCode: item,
+ royaltyParams: {
+ royaltyFactor: parseInt(process.env.COLLECTION_ROYALTY_PERCENT!), //Math.floor(Math.random() * 500), 
+ royaltyBase: 100, //1000,
+ royaltyAddress: collectionOwner.getSender().address as Address
+ }
+ },collectionCode));
 
  const deployer = await blockchain.treasury('deployer');
 
@@ -31,8 +61,77 @@ describe('NftCollection', () => {
  });
  });
 
- it('should deploy', async () => {
- // the check is done inside beforeEach
- // blockchain and nftCollection are ready to use
+ it('should get collection data after collection has been deployed', async () => {
+ const collection_data = await nftCollection.getCollectionData();
+ // check next_item_index
+ expect(collection_data).toHaveProperty("nextItemId", BigInt(0));
+ // check collection content 
+ expect(collection_data.collectionContent).toEqualCell(collectionContent);
+ // check owner address 
+ expect(collection_data.ownerAddress.toString()).toBe(collectionOwner.address.toString());
+ });
+
+ it('should get roylty params after collection has been deployed', async () => {
+ const royalty_params = await nftCollection.getRoyaltyParams();
+ expect(royalty_params.royaltyFactor).toBe(BigInt(parseInt(process.env.COLLECTION_ROYALTY_PERCENT!)));
+ expect(royalty_params.royaltyBase).toBe(BigInt(100));
+ expect(royalty_params.royaltyAddress.toString()).toBe(collectionOwner.address.toString());
+ });
+
+ it ('should mint NFT item if requested by collection owner', async () => {
+
+ const nftOwner = await blockchain.treasury('NewNFTOwner');
+ const mintResult = await nftCollection.sendMintNft(collectionOwner.getSender(), {
+ value: toNano("0.02"),
+ queryId: Math.floor(Math.random() * 10000),
+ amount: toNano("0.014"),
+ itemIndex: 0,
+ itemOwnerAddress: nftOwner.getSender().address!!,
+ itemContent: nftItemContent
+ });
+ // const arr = mintResult.transactions.map(tx => flattenTransaction(tx));
+ // console.log(arr);
+ // check that tx to the collection address is successful
+ expect(mintResult.transactions).toHaveTransaction({
+ to: nftCollection.address,
+ op: 1,
+ value: toNano("0.02"),
+ success: true
+ })
+ // check that getItemAddressByIndex() returns nft item address
+ const nftItemAddr = await nftCollection.getItemAddressByIndex({ type: 'int', value: BigInt(0) }); 
+ // check that tx to the nft item address is successful
+ expect(mintResult.transactions).toHaveTransaction({
+ from: nftCollection.address,
+ to: nftItemAddr,
+ value: toNano("0.014"),
+ success: true
+ })
+ // check that next item index has been incremented 
+ const collection_data = await nftCollection.getCollectionData();
+ expect(collection_data.nextItemId).toBe(BigInt(1));
  });
+
+ it ('should return 401 error if mint item was requested by non-owner', async () => {
+ const nonOwnerWallet = await blockchain.treasury("non-owner");
+ const nftOwner = await blockchain.treasury('NewNFTOwner');
+
+ const result = await nftCollection.sendMintNft(nonOwnerWallet.getSender(), {
+ value: toNano("0.02"),
+ queryId: Math.floor(Math.random() * 10000),
+ amount: toNano("0.014"),
+ itemIndex: 0,
+ itemOwnerAddress: nftOwner.getSender().address!!,
+ itemContent: nftItemContent
+ });
+ // check that tx failed with 401 exit code
+ expect(result.transactions).toHaveTransaction({
+ to: nftCollection.address,
+ value: toNano("0.02"),
+ exitCode: 401,
+ op: 1,
+ success: false
+ });
+ })
+
 });

wrappers/NftCollection.ts

@@ -105,7 +105,7 @@ export class NftCollection implements Contract {
  .endCell()
  })
  }
-
+ // GETTERS
  async getCollectionData(provider: ContractProvider): Promise<{
  nextItemId: bigint, 
  ownerAddress: Address, 
@@ -130,4 +130,16 @@ export class NftCollection implements Contract {
  return itemAddress;
  }
 
+ async getRoyaltyParams(provider: ContractProvider) {
+ const royaltyParams = await provider.get("royalty_params", []);
+ const stack = royaltyParams.stack;
+ let numerator: bigint = stack.readBigNumber();
+ let denominator: bigint = stack.readBigNumber();
+ let destination: Address = stack.readAddress();
+ return {
+ royaltyFactor: numerator,
+ royaltyBase: denominator,
+ royaltyAddress: destination,
+ }
+ }
 }