test: add jest integration tests

Author: yugasun

.env.example

@@ -0,0 +1,22 @@
+# yugasun
+TENCENT_UIN=xxx
+TENCENT_APP_ID=xxx
+TENCENT_SECRET_ID=xxx
+TENCENT_SECRET_KEY=xxx
+
+# bucket for code
+BUCKET=serverless-test
+
+# domain for test
+DOMAIN=abc.com
+SUB_DOMAIN=test.abc.com
+
+# for pg
+REGION=ap-guangzhou
+ZONE=ap-guangzhou-2
+VPC_ID=vpc-xxx
+SUBNET_ID=subnet-xxx
+
+# VPC in ap-guangzhou-3 for cfs
+CFS_VPC_ID=vpc-xxx
+CFS_SUBNET_ID=subnet-xxx

.gitignore

@@ -17,6 +17,8 @@ dist
 .idea
 build
 .env*
+.env.test
+!.env.example
 env.js
 package-lock.json
-yarn.lock
+yarn.lock

README.md

@@ -34,6 +34,12 @@ support type：
 
 Most of time, we just use `feat` and `fix`.
 
+## Test
+
+For running integration tests we should setup some environment variables in `.env.test` locally or `secrets` in CI.
+
+Just copy `.env.example` to `.env.test`, then change to test account.
+
 ## License
 
 Copyright (c) 2019-present Tencent Cloud, Inc.

__tests__/apigw.test.js

@@ -0,0 +1,168 @@
+const { Apigw } = require('../src');
+
+describe('apigw', () => {
+  const credentials = {
+    SecretId: process.env.TENCENT_SECRET_ID,
+    SecretKey: process.env.TENCENT_SECRET_KEY,
+  };
+  const inputs = {
+    protocols: ['http', 'https'],
+    serviceName: 'serverless_test',
+    environment: 'release',
+    netTypes: ['OUTER'],
+    // customDomains: [
+    //   {
+    //     domain: 'test.yugasun.com',
+    //     // TODO: change to your certId
+    //     certificateId: 'cWOJJjax',
+    //     isDefaultMapping: false,
+    //     pathMappingSet: [
+    //       {
+    //         path: '/',
+    //         environment: 'release',
+    //       },
+    //     ],
+    //     protocols: ['http', 'https'],
+    //   },
+    // ],
+    endpoints: [
+      {
+        apiId: 'api-i84p7rla',
+        path: '/',
+        protocol: 'HTTP',
+        method: 'GET',
+        apiName: 'index',
+        function: {
+          functionName: 'egg-function',
+        },
+        usagePlan: {
+          usagePlanId: 'usagePlan-8bbr8pup',
+          usagePlanName: 'slscmp',
+          usagePlanDesc: 'sls create',
+          maxRequestNum: 1000,
+        },
+        auth: {
+          serviceTimeout: 15,
+          secretName: 'authName',
+          secretIds: ['xxx'],
+        },
+      },
+      {
+        path: '/mo',
+        protocol: 'HTTP',
+        method: 'GET',
+        apiName: 'mo',
+        serviceType: 'MOCK',
+        serviceMockReturnMessage: 'test mock response',
+      },
+      {
+        path: '/auto',
+        protocol: 'HTTP',
+        apiName: 'auto-http',
+        method: 'GET',
+        serviceType: 'HTTP',
+        serviceConfig: {
+          url: 'http://www.baidu.com',
+          path: '/test',
+          method: 'GET',
+        },
+      },
+      {
+        path: '/ws',
+        protocol: 'WEBSOCKET',
+        apiName: 'ws-test',
+        method: 'GET',
+        serviceType: 'WEBSOCKET',
+        serviceConfig: {
+          url: 'ws://yugasun.com',
+          path: '/',
+          method: 'GET',
+        },
+      },
+      {
+        path: '/wsf',
+        protocol: 'WEBSOCKET',
+        apiName: 'ws-scf',
+        method: 'GET',
+        serviceType: 'SCF',
+        function: {
+          functionNamespace: 'default',
+          functionQualifier: '$DEFAULT',
+          transportFunctionName: 'fullstack-api',
+          registerFunctionName: 'myRestAPI',
+        },
+      },
+    ],
+  };
+  const apigw = new Apigw(credentials, process.env.REGION);
+  let outputs;
+
+  test('should deploy a apigw success', async () => {
+    outputs = await apigw.deploy(inputs);
+    expect(outputs).toEqual({
+      created: true,
+      serviceId: expect.stringContaining('service-'),
+      serviceName: 'serverless_test',
+      subDomain: expect.stringContaining('.apigw.tencentcs.com'),
+      protocols: inputs.protocols,
+      environment: 'release',
+      apiList: [{
+        path: '/',
+        bindType: 'API',
+        internalDomain: null,
+        method: 'GET',
+        apiName: 'index',
+        apiId: expect.stringContaining('api-'),
+        created: true,
+        usagePlan:  {
+          created: true,
+          secrets:  {
+            'created': false,
+            'secretIds':  [],
+          },
+          usagePlanId: expect.stringContaining('usagePlan-'),
+        },
+      },{
+        path: '/mo',
+        method: 'GET',
+        apiName: 'mo',
+        internalDomain: null,
+        apiId: expect.stringContaining('api-'),
+        created: true,
+      },{
+        path: '/auto',
+        method: 'GET',
+        apiName: 'auto-http',
+        internalDomain: null,
+        apiId: expect.stringContaining('api-'),
+        created: true,
+      },{
+        path: '/ws',
+        method: 'GET',
+        apiName: 'ws-test',
+        internalDomain: null,
+        apiId: expect.stringContaining('api-'),
+        created: true,
+      },{
+        path: '/wsf',
+        method: 'GET',
+        apiName: 'ws-scf',
+        internalDomain: expect.stringContaining('http://set-websocket.cb-common.apigateway.tencentyun.com'),
+        apiId: expect.stringContaining('api-'),
+        created: true,
+      }],
+    });
+
+  });
+
+  test('should remove apigw success', async () => {
+    await apigw.remove(outputs);
+    const detail = await apigw.request({
+      Action: 'DescribeService',
+      ServiceId: outputs.serviceId,
+    });
+
+    expect(detail).toBeNull();
+  });
+});
+

