update

test/test.ts

@@ -1,41 +1,138 @@
-import { expect, tap } from '@pushrocks/tapbundle';
-import { Qenv } from '@pushrocks/qenv';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import { Qenv } from '@push.rocks/qenv';
 
 const testQenv = new Qenv('./', './.nogit/');
 
 import * as bunq from '../ts';
 
 let testBunqAccount: bunq.BunqAccount;
-const testBunqOptions: bunq.IBunqConstructorOptions = {
-  apiKey: testQenv.getEnvVarOnDemand('BUNQ_APIKEY'),
-  deviceName: 'mojoiobunqpackage',
-  environment: 'SANDBOX',
-};
+let sandboxApiKey: string;
+
+tap.test('should create a sandbox API key when needed', async () => {
+  // Check if we have an API key from environment
+  const envApiKey = await testQenv.getEnvVarOnDemand('BUNQ_APIKEY');
+  
+  if (!envApiKey) {
+    // Create a temporary bunq account to generate sandbox API key
+    const tempAccount = new bunq.BunqAccount({
+      apiKey: '',
+      deviceName: 'bunq-test-generator',
+      environment: 'SANDBOX',
+    });
+    
+    sandboxApiKey = await tempAccount.createSandboxUser();
+    console.log('Generated new sandbox API key');
+  } else {
+    sandboxApiKey = envApiKey;
+    console.log('Using existing API key from environment');
+  }
+  
+  expect(sandboxApiKey).toBeTypeofString();
+  expect(sandboxApiKey.length).toBeGreaterThan(0);
+});
 
 tap.test('should create a valid bunq account', async () => {
-  testBunqAccount = new bunq.BunqAccount(testBunqOptions);
-  expect(testBunqAccount).to.be.instanceOf(bunq.BunqAccount);
+  testBunqAccount = new bunq.BunqAccount({
+    apiKey: sandboxApiKey,
+    deviceName: 'bunq-api-test',
+    environment: 'SANDBOX',
+  });
+  expect(testBunqAccount).toBeInstanceOf(bunq.BunqAccount);
 });
 
 tap.test('should init the client', async () => {
   await testBunqAccount.init();
+  expect(testBunqAccount.userId).toBeTypeofNumber();
+  expect(testBunqAccount.userType).toBeOneOf(['UserPerson', 'UserCompany', 'UserApiKey']);
+  console.log(`Initialized as ${testBunqAccount.userType} with ID ${testBunqAccount.userId}`);
 });
 
 tap.test('should get accounts', async () => {
   const accounts = await testBunqAccount.getAccounts();
-  console.log(accounts);
+  expect(accounts).toBeArray();
+  expect(accounts.length).toBeGreaterThan(0);
+  
+  console.log(`Found ${accounts.length} accounts:`);
+  for (const account of accounts) {
+    console.log(`- ${account.description}: ${account.balance.currency} ${account.balance.value}`);
+    expect(account).toBeInstanceOf(bunq.BunqMonetaryAccount);
+    expect(account.id).toBeTypeofNumber();
+    expect(account.balance).toHaveProperty('value');
+    expect(account.balance).toHaveProperty('currency');
+  }
 });
 
 tap.test('should get transactions', async () => {
   const accounts = await testBunqAccount.getAccounts();
-  for (const account of accounts) {
-    const transactions = await account.getTransactions();
-    console.log(transactions);
+  const account = accounts[0];
+  
+  const transactions = await account.getTransactions();
+  expect(transactions).toBeArray();
+  
+  console.log(`Found ${transactions.length} transactions`);
+  if (transactions.length > 0) {
+    const firstTransaction = transactions[0];
+    expect(firstTransaction).toBeInstanceOf(bunq.BunqTransaction);
+    expect(firstTransaction.amount).toHaveProperty('value');
+    expect(firstTransaction.amount).toHaveProperty('currency');
+    
+    console.log(`Latest transaction: ${firstTransaction.amount.value} ${firstTransaction.amount.currency} - ${firstTransaction.description}`);
+  }
+});
+
+tap.test('should test payment builder', async () => {
+  const accounts = await testBunqAccount.getAccounts();
+  const account = accounts[0];
+  
+  // Test payment builder without actually creating the payment
+  const paymentBuilder = bunq.BunqPayment.builder(testBunqAccount, account)
+    .amount('10.00', 'EUR')
+    .toIban('NL91ABNA0417164300', 'Test Recipient')
+    .description('Test payment');
+  
+  expect(paymentBuilder).toBeDefined();
+  console.log('Payment builder created successfully');
+});
+
+tap.test('should test user management', async () => {
+  const user = testBunqAccount.getUser();
+  expect(user).toBeInstanceOf(bunq.BunqUser);
+  
+  const userInfo = await user.getInfo();
+  expect(userInfo).toBeDefined();
+  console.log(`User type: ${Object.keys(userInfo)[0]}`);
+});
+
+tap.test('should test notification filters', async () => {
+  const notification = new bunq.BunqNotification(testBunqAccount);
+  
+  const urlFilters = await notification.listUrlFilters();
+  expect(urlFilters).toBeArray();
+  console.log(`Currently ${urlFilters.length} URL notification filters`);
+  
+  const pushFilters = await notification.listPushFilters();
+  expect(pushFilters).toBeArray();
+  console.log(`Currently ${pushFilters.length} push notification filters`);
+});
+
+tap.test('should test card listing', async () => {
+  try {
+    const cards = await bunq.BunqCard.list(testBunqAccount);
+    expect(cards).toBeArray();
+    console.log(`Found ${cards.length} cards`);
+    
+    for (const card of cards) {
+      expect(card).toBeInstanceOf(bunq.BunqCard);
+      console.log(`Card: ${card.nameOnCard} - ${card.type} (${card.status})`);
+    }
+  } catch (error) {
+    console.log('No cards found (normal for new sandbox accounts)');
   }
 });
 
 tap.test('should stop the instance', async () => {
   await testBunqAccount.stop();
+  console.log('bunq client stopped successfully');
 });
 
 tap.start();