t/plugin/lago.spec.mts - apisix - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 import { generateKeyPair } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { readFile, rm, writeFile } from 'node:fs/promises';
 import { promisify } from 'node:util';

 import { afterAll, beforeAll, describe, expect, it } from '@jest/globals';
 import axios from 'axios';
 import * as compose from 'docker-compose';
 import { gql, request } from 'graphql-request';
 import { Api as LagoApi, Client as LagoClient } from 'lago-javascript-client';
 import simpleGit from 'simple-git';
 import * as YAML from 'yaml';

 import { request as requestAdminAPI } from '../ts/admin_api';
 import { wait } from '../ts/utils';

 const LAGO_VERSION = 'v1.27.0';
 const LAGO_PATH = '/tmp/lago';
 const LAGO_FRONT_PORT = 59999;
 const LAGO_API_PORT = 30699;
 const LAGO_API_URL = `http://127.0.0.1:${LAGO_API_PORT}`;
 const LAGO_API_BASEURL = `http://127.0.0.1:${LAGO_API_PORT}/api/v1`;
 const LAGO_API_GRAPHQL_ENDPOINT = `${LAGO_API_URL}/graphql`;
 const LAGO_BILLABLE_METRIC_CODE = 'test';
 const LAGO_EXTERNAL_SUBSCRIPTION_ID = 'jack_test';

 // The project uses AGPLv3, so we can't store the docker compose file it uses in our repository and download it during testing.
 const downloadComposeFile = async () =>
   simpleGit().clone('https://github.com/getlago/lago', LAGO_PATH, {
     '--depth': '1',
     '--branch': LAGO_VERSION,
   });

 const launchLago = async () => {
   // patch docker-compose.yml to disable useless port
   const composeFilePath = `${LAGO_PATH}/docker-compose.yml`;
   const composeFile = YAML.parse(await readFile(composeFilePath, 'utf8'));
   delete composeFile.services.front; // front-end is not needed for tests
   delete composeFile.services['api-clock']; // clock is not needed for tests
   delete composeFile.services['api-worker']; // worker is not needed for tests
   delete composeFile.services['pdf']; // pdf is not needed for tests
   delete composeFile.services.redis.ports; // prevent port conflict
   delete composeFile.services.db.ports; // prevent port conflict
   await writeFile(composeFilePath, YAML.stringify(composeFile), 'utf8');

   // launch services
   const { privateKey } = await promisify(generateKeyPair)('rsa', {
     modulusLength: 2048,
     publicKeyEncoding: { type: 'pkcs1', format: 'pem' },
     privateKeyEncoding: { type: 'pkcs1', format: 'pem' },
   });
   const composeOpts: compose.IDockerComposeOptions = {
     cwd: LAGO_PATH,
     log: true,
     env: {
       LAGO_RSA_PRIVATE_KEY: Buffer.from(privateKey).toString('base64'),
       FRONT_PORT: `${LAGO_FRONT_PORT}`, // avoiding conflicts, tests do not require a front-end
       API_PORT: `${LAGO_API_PORT}`,
       LAGO_FRONT_URL: `http://127.0.0.1:${LAGO_FRONT_PORT}`,
       LAGO_API_URL,
     },
   };

   await compose.createAll(composeOpts);
   await compose.upOne('api', composeOpts);
   await compose.exec('api', 'rails db:create', composeOpts);
   await compose.exec('api', 'rails db:migrate', composeOpts);
   await compose.upAll(composeOpts);
 };

 const provisionLago = async () => {
   // sign up
   const { registerUser } = await request<{
     registerUser: { token: string; user: { organizations: { id: string }[] } };
   }>(
     LAGO_API_GRAPHQL_ENDPOINT,
     gql`
       mutation signup($input: RegisterUserInput!) {
         registerUser(input: $input) {
           token
           user {
             id
             organizations {
               id
             }
           }
         }
       }
     `,
     {
       input: {
         email: 'test@test.com',
         password: 'Admin000!',
         organizationName: 'test',
       },
     },
   );

   const webToken = registerUser.token;
   const organizationId = registerUser.user.organizations[0].id;
   const requestHeaders = {
     Authorization: `Bearer ${webToken}`,
     'X-Lago-Organization': organizationId,
   };

   // list api keys
   const { apiKeys } = await request<{
     apiKeys: { collection: { id: string }[] };
   }>(
     LAGO_API_GRAPHQL_ENDPOINT,
     gql`
       query getApiKeys {
         apiKeys(page: 1, limit: 20) {
           collection {
             id
           }
         }
       }
     `,
     {},
     requestHeaders,
   );

   // get first api key
   const { apiKey } = await request<{ apiKey: { value: string } }>(
     LAGO_API_GRAPHQL_ENDPOINT,
     gql`
       query getApiKeyValue($id: ID!) {
         apiKey(id: $id) {
           id
           value
         }
       }
     `,
     { id: apiKeys.collection[0].id },
     requestHeaders,
   );

   const lagoClient = LagoClient(apiKey.value, { baseUrl: LAGO_API_BASEURL });

   // create billable metric
   const { data: billableMetric } =
     await lagoClient.billableMetrics.createBillableMetric({
       billable_metric: {
         name: LAGO_BILLABLE_METRIC_CODE,
         code: LAGO_BILLABLE_METRIC_CODE,
         aggregation_type: 'count_agg',
         filters: [
           {
             key: 'tier',
             values: ['normal', 'expensive'],
           },
         ],
       },
     });

   // create plan
   const { data: plan } = await lagoClient.plans.createPlan({
     plan: {
       name: 'test',
       code: 'test',
       interval: 'monthly',
       amount_cents: 0,
       amount_currency: 'USD',
       pay_in_advance: false,
       charges: [
         {
           billable_metric_id: billableMetric.billable_metric.lago_id,
           charge_model: 'standard',
           pay_in_advance: false,
           properties: { amount: '1' },
           filters: [
             {
               properties: { amount: '10' },
               values: { tier: ['expensive'] },
             },
           ],
         },
       ],
     },
   });

   // create customer
   const external_customer_id = 'jack';
   const { data: customer } = await lagoClient.customers.createCustomer({
     customer: {
       external_id: external_customer_id,
       name: 'Jack',
       currency: 'USD',
     },
   });

   // assign plan to customer
   await lagoClient.subscriptions.createSubscription({
     subscription: {
       external_customer_id: customer.customer.external_id,
       plan_code: plan.plan.code,
       external_id: LAGO_EXTERNAL_SUBSCRIPTION_ID,
     },
   });

   return { apiKey: apiKey.value, client: lagoClient };
 };

 describe('Plugin - Lago', () => {
   const JACK_USERNAME = 'jack_test';
   const client = axios.create({ baseURL: 'http://127.0.0.1:1984' });

   let restAPIKey: string;
   let lagoClient: LagoApi<unknown>; // prettier-ignore

   // set up
   beforeAll(async () => {
     if (existsSync(LAGO_PATH)) await rm(LAGO_PATH, { recursive: true });
     await downloadComposeFile();
     await launchLago();
     let res = await provisionLago();
     restAPIKey = res.apiKey;
     lagoClient = res.client;
   }, 120 * 1000);

   // clean up
   afterAll(async () => {
     await compose.downAll({
       cwd: LAGO_PATH,
       commandOptions: ['--volumes'],
     });
     await rm(LAGO_PATH, { recursive: true });
   }, 30 * 1000);

   it('should create route', async () => {
     await expect(
       requestAdminAPI('/apisix/admin/routes/1', 'PUT', {
         uri: '/hello',
         upstream: {
           nodes: {
             '127.0.0.1:1980': 1,
           },
           type: 'roundrobin',
         },
         plugins: {
           'request-id': { include_in_response: true }, // for transaction_id
           'key-auth': {}, // for subscription_id
           lago: {
             endpoint_addrs: [LAGO_API_URL],
             token: restAPIKey,
             event_transaction_id: '${http_x_request_id}',
             event_subscription_id: '${http_x_consumer_username}',
             event_code: 'test',
             batch_max_size: 1, // does not buffered usage reports
           },
         },
       }),
     ).resolves.not.toThrow();

     await expect(
       requestAdminAPI('/apisix/admin/routes/2', 'PUT', {
         uri: '/hello1',
         upstream: {
           nodes: {
             '127.0.0.1:1980': 1,
           },
           type: 'roundrobin',
         },
         plugins: {
           'request-id': { include_in_response: true },
           'key-auth': {},
           lago: {
             endpoint_addrs: [LAGO_API_URL],
             token: restAPIKey,
             event_transaction_id: '${http_x_request_id}',
             event_subscription_id: '${http_x_consumer_username}',
             event_code: 'test',
             event_properties: { tier: 'expensive' },
             batch_max_size: 1,
           },
         },
       }),
     ).resolves.not.toThrow();
   });

   it('should create consumer', async () =>
     expect(
       requestAdminAPI(`/apisix/admin/consumers/${JACK_USERNAME}`, 'PUT', {
         username: JACK_USERNAME,
         plugins: {
           'key-auth': { key: JACK_USERNAME },
         },
       }),
     ).resolves.not.toThrow());

   it('call API (without key)', async () => {
     const res = await client.get('/hello', { validateStatus: () => true });
     expect(res.status).toEqual(401);
   });

   it('call normal API', async () => {
     for (let i = 0; i < 3; i++) {
       await expect(
         client.get('/hello', { headers: { apikey: JACK_USERNAME } }),
       ).resolves.not.toThrow();
     }
     await wait(500);
   });

   it('check Lago events (normal API)', async () => {
     const { data } = await lagoClient.events.findAllEvents({
       external_subscription_id: LAGO_EXTERNAL_SUBSCRIPTION_ID,
     });

     expect(data.events).toHaveLength(3);
     expect(data.events[0].code).toEqual(LAGO_BILLABLE_METRIC_CODE);
   });

   let expensiveStartAt: Date;
   it('call expensive API', async () => {
     expensiveStartAt = new Date();
     for (let i = 0; i < 3; i++) {
       await expect(
         client.get('/hello1', { headers: { apikey: JACK_USERNAME } }),
       ).resolves.not.toThrow();
     }
     await wait(500);
   });

   it('check Lago events (expensive API)', async () => {
     const { data } = await lagoClient.events.findAllEvents({
       external_subscription_id: LAGO_EXTERNAL_SUBSCRIPTION_ID,
       timestamp_from: expensiveStartAt.toISOString(),
     });

     expect(data.events).toHaveLength(3);
     expect(data.events[0].code).toEqual(LAGO_BILLABLE_METRIC_CODE);
     expect(data.events[1].properties).toEqual({ tier: 'expensive' });
   });
 });
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	import { generateKeyPair } from 'node:crypto';
	import { existsSync } from 'node:fs';
	import { readFile, rm, writeFile } from 'node:fs/promises';
	import { promisify } from 'node:util';

	import { afterAll, beforeAll, describe, expect, it } from '@jest/globals';
	import axios from 'axios';
	import * as compose from 'docker-compose';
	import { gql, request } from 'graphql-request';
	import { Api as LagoApi, Client as LagoClient } from 'lago-javascript-client';
	import simpleGit from 'simple-git';
	import * as YAML from 'yaml';

	import { request as requestAdminAPI } from '../ts/admin_api';
	import { wait } from '../ts/utils';

	const LAGO_VERSION = 'v1.27.0';
	const LAGO_PATH = '/tmp/lago';
	const LAGO_FRONT_PORT = 59999;
	const LAGO_API_PORT = 30699;
	const LAGO_API_URL = `http://127.0.0.1:${LAGO_API_PORT}`;
	const LAGO_API_BASEURL = `http://127.0.0.1:${LAGO_API_PORT}/api/v1`;
	const LAGO_API_GRAPHQL_ENDPOINT = `${LAGO_API_URL}/graphql`;
	const LAGO_BILLABLE_METRIC_CODE = 'test';
	const LAGO_EXTERNAL_SUBSCRIPTION_ID = 'jack_test';

	// The project uses AGPLv3, so we can't store the docker compose file it uses in our repository and download it during testing.
	const downloadComposeFile = async () =>
	simpleGit().clone('https://github.com/getlago/lago', LAGO_PATH, {
	'--depth': '1',
	'--branch': LAGO_VERSION,
	});

	const launchLago = async () => {
	// patch docker-compose.yml to disable useless port
	const composeFilePath = `${LAGO_PATH}/docker-compose.yml`;
	const composeFile = YAML.parse(await readFile(composeFilePath, 'utf8'));
	delete composeFile.services.front; // front-end is not needed for tests
	delete composeFile.services['api-clock']; // clock is not needed for tests
	delete composeFile.services['api-worker']; // worker is not needed for tests
	delete composeFile.services['pdf']; // pdf is not needed for tests
	delete composeFile.services.redis.ports; // prevent port conflict
	delete composeFile.services.db.ports; // prevent port conflict
	await writeFile(composeFilePath, YAML.stringify(composeFile), 'utf8');

	// launch services
	const { privateKey } = await promisify(generateKeyPair)('rsa', {
	modulusLength: 2048,
	publicKeyEncoding: { type: 'pkcs1', format: 'pem' },
	privateKeyEncoding: { type: 'pkcs1', format: 'pem' },
	});
	const composeOpts: compose.IDockerComposeOptions = {
	cwd: LAGO_PATH,
	log: true,
	env: {
	LAGO_RSA_PRIVATE_KEY: Buffer.from(privateKey).toString('base64'),
	FRONT_PORT: `${LAGO_FRONT_PORT}`, // avoiding conflicts, tests do not require a front-end
	API_PORT: `${LAGO_API_PORT}`,
	LAGO_FRONT_URL: `http://127.0.0.1:${LAGO_FRONT_PORT}`,
	LAGO_API_URL,
	},
	};

	await compose.createAll(composeOpts);
	await compose.upOne('api', composeOpts);
	await compose.exec('api', 'rails db:create', composeOpts);
	await compose.exec('api', 'rails db:migrate', composeOpts);
	await compose.upAll(composeOpts);
	};

	const provisionLago = async () => {
	// sign up
	const { registerUser } = await request<{
	registerUser: { token: string; user: { organizations: { id: string }[] } };
	}>(
	LAGO_API_GRAPHQL_ENDPOINT,
	gql`
	mutation signup($input: RegisterUserInput!) {
	registerUser(input: $input) {
	token
	user {
	id
	organizations {
	id
	}
	}
	}
	}
	`,
	{
	input: {
	email: 'test@test.com',
	password: 'Admin000!',
	organizationName: 'test',
	},
	},
	);

	const webToken = registerUser.token;
	const organizationId = registerUser.user.organizations[0].id;
	const requestHeaders = {
	Authorization: `Bearer ${webToken}`,
	'X-Lago-Organization': organizationId,
	};

	// list api keys
	const { apiKeys } = await request<{
	apiKeys: { collection: { id: string }[] };
	}>(
	LAGO_API_GRAPHQL_ENDPOINT,
	gql`
	query getApiKeys {
	apiKeys(page: 1, limit: 20) {
	collection {
	id
	}
	}
	}
	`,
	{},
	requestHeaders,
	);

	// get first api key
	const { apiKey } = await request<{ apiKey: { value: string } }>(
	LAGO_API_GRAPHQL_ENDPOINT,
	gql`
	query getApiKeyValue($id: ID!) {
	apiKey(id: $id) {
	id
	value
	}
	}
	`,
	{ id: apiKeys.collection[0].id },
	requestHeaders,
	);

	const lagoClient = LagoClient(apiKey.value, { baseUrl: LAGO_API_BASEURL });

	// create billable metric
	const { data: billableMetric } =
	await lagoClient.billableMetrics.createBillableMetric({
	billable_metric: {
	name: LAGO_BILLABLE_METRIC_CODE,
	code: LAGO_BILLABLE_METRIC_CODE,
	aggregation_type: 'count_agg',
	filters: [
	{
	key: 'tier',
	values: ['normal', 'expensive'],
	},
	],
	},
	});

	// create plan
	const { data: plan } = await lagoClient.plans.createPlan({
	plan: {
	name: 'test',
	code: 'test',
	interval: 'monthly',
	amount_cents: 0,
	amount_currency: 'USD',
	pay_in_advance: false,
	charges: [
	{
	billable_metric_id: billableMetric.billable_metric.lago_id,
	charge_model: 'standard',
	pay_in_advance: false,
	properties: { amount: '1' },
	filters: [
	{
	properties: { amount: '10' },
	values: { tier: ['expensive'] },
	},
	],
	},
	],
	},
	});

	// create customer
	const external_customer_id = 'jack';
	const { data: customer } = await lagoClient.customers.createCustomer({
	customer: {
	external_id: external_customer_id,
	name: 'Jack',
	currency: 'USD',
	},
	});

	// assign plan to customer
	await lagoClient.subscriptions.createSubscription({
	subscription: {
	external_customer_id: customer.customer.external_id,
	plan_code: plan.plan.code,
	external_id: LAGO_EXTERNAL_SUBSCRIPTION_ID,
	},
	});

	return { apiKey: apiKey.value, client: lagoClient };
	};

	describe('Plugin - Lago', () => {
	const JACK_USERNAME = 'jack_test';
	const client = axios.create({ baseURL: 'http://127.0.0.1:1984' });

	let restAPIKey: string;
	let lagoClient: LagoApi<unknown>; // prettier-ignore

	// set up
	beforeAll(async () => {
	if (existsSync(LAGO_PATH)) await rm(LAGO_PATH, { recursive: true });
	await downloadComposeFile();
	await launchLago();
	let res = await provisionLago();
	restAPIKey = res.apiKey;
	lagoClient = res.client;
	}, 120 * 1000);

	// clean up
	afterAll(async () => {
	await compose.downAll({
	cwd: LAGO_PATH,
	commandOptions: ['--volumes'],
	});
	await rm(LAGO_PATH, { recursive: true });
	}, 30 * 1000);

	it('should create route', async () => {
	await expect(
	requestAdminAPI('/apisix/admin/routes/1', 'PUT', {
	uri: '/hello',
	upstream: {
	nodes: {
	'127.0.0.1:1980': 1,
	},
	type: 'roundrobin',
	},
	plugins: {
	'request-id': { include_in_response: true }, // for transaction_id
	'key-auth': {}, // for subscription_id
	lago: {
	endpoint_addrs: [LAGO_API_URL],
	token: restAPIKey,
	event_transaction_id: '${http_x_request_id}',
	event_subscription_id: '${http_x_consumer_username}',
	event_code: 'test',
	batch_max_size: 1, // does not buffered usage reports
	},
	},
	}),
	).resolves.not.toThrow();

	await expect(
	requestAdminAPI('/apisix/admin/routes/2', 'PUT', {
	uri: '/hello1',
	upstream: {
	nodes: {
	'127.0.0.1:1980': 1,
	},
	type: 'roundrobin',
	},
	plugins: {
	'request-id': { include_in_response: true },
	'key-auth': {},
	lago: {
	endpoint_addrs: [LAGO_API_URL],
	token: restAPIKey,
	event_transaction_id: '${http_x_request_id}',
	event_subscription_id: '${http_x_consumer_username}',
	event_code: 'test',
	event_properties: { tier: 'expensive' },
	batch_max_size: 1,
	},
	},
	}),
	).resolves.not.toThrow();
	});

	it('should create consumer', async () =>
	expect(
	requestAdminAPI(`/apisix/admin/consumers/${JACK_USERNAME}`, 'PUT', {
	username: JACK_USERNAME,
	plugins: {
	'key-auth': { key: JACK_USERNAME },
	},
	}),
	).resolves.not.toThrow());

	it('call API (without key)', async () => {
	const res = await client.get('/hello', { validateStatus: () => true });
	expect(res.status).toEqual(401);
	});

	it('call normal API', async () => {
	for (let i = 0; i < 3; i++) {
	await expect(
	client.get('/hello', { headers: { apikey: JACK_USERNAME } }),
	).resolves.not.toThrow();
	}
	await wait(500);
	});

	it('check Lago events (normal API)', async () => {
	const { data } = await lagoClient.events.findAllEvents({
	external_subscription_id: LAGO_EXTERNAL_SUBSCRIPTION_ID,
	});

	expect(data.events).toHaveLength(3);
	expect(data.events[0].code).toEqual(LAGO_BILLABLE_METRIC_CODE);
	});

	let expensiveStartAt: Date;
	it('call expensive API', async () => {
	expensiveStartAt = new Date();
	for (let i = 0; i < 3; i++) {
	await expect(
	client.get('/hello1', { headers: { apikey: JACK_USERNAME } }),
	).resolves.not.toThrow();
	}
	await wait(500);
	});

	it('check Lago events (expensive API)', async () => {
	const { data } = await lagoClient.events.findAllEvents({
	external_subscription_id: LAGO_EXTERNAL_SUBSCRIPTION_ID,
	timestamp_from: expensiveStartAt.toISOString(),
	});

	expect(data.events).toHaveLength(3);
	expect(data.events[0].code).toEqual(LAGO_BILLABLE_METRIC_CODE);
	expect(data.events[1].properties).toEqual({ tier: 'expensive' });
	});
	});