__tests__/cam.test.js

@@ -0,0 +1,45 @@
+const { Cam } = require('../src');
+
+describe('Cam', () => {
+  const credentials = {
+    SecretId: process.env.TENCENT_SECRET_ID,
+    SecretKey: process.env.TENCENT_SECRET_KEY,
+  };
+  const roleName = 'role-test';
+  const policy = JSON.stringify({
+    version: '2.0',
+    statement: [
+      {
+        action: 'name/sts:AssumeRole',
+        effect: 'allow',
+        principal: {
+          service: ['cloudaudit.cloud.tencent.com', 'cls.cloud.tencent.com'],
+        },
+      },
+    ],
+  });
+  const cam = new Cam(credentials, process.env.REGION);
+
+  test('should create role success', async () => {
+    await cam.CreateRole(roleName, policy);
+    const { RoleInfo } = await cam.GetRole(roleName);
+    const exist = await cam.isRoleExist(roleName, {});
+    expect(RoleInfo.RoleName).toBe(roleName);
+    expect(exist).toBe(true);
+  });
+
+  test('should delete role success', async () => {
+    await cam.DeleteRole(roleName, {});
+    try {
+      await cam.GetRole(roleName);
+    } catch (e) {
+      expect(e.code).toBe('InvalidParameter.RoleNotExist');
+    }
+  });
+
+  test('SCFExcuteRole should exist', async () => {
+    const res = await cam.CheckSCFExcuteRole();
+    expect(res).toBe(true);
+  });
+});
+

__tests__/cdn.test.js

@@ -0,0 +1,47 @@
+const { Cdn } = require('../src');
+
+describe('Cdn', () => {
+  const credentials = {
+    SecretId: process.env.TENCENT_SECRET_ID,
+    SecretKey: process.env.TENCENT_SECRET_KEY,
+  };
+  const inputs = {
+    async: true,
+    area: 'overseas',
+    domain: 'test.yuga.chat',
+    hostType: 'cos',
+    origin: {
+      origins: ['up6pwd9-89hm718-xxx.cos-website.ap-guangzhou.myqcloud.com'],
+      originType: 'cos',
+      originPullProtocol: 'https',
+    },
+    serviceType: 'web',
+    https: {
+      switch: 'on',
+      http2: 'on',
+      certInfo: {
+        certId: 'cWOJJjax',
+      },
+    },
+    forceRedirect: {
+      switch: 'on',
+      redirectType: 'https',
+      redirectStatusCode: 301,
+    },
+  };
+  const cdn = new Cdn(credentials, process.env.REGION);
+
+  test('should deploy CDN success', async () => {
+    const res = await cdn.deploy(inputs);
+    expect(res).toEqual({
+      created: true,
+      https: true,
+      domain: inputs.domain,
+      origins: inputs.origin.origins,
+      cname: `${inputs.domain}.cdn.dnsv1.com`,
+      inputCache: JSON.stringify(inputs),
+      resourceId: expect.stringContaining('cdn-'),
+    });
+  });
+});
+

__tests__/cfs.test.js

@@ -0,0 +1,44 @@
+const { sleep } = require('@ygkit/request');
+const { Cfs } = require('../src');
+const apis = require('../src/modules/cfs/apis');
+
+describe('Cfs', () => {
+  const credentials = {
+    SecretId: process.env.TENCENT_SECRET_ID,
+    SecretKey: process.env.TENCENT_SECRET_KEY,
+  };
+  const inputs = {
+    fsName: 'cfs-test',
+    region: 'ap-guangzhou',
+    zone: 'ap-guangzhou-3',
+    netInterface: 'VPC',
+    vpc: {
+      vpcId: process.env.CFS_VPC_ID,
+      subnetId: process.env.CFS_SUBNET_ID,
+    },
+  };
+  const cfs = new Cfs(credentials, process.env.REGION);
+
+  test('should deploy CFS success', async () => {
+    const res = await cfs.deploy(inputs);
+    expect(res).toEqual({
+      region: process.env.REGION,
+      fsName: inputs.fsName,
+      pGroupId: 'pgroupbasic',
+      netInterface: 'VPC',
+      protocol: 'NFS',
+      storageType: 'SD',
+      fileSystemId: expect.stringContaining('cfs-'),
+    });
+    inputs.fileSystemId = res.fileSystemId;
+  });
+
+  test('should remove CFS success', async () => {
+    await sleep(1000);
+    const res = await cfs.remove(inputs);
+    const detail = await apis.getCfs(cfs.capi, inputs.fileSystemId);
+    expect(res).toEqual({});
+    expect(detail).toBeUndefined();
+  });
+});
+