@nextsparkjs/core 0.1.0-beta.1 → 0.1.0-beta.10

package/templates/contents/themes/default/tests/cypress/e2e/api/billing/plans/downgrade.cy.ts

@@ -1,510 +0,0 @@
-// @ts-nocheck
-/// <reference types="cypress" />
-
-/**
- * Billing API - Downgrade Policy Tests
- *
- * BDD: Feature: Downgrade Policy - Soft Limits
- * As a user downgrading from a higher plan
- * I want my existing resources to remain accessible
- * So that I don't lose my data
- *
- * Tests for:
- * - Downgrade is always allowed
- * - Existing resources remain accessible after downgrade
- * - New resource creation blocked when over limit
- * - Creation allowed after reducing resources
- * - Features are lost immediately on downgrade
- * - Team members remain but cannot add more
- *
- * Session: 2025-12-20-subscriptions-system-v2
- * Phase: 9 (api-tester)
- *
- * NOTE: These tests validate the soft-limit downgrade policy configuration.
- * Full E2E downgrade tests require Stripe integration.
- */
-
-import * as allure from 'allure-cypress'
-
-const BillingAPIController = require('../BillingAPIController.js')
-import billingPlans from './fixtures/billing-plans.json'
-
-describe('Billing API - Downgrade Policy (Soft Limits)', () => {
-  let billingAPI: any
-
-  // Test data from fixtures
-  const FREE_PLAN = billingPlans.plans.free
-  const STARTER_PLAN = billingPlans.plans.starter
-  const PRO_PLAN = billingPlans.plans.pro
-  const BUSINESS_PLAN = billingPlans.plans.business
-  const SUPERADMIN = billingPlans.testCredentials.superadmin
-  const BASE_URL = Cypress.config('baseUrl') || 'http://localhost:5173'
-
-  before(() => {
-    billingAPI = new BillingAPIController(BASE_URL, SUPERADMIN.apiKey, SUPERADMIN.teamId)
-    cy.log('BillingAPIController initialized for Downgrade Policy tests')
-    cy.log('Testing soft-limit downgrade behavior')
-  })
-
-  beforeEach(() => {
-    allure.epic('Billing')
-    allure.feature('Downgrade Policy')
-    allure.owner('qa-automation')
-  })
-
-  // ============================================================
-  // TEST GROUP 1: Plan Limit Comparisons for Downgrade
-  // ============================================================
-  describe('Limit Comparisons', () => {
-    it('DOWNGRADE_001: Free plan limits should be lower than all paid plans', () => {
-      allure.story('Limit Analysis')
-      allure.severity('critical')
-      allure.description(`
-        Scenario: Free plan has lowest limits
-        Given the plan configurations
-        Then Free limits should be < Starter < Pro < Business
-      `)
-
-      const limits = ['team_members', 'tasks', 'customers', 'webhooks_count']
-
-      limits.forEach((limit) => {
-        // Free < Starter
-        expect(FREE_PLAN.limits[limit]).to.be.lessThan(STARTER_PLAN.limits[limit])
-        // Starter < Pro
-        expect(STARTER_PLAN.limits[limit]).to.be.lessThan(PRO_PLAN.limits[limit])
-        // Pro < Business
-        expect(PRO_PLAN.limits[limit]).to.be.lessThan(BUSINESS_PLAN.limits[limit])
-
-        cy.log(`${limit}: Free=${FREE_PLAN.limits[limit]} < Starter=${STARTER_PLAN.limits[limit]} < Pro=${PRO_PLAN.limits[limit]} < Business=${BUSINESS_PLAN.limits[limit]}`)
-      })
-    })
-
-    it('DOWNGRADE_002: Calculate potential over-limit scenarios on downgrade', () => {
-      allure.story('Over-limit Calculation')
-      allure.severity('normal')
-      allure.description(`
-        Scenario: Identify resources that would exceed limits on downgrade
-        Given a team at Pro limits
-        When they downgrade to Free
-        Then many resources would be over limit
-      `)
-
-      // Simulate a team using Pro limits fully
-      const proUsage = {
-        team_members: PRO_PLAN.limits.team_members, // 15
-        tasks: PRO_PLAN.limits.tasks,               // 1000
-        customers: PRO_PLAN.limits.customers,       // 500
-        webhooks_count: PRO_PLAN.limits.webhooks_count // 10
-      }
-
-      // Calculate over-limit on downgrade to Free
-      const overLimits = {
-        team_members: proUsage.team_members - FREE_PLAN.limits.team_members, // 15 - 3 = 12
-        tasks: proUsage.tasks - FREE_PLAN.limits.tasks,                      // 1000 - 50 = 950
-        customers: proUsage.customers - FREE_PLAN.limits.customers,          // 500 - 25 = 475
-        webhooks_count: proUsage.webhooks_count - FREE_PLAN.limits.webhooks_count // 10 - 0 = 10
-      }
-
-      cy.log('Over-limit resources on Pro -> Free downgrade:')
-      Object.entries(overLimits).forEach(([key, value]) => {
-        if (value as number > 0) {
-          cy.log(`  ${key}: ${value} over limit`)
-        }
-      })
-
-      // Verify significant over-limit
-      expect(overLimits.tasks).to.be.greaterThan(900)
-      expect(overLimits.customers).to.be.greaterThan(400)
-      expect(overLimits.team_members).to.be.greaterThan(10)
-    })
-  })
-
-  // ============================================================
-  // TEST GROUP 2: Feature Loss on Downgrade
-  // ============================================================
-  describe('Feature Loss', () => {
-    it('DOWNGRADE_010: Pro features should be lost when downgrading to Free', () => {
-      allure.story('Feature Loss')
-      allure.severity('critical')
-      allure.description(`
-        Scenario: Features are lost immediately on downgrade
-        Given a team with Pro plan
-        When they downgrade to Free plan
-        Then Pro-exclusive features should be blocked
-      `)
-
-      // Features in Pro but not in Free
-      const proExclusiveFeatures = PRO_PLAN.features.filter(
-        (f: string) => !FREE_PLAN.features.includes(f)
-      )
-
-      cy.log('Features lost on Pro -> Free downgrade:')
-      proExclusiveFeatures.forEach((feature: string) => {
-        cy.log(`  - ${feature}`)
-      })
-
-      // Expected to lose
-      expect(proExclusiveFeatures).to.include('advanced_analytics')
-      expect(proExclusiveFeatures).to.include('realtime_analytics')
-      expect(proExclusiveFeatures).to.include('webhooks')
-      expect(proExclusiveFeatures).to.include('task_automation')
-      expect(proExclusiveFeatures).to.include('custom_branding')
-    })
-
-    it('DOWNGRADE_011: Map features to blocked actions after downgrade', () => {
-      allure.story('Action Blocking')
-      allure.severity('critical')
-      allure.description(`
-        Scenario: Feature loss means action blocking
-        Given the action mappings
-        When Pro features are lost
-        Then corresponding actions should be blocked
-      `)
-
-      const featureToActions = billingPlans.actionMappings.features
-
-      // Features lost on Pro -> Free
-      const lostFeatures = PRO_PLAN.features.filter(
-        (f: string) => !FREE_PLAN.features.includes(f)
-      )
-
-      // Find actions that would be blocked
-      const blockedActions: string[] = []
-      Object.entries(featureToActions).forEach(([action, feature]) => {
-        if (lostFeatures.includes(feature as string)) {
-          blockedActions.push(action)
-        }
-      })
-
-      cy.log('Actions blocked after Pro -> Free downgrade:')
-      blockedActions.forEach((action) => {
-        cy.log(`  - ${action}`)
-      })
-
-      // Verify key actions blocked
-      expect(blockedActions).to.include('analytics.view_advanced')
-      expect(blockedActions).to.include('analytics.view_realtime')
-      expect(blockedActions).to.include('tasks.automate')
-    })
-
-    it('DOWNGRADE_012: Business features lost on downgrade to Pro', () => {
-      allure.story('Feature Loss')
-      allure.severity('normal')
-      allure.description(`
-        Scenario: Business-exclusive features lost on downgrade to Pro
-        Given a team with Business plan
-        When they downgrade to Pro plan
-        Then Business-exclusive features should be blocked
-      `)
-
-      // Features in Business but not in Pro
-      const businessExclusiveFeatures = BUSINESS_PLAN.features.filter(
-        (f: string) => !PRO_PLAN.features.includes(f)
-      )
-
-      cy.log('Features lost on Business -> Pro downgrade:')
-      businessExclusiveFeatures.forEach((feature: string) => {
-        cy.log(`  - ${feature}`)
-      })
-
-      // Expected to lose
-      expect(businessExclusiveFeatures).to.include('sso')
-      expect(businessExclusiveFeatures).to.include('audit_logs')
-      expect(businessExclusiveFeatures).to.include('customer_import')
-      expect(businessExclusiveFeatures).to.include('recurring_tasks')
-    })
-  })
-
-  // ============================================================
-  // TEST GROUP 3: Soft Limit Policy
-  // ============================================================
-  describe('Soft Limit Policy', () => {
-    it('DOWNGRADE_020: Over-limit resources should remain accessible (read)', () => {
-      allure.story('Soft Limits')
-      allure.severity('critical')
-      allure.description(`
-        Scenario: Existing resources remain accessible after downgrade
-        Given my team was downgraded and has resources over limit
-        Then I should still be able to read all existing resources
-        Note: This is the "soft limit" policy
-      `)
-
-      // The soft limit policy means:
-      // - If you have 200 tasks and downgrade to Free (limit 50)
-      // - All 200 tasks remain accessible
-      // - You just can't create new ones
-
-      cy.log('Soft Limit Policy:')
-      cy.log('  ❌ New creation blocked when over limit')
-      cy.log('  ✓ Existing resources remain accessible')
-      cy.log('  ✓ Can delete/archive to get under limit')
-      cy.log('  ✓ Creation allowed again after reducing usage')
-
-      // Verify policy is documented in fixture
-      expect(FREE_PLAN.limits.tasks).to.eq(50)
-      cy.log(`Free plan task limit: ${FREE_PLAN.limits.tasks}`)
-      cy.log('If team has 200 tasks and downgrades: all 200 remain accessible')
-    })
-
-    it('DOWNGRADE_021: Creation should be blocked when over limit', () => {
-      allure.story('Creation Blocking')
-      allure.severity('critical')
-      allure.description(`
-        Scenario: New resource creation blocked when over limit
-        Given my team has more resources than the plan limit
-        When I check action for creating more
-        Then the action should be denied with quota_exceeded
-      `)
-
-      // This tests the expected behavior
-      // When current > max, creation should be blocked
-
-      cy.log('Quota Exceeded Behavior:')
-      cy.log('  action: tasks.create')
-      cy.log('  current: 200 (example)')
-      cy.log('  max: 50 (Free plan)')
-      cy.log('  allowed: false')
-      cy.log('  reason: quota_exceeded')
-
-      // The check-action endpoint handles this case
-      // Response format:
-      const expectedResponse = {
-        allowed: false,
-        reason: 'quota_exceeded',
-        quota: {
-          allowed: false,
-          current: 200,
-          max: 50,
-          remaining: -150,
-          percentUsed: 400
-        }
-      }
-
-      cy.log('Expected response structure:')
-      cy.log(JSON.stringify(expectedResponse, null, 2))
-    })
-
-    it('DOWNGRADE_022: Quota remaining can be negative when over limit', () => {
-      allure.story('Negative Remaining')
-      allure.severity('normal')
-      allure.description(`
-        Scenario: Quota remaining shows negative when over limit
-        Given a team with 200 tasks on Free plan (limit 50)
-        When checking usage
-        Then remaining should be -150
-        And percentUsed should be > 100
-      `)
-
-      // When over limit:
-      // current: 200
-      // max: 50
-      // remaining: 50 - 200 = -150
-      // percentUsed: (200/50) * 100 = 400%
-
-      const overLimitScenario = {
-        current: 200,
-        max: 50,
-        remaining: -150,
-        percentUsed: 400
-      }
-
-      expect(overLimitScenario.remaining).to.be.lessThan(0)
-      expect(overLimitScenario.percentUsed).to.be.greaterThan(100)
-
-      cy.log('Over-limit quota calculation:')
-      cy.log(`  current: ${overLimitScenario.current}`)
-      cy.log(`  max: ${overLimitScenario.max}`)
-      cy.log(`  remaining: ${overLimitScenario.remaining}`)
-      cy.log(`  percentUsed: ${overLimitScenario.percentUsed}%`)
-    })
-  })
-
-  // ============================================================
-  // TEST GROUP 4: Recovery from Over-Limit
-  // ============================================================
-  describe('Recovery from Over-Limit', () => {
-    it('DOWNGRADE_030: Creation allowed after reducing resources', () => {
-      allure.story('Recovery')
-      allure.severity('critical')
-      allure.description(`
-        Scenario: Creation allowed after reducing resources
-        Given my team was over the tasks limit
-        When I delete tasks until under the limit
-        Then I should be able to create new tasks again
-      `)
-
-      // Recovery scenario:
-      // 1. Team has 200 tasks, Free plan limit 50
-      // 2. Delete 160 tasks -> now has 40 tasks
-      // 3. 40 < 50, so creation is allowed again
-
-      const recoveryScenario = {
-        before: { current: 200, max: 50, allowed: false },
-        after: { current: 40, max: 50, allowed: true, remaining: 10 }
-      }
-
-      expect(recoveryScenario.before.allowed).to.be.false
-      expect(recoveryScenario.after.allowed).to.be.true
-      expect(recoveryScenario.after.remaining).to.eq(10)
-
-      cy.log('Recovery scenario:')
-      cy.log('  Before: 200 tasks (blocked)')
-      cy.log('  Action: Delete 160 tasks')
-      cy.log('  After: 40 tasks (10 remaining)')
-      cy.log('  Result: Creation allowed again')
-    })
-
-    it('DOWNGRADE_031: Team members soft limit behavior', () => {
-      allure.story('Team Members')
-      allure.severity('normal')
-      allure.description(`
-        Scenario: Team members remain but cannot add more
-        Given my team has 8 members (from Pro plan)
-        When I downgrade to Free plan (limit 3 members)
-        Then all 8 members should still be in the team
-        But I should not be able to invite new members
-      `)
-
-      // Pro allows 15 members, Free allows 3
-      // If team has 8 members and downgrades:
-      // - 8 members remain in team
-      // - Cannot invite more until < 3
-
-      const teamMemberScenario = {
-        proLimit: PRO_PLAN.limits.team_members,  // 15
-        freeLimit: FREE_PLAN.limits.team_members, // 3
-        currentMembers: 8,
-        canInvite: false
-      }
-
-      expect(teamMemberScenario.currentMembers).to.be.greaterThan(teamMemberScenario.freeLimit)
-      expect(teamMemberScenario.canInvite).to.be.false
-
-      cy.log('Team members soft limit:')
-      cy.log(`  Pro limit: ${teamMemberScenario.proLimit}`)
-      cy.log(`  Free limit: ${teamMemberScenario.freeLimit}`)
-      cy.log(`  Current members: ${teamMemberScenario.currentMembers}`)
-      cy.log(`  Can invite: ${teamMemberScenario.canInvite}`)
-      cy.log('  Note: All 8 members remain, but no new invites')
-    })
-  })
-
-  // ============================================================
-  // TEST GROUP 5: Downgrade Warning Data
-  // ============================================================
-  describe('Downgrade Warning Data', () => {
-    it('DOWNGRADE_040: Calculate what exceeds limits on downgrade', () => {
-      allure.story('Warning Calculation')
-      allure.severity('normal')
-      allure.description(`
-        Scenario: Calculate resources that would exceed limits
-        Given current usage and target plan limits
-        Then calculate what resources would be over limit
-      `)
-
-      // Simulate a Pro team's usage
-      const currentUsage = {
-        team_members: 10,
-        tasks: 800,
-        customers: 300,
-        webhooks_count: 8
-      }
-
-      // Calculate what exceeds Free limits
-      const freeExceeds: Record<string, number> = {}
-      Object.keys(currentUsage).forEach((key) => {
-        const diff = currentUsage[key as keyof typeof currentUsage] - FREE_PLAN.limits[key]
-        if (diff > 0) {
-          freeExceeds[key] = diff
-        }
-      })
-
-      cy.log('Current usage (Pro team):')
-      Object.entries(currentUsage).forEach(([key, value]) => {
-        cy.log(`  ${key}: ${value}`)
-      })
-
-      cy.log('Exceeds Free limits by:')
-      Object.entries(freeExceeds).forEach(([key, value]) => {
-        cy.log(`  ${key}: +${value}`)
-      })
-
-      expect(freeExceeds.team_members).to.eq(7)  // 10 - 3
-      expect(freeExceeds.tasks).to.eq(750)       // 800 - 50
-      expect(freeExceeds.customers).to.eq(275)   // 300 - 25
-      expect(freeExceeds.webhooks_count).to.eq(8) // 8 - 0
-    })
-
-    it('DOWNGRADE_041: Calculate features lost on downgrade', () => {
-      allure.story('Features Lost')
-      allure.severity('normal')
-      allure.description(`
-        Scenario: List features that will be lost on downgrade
-        Given current plan features and target plan features
-        Then list features that will be lost
-      `)
-
-      // Pro -> Free downgrade
-      const currentFeatures = PRO_PLAN.features
-      const targetFeatures = FREE_PLAN.features
-
-      const lostFeatures = currentFeatures.filter(
-        (f: string) => !targetFeatures.includes(f)
-      )
-
-      cy.log(`Features in Pro: ${currentFeatures.length}`)
-      cy.log(`Features in Free: ${targetFeatures.length}`)
-      cy.log(`Features to be lost: ${lostFeatures.length}`)
-
-      lostFeatures.forEach((feature: string) => {
-        cy.log(`  - ${feature}`)
-      })
-
-      expect(lostFeatures.length).to.be.greaterThan(5)
-    })
-  })
-
-  // ============================================================
-  // TEST GROUP 6: Integration Tests
-  // ============================================================
-  describe('Integration', () => {
-    it('DOWNGRADE_100: Complete downgrade policy validation', () => {
-      allure.story('Complete Validation')
-      allure.severity('critical')
-      allure.description(`
-        Integration test that validates downgrade policy:
-        - Soft limits preserve existing resources
-        - Creation blocked when over limit
-        - Features lost immediately
-        - Recovery possible by reducing usage
-      `)
-
-      // 1. Soft limit policy is in place
-      cy.log('1. Soft Limit Policy Verification')
-      cy.log('   Existing resources remain accessible')
-      cy.log('   Only new creation is blocked')
-
-      // 2. Feature loss is immediate
-      const proToFreeFeatureLoss = PRO_PLAN.features.filter(
-        (f: string) => !FREE_PLAN.features.includes(f)
-      )
-      expect(proToFreeFeatureLoss.length).to.be.greaterThan(0)
-      cy.log(`2. Feature loss: ${proToFreeFeatureLoss.length} features`)
-
-      // 3. Limits are enforced correctly
-      expect(FREE_PLAN.limits.tasks).to.eq(50)
-      expect(FREE_PLAN.limits.customers).to.eq(25)
-      expect(FREE_PLAN.limits.team_members).to.eq(3)
-      cy.log('3. Limits are defined correctly')
-
-      // 4. Action mappings exist for limits
-      const limitMappings = billingPlans.actionMappings.limits
-      expect(limitMappings['tasks.create']).to.eq('tasks')
-      expect(limitMappings['customers.create']).to.eq('customers')
-      expect(limitMappings['team.members.invite']).to.eq('team_members')
-      cy.log('4. Action mappings are correct')
-
-      cy.log('Downgrade policy validation complete')
-    })
-  })
-})

