telegram-management-system/marketing-agent/services/billing-service/tests/subscription.test.js

import request from 'supertest';
import app from '../src/app.js';
import { Subscription } from '../src/models/Subscription.js';
import mongoose from 'mongoose';

describe('Subscription API', () => {
  beforeAll(async () => {
    // Connect to test database
    await mongoose.connect('mongodb://localhost:27017/billing-test', {
      useNewUrlParser: true,
      useUnifiedTopology: true
    });
  });

  afterAll(async () => {
    // Clean up and close connection
    await mongoose.connection.dropDatabase();
    await mongoose.connection.close();
  });

  afterEach(async () => {
    // Clean up data after each test
    await Subscription.deleteMany({});
  });

  describe('POST /api/subscriptions', () => {
    it('should create a new subscription', async () => {
      const subscriptionData = {
        plan: 'starter',
        billingCycle: 'monthly'
      };

      const response = await request(app)
        .post('/api/subscriptions')
        .set('Authorization', 'Bearer test-token')
        .set('x-tenant-id', 'test-tenant')
        .send(subscriptionData);

      expect(response.status).toBe(201);
      expect(response.body.success).toBe(true);
      expect(response.body.subscription).toBeDefined();
      expect(response.body.subscription.plan).toBe('starter');
    });

    it('should validate required fields', async () => {
      const response = await request(app)
        .post('/api/subscriptions')
        .set('Authorization', 'Bearer test-token')
        .set('x-tenant-id', 'test-tenant')
        .send({});

      expect(response.status).toBe(400);
      expect(response.body.success).toBe(false);
      expect(response.body.errors).toBeDefined();
    });
  });

  describe('GET /api/subscriptions', () => {
    it('should return tenant subscriptions', async () => {
      // Create test subscription
      const subscription = new Subscription({
        tenantId: 'test-tenant',
        plan: 'professional',
        status: 'active'
      });
      await subscription.save();

      const response = await request(app)
        .get('/api/subscriptions')
        .set('Authorization', 'Bearer test-token')
        .set('x-tenant-id', 'test-tenant');

      expect(response.status).toBe(200);
      expect(response.body.success).toBe(true);
      expect(response.body.subscriptions).toHaveLength(1);
      expect(response.body.subscriptions[0].plan).toBe('professional');
    });
  });

  describe('POST /api/subscriptions/:id/cancel', () => {
    it('should cancel a subscription', async () => {
      // Create test subscription
      const subscription = new Subscription({
        tenantId: 'test-tenant',
        plan: 'starter',
        status: 'active'
      });
      await subscription.save();

      const response = await request(app)
        .post(`/api/subscriptions/${subscription._id}/cancel`)
        .set('Authorization', 'Bearer test-token')
        .set('x-tenant-id', 'test-tenant')
        .send({ reason: 'No longer needed' });

      expect(response.status).toBe(200);
      expect(response.body.success).toBe(true);
      expect(response.body.subscription.status).toBe('canceled');
    });
  });
});