@l4yercak3/cli 1.0.0

package/tests/nextjs-detector.test.js

@@ -0,0 +1,235 @@
+/**
+ * Tests for Next.js Detector
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+const NextJsDetector = require('../src/detectors/nextjs-detector');
+
+describe('NextJsDetector', () => {
+  const mockProjectPath = '/test/project';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('properties', () => {
+    it('has correct name', () => {
+      expect(NextJsDetector.name).toBe('nextjs');
+    });
+
+    it('has high priority', () => {
+      expect(NextJsDetector.priority).toBe(100);
+    });
+  });
+
+  describe('detect', () => {
+    it('returns not detected when no package.json exists', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = NextJsDetector.detect(mockProjectPath);
+
+      // When package.json doesn't exist, returns raw results object
+      expect(result.isNextJs).toBe(false);
+      expect(result.version).toBeNull();
+    });
+
+    it('returns not detected when Next.js is not in dependencies', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          react: '^18.0.0',
+        },
+      }));
+
+      const result = NextJsDetector.detect(mockProjectPath);
+
+      expect(result).toEqual({
+        detected: false,
+        confidence: 0,
+        metadata: {},
+      });
+    });
+
+    it('detects Next.js project with version', () => {
+      fs.existsSync.mockImplementation((p) => {
+        if (p === path.join(mockProjectPath, 'package.json')) return true;
+        return false;
+      });
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          next: '^14.0.0',
+          react: '^18.0.0',
+        },
+      }));
+
+      const result = NextJsDetector.detect(mockProjectPath);
+
+      expect(result.detected).toBe(true);
+      expect(result.confidence).toBe(0.95);
+      expect(result.metadata.version).toBe('^14.0.0');
+    });
+
+    it('detects TypeScript from dependencies', () => {
+      fs.existsSync.mockImplementation((p) => {
+        if (p === path.join(mockProjectPath, 'package.json')) return true;
+        return false;
+      });
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          next: '^14.0.0',
+        },
+        devDependencies: {
+          typescript: '^5.0.0',
+        },
+      }));
+
+      const result = NextJsDetector.detect(mockProjectPath);
+
+      expect(result.metadata.hasTypeScript).toBe(true);
+    });
+
+    it('detects TypeScript from tsconfig.json', () => {
+      fs.existsSync.mockImplementation((p) => {
+        if (p === path.join(mockProjectPath, 'package.json')) return true;
+        if (p === path.join(mockProjectPath, 'tsconfig.json')) return true;
+        return false;
+      });
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          next: '^14.0.0',
+        },
+      }));
+
+      const result = NextJsDetector.detect(mockProjectPath);
+
+      expect(result.metadata.hasTypeScript).toBe(true);
+    });
+
+    it('detects App Router from app directory', () => {
+      fs.existsSync.mockImplementation((p) => {
+        if (p === path.join(mockProjectPath, 'package.json')) return true;
+        if (p === path.join(mockProjectPath, 'app')) return true;
+        return false;
+      });
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          next: '^14.0.0',
+        },
+      }));
+
+      const result = NextJsDetector.detect(mockProjectPath);
+
+      expect(result.metadata.routerType).toBe('app');
+    });
+
+    it('detects App Router from src/app directory', () => {
+      fs.existsSync.mockImplementation((p) => {
+        if (p === path.join(mockProjectPath, 'package.json')) return true;
+        if (p === path.join(mockProjectPath, 'src', 'app')) return true;
+        return false;
+      });
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          next: '^14.0.0',
+        },
+      }));
+
+      const result = NextJsDetector.detect(mockProjectPath);
+
+      expect(result.metadata.routerType).toBe('app');
+    });
+
+    it('detects Pages Router from pages directory', () => {
+      fs.existsSync.mockImplementation((p) => {
+        if (p === path.join(mockProjectPath, 'package.json')) return true;
+        if (p === path.join(mockProjectPath, 'pages')) return true;
+        return false;
+      });
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          next: '^14.0.0',
+        },
+      }));
+
+      const result = NextJsDetector.detect(mockProjectPath);
+
+      expect(result.metadata.routerType).toBe('pages');
+    });
+
+    it('detects next.config.js', () => {
+      fs.existsSync.mockImplementation((p) => {
+        if (p === path.join(mockProjectPath, 'package.json')) return true;
+        if (p === path.join(mockProjectPath, 'next.config.js')) return true;
+        return false;
+      });
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          next: '^14.0.0',
+        },
+      }));
+
+      const result = NextJsDetector.detect(mockProjectPath);
+
+      expect(result.metadata.config).toBe('next.config.js');
+    });
+
+    it('detects next.config.mjs', () => {
+      fs.existsSync.mockImplementation((p) => {
+        if (p === path.join(mockProjectPath, 'package.json')) return true;
+        if (p === path.join(mockProjectPath, 'next.config.mjs')) return true;
+        return false;
+      });
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          next: '^14.0.0',
+        },
+      }));
+
+      const result = NextJsDetector.detect(mockProjectPath);
+
+      expect(result.metadata.config).toBe('next.config.mjs');
+    });
+
+    it('handles JSON parse errors gracefully', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue('invalid json');
+
+      const result = NextJsDetector.detect(mockProjectPath);
+
+      expect(result).toEqual({
+        detected: false,
+        confidence: 0,
+        metadata: {},
+      });
+    });
+  });
+
+  describe('getSupportedFeatures', () => {
+    it('returns all features as supported', () => {
+      const features = NextJsDetector.getSupportedFeatures();
+
+      expect(features).toEqual({
+        oauth: true,
+        stripe: true,
+        crm: true,
+        projects: true,
+        invoices: true,
+      });
+    });
+  });
+
+  describe('getAvailableGenerators', () => {
+    it('returns list of available generators', () => {
+      const generators = NextJsDetector.getAvailableGenerators();
+
+      expect(generators).toContain('api-client');
+      expect(generators).toContain('env');
+      expect(generators).toContain('nextauth');
+      expect(generators).toContain('oauth-guide');
+    });
+  });
+});

package/tests/oauth-detector.test.js

@@ -0,0 +1,264 @@
+/**
+ * Tests for OAuth Detector
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+const OAuthDetector = require('../src/detectors/oauth-detector');
+
+describe('OAuthDetector', () => {
+  const mockProjectPath = '/test/project';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.existsSync.mockReturnValue(false);
+  });
+
+  describe('detect', () => {
+    it('returns hasOAuth false when no OAuth setup exists', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = OAuthDetector.detect(mockProjectPath);
+
+      expect(result.hasOAuth).toBe(false);
+      expect(result.oauthType).toBeNull();
+      expect(result.configPath).toBeNull();
+      expect(result.providers).toEqual([]);
+    });
+
+    describe('NextAuth.js detection', () => {
+      it('detects App Router NextAuth config (TypeScript)', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'app/api/auth/[...nextauth]/route.ts')
+        );
+        fs.readFileSync.mockReturnValue('GoogleProvider({})');
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.hasOAuth).toBe(true);
+        expect(result.oauthType).toBe('nextauth');
+        expect(result.configPath).toBe('app/api/auth/[...nextauth]/route.ts');
+      });
+
+      it('detects App Router NextAuth config (JavaScript)', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'app/api/auth/[...nextauth]/route.js')
+        );
+        fs.readFileSync.mockReturnValue('export default');
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.hasOAuth).toBe(true);
+        expect(result.oauthType).toBe('nextauth');
+        expect(result.configPath).toBe('app/api/auth/[...nextauth]/route.js');
+      });
+
+      it('detects Pages Router NextAuth config', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'pages/api/auth/[...nextauth].ts')
+        );
+        fs.readFileSync.mockReturnValue('export default NextAuth');
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.hasOAuth).toBe(true);
+        expect(result.oauthType).toBe('nextauth');
+        expect(result.configPath).toBe('pages/api/auth/[...nextauth].ts');
+      });
+
+      it('detects src/app NextAuth config', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'src/app/api/auth/[...nextauth]/route.ts')
+        );
+        fs.readFileSync.mockReturnValue('NextAuth');
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.hasOAuth).toBe(true);
+        expect(result.configPath).toBe('src/app/api/auth/[...nextauth]/route.ts');
+      });
+    });
+
+    describe('provider detection', () => {
+      it('detects Google provider', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'app/api/auth/[...nextauth]/route.ts')
+        );
+        fs.readFileSync.mockReturnValue('GoogleProvider({ clientId: "" })');
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.providers).toContain('google');
+      });
+
+      it('detects Microsoft/Azure provider', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'app/api/auth/[...nextauth]/route.ts')
+        );
+        fs.readFileSync.mockReturnValue('AzureADProvider({ clientId: "" })');
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.providers).toContain('microsoft');
+      });
+
+      it('detects GitHub provider', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'app/api/auth/[...nextauth]/route.ts')
+        );
+        fs.readFileSync.mockReturnValue('GitHubProvider({ clientId: "" })');
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.providers).toContain('github');
+      });
+
+      it('detects multiple providers', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'app/api/auth/[...nextauth]/route.ts')
+        );
+        fs.readFileSync.mockReturnValue(`
+          GoogleProvider({}),
+          AzureADProvider({}),
+          GitHubProvider({})
+        `);
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.providers).toContain('google');
+        expect(result.providers).toContain('microsoft');
+        expect(result.providers).toContain('github');
+      });
+
+      it('detects provider by keyword (lowercase)', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'app/api/auth/[...nextauth]/route.ts')
+        );
+        fs.readFileSync.mockReturnValue('providers: [google, azure, github]');
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.providers).toContain('google');
+        expect(result.providers).toContain('microsoft');
+        expect(result.providers).toContain('github');
+      });
+    });
+
+    describe('environment variable detection', () => {
+      it('detects OAuth env vars in .env.local', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, '.env.local')
+        );
+        fs.readFileSync.mockReturnValue('NEXTAUTH_SECRET=secret123');
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.hasEnvVars).toBe(true);
+      });
+
+      it('detects OAuth env vars in .env', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, '.env')
+        );
+        fs.readFileSync.mockReturnValue('GOOGLE_CLIENT_ID=abc123');
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.hasEnvVars).toBe(true);
+      });
+
+      it('detects various OAuth env var names', () => {
+        const oauthVars = [
+          'NEXTAUTH_URL',
+          'NEXTAUTH_SECRET',
+          'GOOGLE_CLIENT_ID',
+          'GOOGLE_CLIENT_SECRET',
+          'MICROSOFT_CLIENT_ID',
+          'GITHUB_CLIENT_ID',
+          'GOOGLE_OAUTH_CLIENT_ID',
+        ];
+
+        for (const varName of oauthVars) {
+          fs.existsSync.mockImplementation((p) =>
+            p === path.join(mockProjectPath, '.env.local')
+          );
+          fs.readFileSync.mockReturnValue(`${varName}=value`);
+
+          const result = OAuthDetector.detect(mockProjectPath);
+
+          expect(result.hasEnvVars).toBe(true);
+        }
+      });
+    });
+
+    describe('package.json detection', () => {
+      it('detects next-auth in dependencies', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'package.json')
+        );
+        fs.readFileSync.mockReturnValue(JSON.stringify({
+          dependencies: { 'next-auth': '^4.0.0' },
+        }));
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.hasOAuth).toBe(true);
+        expect(result.oauthType).toBe('nextauth');
+      });
+
+      it('detects next-auth in devDependencies', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'package.json')
+        );
+        fs.readFileSync.mockReturnValue(JSON.stringify({
+          devDependencies: { 'next-auth': '^4.0.0' },
+        }));
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.hasOAuth).toBe(true);
+      });
+
+      it('handles package.json read errors', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'package.json')
+        );
+        fs.readFileSync.mockImplementation(() => {
+          throw new Error('Read failed');
+        });
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.hasOAuth).toBe(false);
+      });
+
+      it('handles invalid JSON in package.json', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'package.json')
+        );
+        fs.readFileSync.mockReturnValue('invalid json');
+
+        const result = OAuthDetector.detect(mockProjectPath);
+
+        expect(result.hasOAuth).toBe(false);
+      });
+    });
+
+    it('handles config file read errors gracefully', () => {
+      fs.existsSync.mockImplementation((p) =>
+        p === path.join(mockProjectPath, 'app/api/auth/[...nextauth]/route.ts')
+      );
+      fs.readFileSync.mockImplementation(() => {
+        throw new Error('Read failed');
+      });
+
+      const result = OAuthDetector.detect(mockProjectPath);
+
+      expect(result.hasOAuth).toBe(true);
+      expect(result.providers).toEqual([]);
+    });
+  });
+});