package/templates/contents/themes/default/tests/cypress/e2e/api/billing/plans/fixtures/billing-plans.json

@@ -1,163 +0,0 @@
-{
-  "$schema": "./billing-plans.schema.json",
-  "_description": "Test data for billing plan tests - matches billing.config.ts",
-
-  "plans": {
-    "free": {
-      "slug": "free",
-      "name": "Free",
-      "priceMonthly": 0,
-      "priceYearly": 0,
-      "features": ["basic_analytics"],
-      "limits": {
-        "team_members": 3,
-        "tasks": 50,
-        "customers": 25,
-        "api_calls": 1000,
-        "storage_gb": 1,
-        "file_uploads": 100,
-        "webhooks_count": 0
-      }
-    },
-    "starter": {
-      "slug": "starter",
-      "name": "Starter",
-      "priceMonthly": 1500,
-      "priceYearly": 14400,
-      "features": ["basic_analytics", "advanced_analytics", "api_access", "guest_access"],
-      "limits": {
-        "team_members": 5,
-        "tasks": 200,
-        "customers": 100,
-        "api_calls": 10000,
-        "storage_gb": 10,
-        "file_uploads": 500,
-        "webhooks_count": 3
-      }
-    },
-    "pro": {
-      "slug": "pro",
-      "name": "Pro",
-      "priceMonthly": 2900,
-      "priceYearly": 29000,
-      "features": [
-        "basic_analytics",
-        "advanced_analytics",
-        "realtime_analytics",
-        "api_access",
-        "webhooks",
-        "custom_branding",
-        "guest_access",
-        "priority_support",
-        "task_automation"
-      ],
-      "limits": {
-        "team_members": 15,
-        "tasks": 1000,
-        "customers": 500,
-        "api_calls": 100000,
-        "storage_gb": 50,
-        "file_uploads": 2000,
-        "webhooks_count": 10
-      }
-    },
-    "business": {
-      "slug": "business",
-      "name": "Business",
-      "priceMonthly": 7900,
-      "priceYearly": 79000,
-      "features": [
-        "basic_analytics",
-        "advanced_analytics",
-        "realtime_analytics",
-        "api_access",
-        "webhooks",
-        "custom_branding",
-        "sso",
-        "audit_logs",
-        "guest_access",
-        "priority_support",
-        "task_automation",
-        "customer_import",
-        "recurring_tasks"
-      ],
-      "limits": {
-        "team_members": 50,
-        "tasks": 5000,
-        "customers": 2000,
-        "api_calls": 500000,
-        "storage_gb": 200,
-        "file_uploads": 10000,
-        "webhooks_count": 50
-      }
-    },
-    "enterprise": {
-      "slug": "enterprise",
-      "name": "Enterprise",
-      "features": ["*"],
-      "limits": {
-        "team_members": -1,
-        "tasks": -1,
-        "customers": -1,
-        "api_calls": -1,
-        "storage_gb": -1,
-        "file_uploads": -1,
-        "webhooks_count": -1
-      }
-    }
-  },
-
-  "actionMappings": {
-    "features": {
-      "analytics.view_advanced": "advanced_analytics",
-      "analytics.view_realtime": "realtime_analytics",
-      "api.generate_key": "api_access",
-      "webhooks.create": "webhooks",
-      "branding.customize": "custom_branding",
-      "branding.white_label": "white_label",
-      "auth.configure_sso": "sso",
-      "security.view_audit_logs": "audit_logs",
-      "support.priority_access": "priority_support",
-      "support.dedicated_channel": "dedicated_support",
-      "team.invite_guest": "guest_access",
-      "tasks.automate": "task_automation",
-      "tasks.create_recurring": "recurring_tasks",
-      "customers.bulk_import": "customer_import"
-    },
-    "limits": {
-      "team.members.invite": "team_members",
-      "tasks.create": "tasks",
-      "customers.create": "customers",
-      "api.call": "api_calls",
-      "files.upload": "storage_gb",
-      "files.upload_count": "file_uploads",
-      "webhooks.create": "webhooks_count"
-    }
-  },
-
-  "testTeams": {
-    "free": {
-      "teamId": "team-personal-carlos-001",
-      "subscriptionId": "sub-personal-carlos-001",
-      "description": "Carlos personal team with Free plan"
-    },
-    "pro": {
-      "teamId": "team-tmt-001",
-      "subscriptionId": "sub-tmt-001",
-      "description": "TMT Core team with Pro plan"
-    },
-    "enterprise": {
-      "teamId": "team-ironvale-002",
-      "subscriptionId": "sub-ironvale-001",
-      "description": "Ironvale Global with Enterprise plan"
-    }
-  },
-
-  "testCredentials": {
-    "superadmin": {
-      "apiKey": "test_api_key_for_testing_purposes_only_not_a_real_secret_key_abc123",
-      "userId": "test-superadmin-001",
-      "teamId": "team-tmt-001"
-    }
-  }
-}