fix(big fix upgrade): upgrade multiple areas of the core functionalities

test/helpers/cloudlyfactory.ts

@@ -21,3 +21,7 @@ export const createCloudly = async () => {
   return cloudlyInstance;
 }
 
+export const getEnvVarOnDemand = async (envVarName: string) => {
+  return testQenv.getEnvVarOnDemand(envVarName);
+} 
+

test/helpers/docker.ts

@@ -0,0 +1,9 @@
+import * as smartstream from '@push.rocks/smartstream';
+import * as smartpath from '@push.rocks/smartpath';
+
+export const getAlpineImageReadableStream = async () => {
+  const currentDir = smartpath.get.dirnameFromImportMetaUrl(import.meta.url);
+  const imagePath = smartpath.join(currentDir, '../../.nogit/testfiles/alpine.tar');
+  const readableStream = smartstream.nodewebhelpers.createWebReadableStreamFromFile(imagePath);
+  return readableStream;
+}

test/helpers/index.ts

@@ -1 +1,2 @@
 export * from './cloudlyfactory.js';
+export * from './docker.js';

test/test.apiclient.ts

@@ -1,30 +1,80 @@
 import { tap, expect } from '@push.rocks/tapbundle';
+import * as helpers from './helpers/index.js';
 
+import * as cloudly from '../ts/index.js';
 import * as cloudlyApiClient from '../ts_apiclient/index.js';
+import { Image } from '../ts_apiclient/classes.image.js';
 
+let testCloudly: cloudly.Cloudly;
 let testClient: cloudlyApiClient.CloudlyApiClient;
 
+tap.preTask('should start cloudly', async () => {
+  testCloudly = await helpers.createCloudly();
+  await testCloudly.start();
+});
+
+tap.preTask('should create a new machine user for testing', async () => {
+  const machineUser = new testCloudly.authManager.CUser();
+  machineUser.id = await testCloudly.authManager.CUser.getNewId();
+  machineUser.data = {
+    type: 'machine',
+    username: 'test',
+    password: 'test',
+    tokens: [{
+      token: 'test',
+      expiresAt: Date.now() + 3600 * 1000 * 24 * 365,
+      assignedRoles: ['admin'],
+    }],
+    role: 'admin',
+  };
+  await machineUser.save();
+});
+
 tap.test('should create a new cloudlyApiClient', async () => {
   testClient = new cloudlyApiClient.CloudlyApiClient({
     registerAs: 'api',
-    cloudlyUrl: 'http://localhost:3000',
+    cloudlyUrl: `http://localhost:${await helpers.getEnvVarOnDemand('SERVEZONE_PORT')}`,
   });
-  // await testClient.start();
+  await testClient.start();
   expect(testClient).toBeTruthy();
 });
 
-tap.test('should get an identity', async () => {
-  const identity = await testClient.getIdentityByJumpCode('test');
-  expect(identity).toBeTruthy();
-});
-
-tap.test('should trigger a server action', async () => {
-  
+tap.test('create a new machine user', async () => {
+  const machineUser = await testCloudly.authManager.CUser.createMachineUser('test', 'api');
+  machineUser.data.tokens.push({
+    token: 'test',
+    expiresAt: Date.now() + 3600 * 1000 * 24 * 365,
+    assignedRoles: ['api'],
+  })
+  await machineUser.save();
 })
 
+tap.test('should get an identity', async () => {
+  const identity = await testClient.getIdentityByToken('test');
+  expect(identity).toBeTruthy();
+  console.log(identity);
+});
+
+let image: Image;
+tap.test('should create and upload an image', async () => {
+  image = await testClient.images.createImage({
+    name: 'test',
+    description: 'test'
+  });
+  console.log('created image: ', image);
+  expect(image).toBeInstanceOf(Image);
+})
+
+tap.test('should upload an image version', async () => {
+  const imageStream = await helpers.getAlpineImageReadableStream();
+
+  await image.pushImageVersion('v1.0.0', imageStream);
+});
+
 tap.test('should stop the apiclient', async (toolsArg) => {
-  await toolsArg.delayFor(1000);
+  await toolsArg.delayFor(10000);
   await testClient.stop();
+  await testCloudly.stop();
 })
 
 export default tap.start();