ios-app-review-plugin 1.0.0

package/tests/analyzers/asc-iap.test.ts

@@ -0,0 +1,228 @@
+import { ASCIAPAnalyzer } from '../../src/analyzers/asc-iap';
+import type { XcodeProject } from '../../src/types/index';
+
+// Mock the ASC module
+jest.mock('../../src/asc/index', () => ({
+  hasCredentials: jest.fn(),
+  getAppByBundleId: jest.fn(),
+  validateAllIAPs: jest.fn(),
+  getIAPStateDescription: jest.fn().mockReturnValue('Missing Metadata'),
+  isASCError: jest.fn().mockReturnValue(false),
+}));
+
+const mocks = jest.requireMock('../../src/asc/index');
+
+const mockProject: XcodeProject = {
+  path: '/test/TestApp.xcodeproj',
+  name: 'TestApp',
+  targets: [
+    {
+      name: 'TestApp',
+      type: 'application',
+      bundleIdentifier: 'com.test.app',
+      sourceFiles: [],
+    },
+  ],
+  configurations: ['Debug', 'Release'],
+};
+
+describe('ASCIAPAnalyzer', () => {
+  let analyzer: ASCIAPAnalyzer;
+
+  beforeEach(() => {
+    analyzer = new ASCIAPAnalyzer();
+    jest.clearAllMocks();
+  });
+
+  describe('analyze', () => {
+    it('should return info issue when credentials are not configured', async () => {
+      mocks.hasCredentials.mockReturnValue(false);
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.passed).toBe(true);
+      expect(result.issues).toHaveLength(1);
+      expect(result.issues[0]?.id).toBe('asc-credentials-not-configured');
+      expect(result.issues[0]?.severity).toBe('info');
+    });
+
+    it('should return warning when no bundle ID found', async () => {
+      mocks.hasCredentials.mockReturnValue(true);
+
+      const projectWithoutBundleId: XcodeProject = {
+        ...mockProject,
+        targets: [{ name: 'TestApp', type: 'application', sourceFiles: [] }],
+      };
+
+      const result = await analyzer.analyze(projectWithoutBundleId, { basePath: '/test' });
+
+      expect(result.passed).toBe(true);
+      expect(result.issues[0]?.id).toBe('asc-no-bundle-id');
+    });
+
+    it('should return info when no IAPs configured', async () => {
+      mocks.hasCredentials.mockReturnValue(true);
+      mocks.getAppByBundleId.mockResolvedValue({ id: 'app-1', type: 'apps' });
+      mocks.validateAllIAPs.mockResolvedValue([]);
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.issues.some((i) => i.id === 'asc-no-iaps')).toBe(true);
+    });
+
+    it('should detect IAP with missing metadata', async () => {
+      mocks.hasCredentials.mockReturnValue(true);
+      mocks.getAppByBundleId.mockResolvedValue({ id: 'app-1', type: 'apps' });
+      mocks.validateAllIAPs.mockResolvedValue([
+        {
+          iap: {
+            id: 'iap-1',
+            type: 'inAppPurchases',
+            attributes: {
+              name: 'Premium Feature',
+              productId: 'com.test.premium',
+              inAppPurchaseType: 'NON_CONSUMABLE',
+              state: 'MISSING_METADATA',
+            },
+          },
+          localizations: [],
+          reviewScreenshot: undefined,
+          isReadyForSubmission: false,
+        },
+      ]);
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.passed).toBe(false);
+      expect(result.issues.some((i) => i.id === 'asc-iap-missing-metadata')).toBe(true);
+      expect(result.issues.some((i) => i.id === 'asc-iap-no-localizations')).toBe(true);
+      expect(result.issues.some((i) => i.id === 'asc-iap-missing-screenshot')).toBe(true);
+    });
+
+    it('should detect IAP with missing review screenshot', async () => {
+      mocks.hasCredentials.mockReturnValue(true);
+      mocks.getAppByBundleId.mockResolvedValue({ id: 'app-1', type: 'apps' });
+      mocks.validateAllIAPs.mockResolvedValue([
+        {
+          iap: {
+            id: 'iap-1',
+            type: 'inAppPurchases',
+            attributes: {
+              name: 'Premium Feature',
+              productId: 'com.test.premium',
+              inAppPurchaseType: 'CONSUMABLE',
+              state: 'READY_TO_SUBMIT',
+            },
+          },
+          localizations: [
+            {
+              id: 'loc-1',
+              type: 'inAppPurchaseLocalizations',
+              attributes: { locale: 'en-US', name: 'Premium', description: 'Unlock premium' },
+            },
+          ],
+          reviewScreenshot: undefined,
+          isReadyForSubmission: false,
+        },
+      ]);
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.issues.some((i) => i.id === 'asc-iap-missing-screenshot')).toBe(true);
+    });
+
+    it('should pass with fully configured IAP', async () => {
+      mocks.hasCredentials.mockReturnValue(true);
+      mocks.getAppByBundleId.mockResolvedValue({ id: 'app-1', type: 'apps' });
+      mocks.validateAllIAPs.mockResolvedValue([
+        {
+          iap: {
+            id: 'iap-1',
+            type: 'inAppPurchases',
+            attributes: {
+              name: 'Premium Feature',
+              productId: 'com.test.premium',
+              inAppPurchaseType: 'NON_CONSUMABLE',
+              state: 'READY_TO_SUBMIT',
+            },
+          },
+          localizations: [
+            {
+              id: 'loc-1',
+              type: 'inAppPurchaseLocalizations',
+              attributes: { locale: 'en-US', name: 'Premium', description: 'Unlock premium features' },
+            },
+          ],
+          reviewScreenshot: {
+            id: 'ss-1',
+            type: 'inAppPurchaseAppStoreReviewScreenshots',
+            attributes: { fileName: 'screenshot.png', assetDeliveryState: { state: 'COMPLETE' } },
+          },
+          isReadyForSubmission: true,
+        },
+      ]);
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.passed).toBe(true);
+    });
+  });
+
+  describe('validateByBundleId', () => {
+    it('should return error when credentials not configured', async () => {
+      mocks.hasCredentials.mockReturnValue(false);
+
+      const result = await analyzer.validateByBundleId('com.test.app');
+
+      expect(result.passed).toBe(false);
+      expect(result.issues[0]?.severity).toBe('error');
+    });
+
+    it('should validate IAPs for given bundle ID', async () => {
+      mocks.hasCredentials.mockReturnValue(true);
+      mocks.getAppByBundleId.mockResolvedValue({ id: 'app-1', type: 'apps' });
+      mocks.validateAllIAPs.mockResolvedValue([]);
+
+      const result = await analyzer.validateByBundleId('com.test.app');
+
+      expect(result.analyzer).toBe('ASC IAP Analyzer');
+      expect(result.issues.some((i) => i.id === 'asc-no-iaps')).toBe(true);
+    });
+
+    it('should detect rejected IAP', async () => {
+      mocks.hasCredentials.mockReturnValue(true);
+      mocks.getAppByBundleId.mockResolvedValue({ id: 'app-1', type: 'apps' });
+      mocks.validateAllIAPs.mockResolvedValue([
+        {
+          iap: {
+            id: 'iap-1',
+            type: 'inAppPurchases',
+            attributes: {
+              name: 'Premium',
+              productId: 'com.test.premium',
+              inAppPurchaseType: 'NON_CONSUMABLE',
+              state: 'REJECTED',
+            },
+          },
+          localizations: [
+            {
+              id: 'loc-1',
+              type: 'inAppPurchaseLocalizations',
+              attributes: { locale: 'en-US', name: 'Premium', description: 'Desc' },
+            },
+          ],
+          reviewScreenshot: {
+            id: 'ss-1',
+            type: 'inAppPurchaseAppStoreReviewScreenshots',
+            attributes: { fileName: 'screenshot.png', assetDeliveryState: { state: 'COMPLETE' } },
+          },
+          isReadyForSubmission: false,
+        },
+      ]);
+
+      const result = await analyzer.validateByBundleId('com.test.app');
+
+      expect(result.issues.some((i) => i.id === 'asc-iap-rejected')).toBe(true);
+    });
+  });
+});

package/tests/analyzers/asc-metadata.test.ts

@@ -0,0 +1,210 @@
+import { ASCMetadataAnalyzer } from '../../src/analyzers/asc-metadata';
+import type { XcodeProject } from '../../src/types/index';
+
+// Mock the ASC module
+jest.mock('../../src/asc/index', () => ({
+  hasCredentials: jest.fn(),
+  getAppWithInfo: jest.fn(),
+  isASCError: jest.fn().mockReturnValue(false),
+}));
+
+const mockHasCredentials = jest.requireMock('../../src/asc/index').hasCredentials as jest.Mock;
+const mockGetAppWithInfo = jest.requireMock('../../src/asc/index').getAppWithInfo as jest.Mock;
+
+const mockProject: XcodeProject = {
+  path: '/test/TestApp.xcodeproj',
+  name: 'TestApp',
+  targets: [
+    {
+      name: 'TestApp',
+      type: 'application',
+      bundleIdentifier: 'com.test.app',
+      sourceFiles: [],
+    },
+  ],
+  configurations: ['Debug', 'Release'],
+};
+
+describe('ASCMetadataAnalyzer', () => {
+  let analyzer: ASCMetadataAnalyzer;
+
+  beforeEach(() => {
+    analyzer = new ASCMetadataAnalyzer();
+    jest.clearAllMocks();
+  });
+
+  describe('analyze', () => {
+    it('should return info issue when credentials are not configured', async () => {
+      mockHasCredentials.mockReturnValue(false);
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.passed).toBe(true);
+      expect(result.issues).toHaveLength(1);
+      expect(result.issues[0]?.id).toBe('asc-credentials-not-configured');
+      expect(result.issues[0]?.severity).toBe('info');
+    });
+
+    it('should return warning when no bundle ID found', async () => {
+      mockHasCredentials.mockReturnValue(true);
+
+      const projectWithoutBundleId: XcodeProject = {
+        ...mockProject,
+        targets: [{ name: 'TestApp', type: 'application', sourceFiles: [] }],
+      };
+
+      const result = await analyzer.analyze(projectWithoutBundleId, { basePath: '/test' });
+
+      expect(result.passed).toBe(true);
+      expect(result.issues).toHaveLength(1);
+      expect(result.issues[0]?.id).toBe('asc-no-bundle-id');
+      expect(result.issues[0]?.severity).toBe('warning');
+    });
+
+    it('should validate metadata when credentials are configured', async () => {
+      mockHasCredentials.mockReturnValue(true);
+      mockGetAppWithInfo.mockResolvedValue({
+        app: {
+          id: '123',
+          type: 'apps',
+          attributes: { name: 'TestApp', bundleId: 'com.test.app', primaryLocale: 'en-US' },
+        },
+        localizations: [
+          {
+            id: 'loc-1',
+            type: 'appInfoLocalizations',
+            attributes: {
+              locale: 'en-US',
+              name: 'TestApp',
+              subtitle: 'A great app',
+              privacyPolicyUrl: 'https://example.com/privacy',
+            },
+          },
+        ],
+      });
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.passed).toBe(true);
+    });
+
+    it('should detect app name too long', async () => {
+      mockHasCredentials.mockReturnValue(true);
+      mockGetAppWithInfo.mockResolvedValue({
+        app: {
+          id: '123',
+          type: 'apps',
+          attributes: { name: 'TestApp', bundleId: 'com.test.app', primaryLocale: 'en-US' },
+        },
+        localizations: [
+          {
+            id: 'loc-1',
+            type: 'appInfoLocalizations',
+            attributes: {
+              locale: 'en-US',
+              name: 'This App Name Is Way Too Long For The App Store Limit',
+              subtitle: null,
+              privacyPolicyUrl: 'https://example.com/privacy',
+            },
+          },
+        ],
+      });
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.issues.some((i) => i.id === 'asc-name-too-long')).toBe(true);
+    });
+
+    it('should detect missing privacy policy URL', async () => {
+      mockHasCredentials.mockReturnValue(true);
+      mockGetAppWithInfo.mockResolvedValue({
+        app: {
+          id: '123',
+          type: 'apps',
+          attributes: { name: 'TestApp', bundleId: 'com.test.app', primaryLocale: 'en-US' },
+        },
+        localizations: [
+          {
+            id: 'loc-1',
+            type: 'appInfoLocalizations',
+            attributes: {
+              locale: 'en-US',
+              name: 'TestApp',
+              subtitle: null,
+              privacyPolicyUrl: null,
+            },
+          },
+        ],
+      });
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.issues.some((i) => i.id === 'asc-missing-privacy-policy')).toBe(true);
+    });
+
+    it('should detect placeholder text', async () => {
+      mockHasCredentials.mockReturnValue(true);
+      mockGetAppWithInfo.mockResolvedValue({
+        app: {
+          id: '123',
+          type: 'apps',
+          attributes: { name: 'TestApp', bundleId: 'com.test.app', primaryLocale: 'en-US' },
+        },
+        localizations: [
+          {
+            id: 'loc-1',
+            type: 'appInfoLocalizations',
+            attributes: {
+              locale: 'en-US',
+              name: 'Lorem ipsum dolor sit amet',
+              subtitle: null,
+              privacyPolicyUrl: 'https://example.com/privacy',
+            },
+          },
+        ],
+      });
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.issues.some((i) => i.id === 'asc-name-placeholder')).toBe(true);
+    });
+  });
+
+  describe('validateByBundleId', () => {
+    it('should return error when credentials not configured', async () => {
+      mockHasCredentials.mockReturnValue(false);
+
+      const result = await analyzer.validateByBundleId('com.test.app');
+
+      expect(result.passed).toBe(false);
+      expect(result.issues[0]?.severity).toBe('error');
+    });
+
+    it('should validate metadata for valid bundle ID', async () => {
+      mockHasCredentials.mockReturnValue(true);
+      mockGetAppWithInfo.mockResolvedValue({
+        app: {
+          id: '123',
+          type: 'apps',
+          attributes: { name: 'TestApp', bundleId: 'com.test.app', primaryLocale: 'en-US' },
+        },
+        localizations: [
+          {
+            id: 'loc-1',
+            type: 'appInfoLocalizations',
+            attributes: {
+              locale: 'en-US',
+              name: 'TestApp',
+              subtitle: null,
+              privacyPolicyUrl: 'https://example.com/privacy',
+            },
+          },
+        ],
+      });
+
+      const result = await analyzer.validateByBundleId('com.test.app');
+
+      expect(result.passed).toBe(true);
+    });
+  });
+});

package/tests/analyzers/asc-screenshots.test.ts

@@ -0,0 +1,135 @@
+import { ASCScreenshotAnalyzer } from '../../src/analyzers/asc-screenshots';
+import type { XcodeProject } from '../../src/types/index';
+
+// Mock the ASC module
+jest.mock('../../src/asc/index', () => ({
+  hasCredentials: jest.fn(),
+  getAppByBundleId: jest.fn(),
+  getEditableVersion: jest.fn(),
+  getVersionLocalizations: jest.fn(),
+  getScreenshotSetsWithScreenshots: jest.fn(),
+  REQUIRED_IPHONE_DISPLAY_TYPES: ['APP_IPHONE_65', 'APP_IPHONE_55'],
+  REQUIRED_IPAD_DISPLAY_TYPES: ['APP_IPAD_PRO_129'],
+  getDisplayTypeDescription: jest.fn((type: string) => type),
+  validateScreenshotSet: jest.fn().mockReturnValue({ hasProcessingErrors: false, issues: [] }),
+  isASCError: jest.fn().mockReturnValue(false),
+}));
+
+const mocks = jest.requireMock('../../src/asc/index');
+
+const mockProject: XcodeProject = {
+  path: '/test/TestApp.xcodeproj',
+  name: 'TestApp',
+  targets: [
+    {
+      name: 'TestApp',
+      type: 'application',
+      bundleIdentifier: 'com.test.app',
+      sourceFiles: [],
+    },
+  ],
+  configurations: ['Debug', 'Release'],
+};
+
+describe('ASCScreenshotAnalyzer', () => {
+  let analyzer: ASCScreenshotAnalyzer;
+
+  beforeEach(() => {
+    analyzer = new ASCScreenshotAnalyzer();
+    jest.clearAllMocks();
+  });
+
+  describe('analyze', () => {
+    it('should return info issue when credentials are not configured', async () => {
+      mocks.hasCredentials.mockReturnValue(false);
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.passed).toBe(true);
+      expect(result.issues).toHaveLength(1);
+      expect(result.issues[0]?.id).toBe('asc-credentials-not-configured');
+      expect(result.issues[0]?.severity).toBe('info');
+    });
+
+    it('should return warning when no bundle ID found', async () => {
+      mocks.hasCredentials.mockReturnValue(true);
+
+      const projectWithoutBundleId: XcodeProject = {
+        ...mockProject,
+        targets: [{ name: 'TestApp', type: 'application', sourceFiles: [] }],
+      };
+
+      const result = await analyzer.analyze(projectWithoutBundleId, { basePath: '/test' });
+
+      expect(result.passed).toBe(true);
+      expect(result.issues).toHaveLength(1);
+      expect(result.issues[0]?.id).toBe('asc-no-bundle-id');
+    });
+
+    it('should return info when no editable version found', async () => {
+      mocks.hasCredentials.mockReturnValue(true);
+      mocks.getAppByBundleId.mockResolvedValue({ id: 'app-1', type: 'apps' });
+      mocks.getEditableVersion.mockResolvedValue(null);
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      expect(result.issues.some((i: { id: string }) => i.id === 'asc-no-editable-version')).toBe(true);
+    });
+
+    it('should validate screenshots when version exists', async () => {
+      mocks.hasCredentials.mockReturnValue(true);
+      mocks.getAppByBundleId.mockResolvedValue({ id: 'app-1', type: 'apps' });
+      mocks.getEditableVersion.mockResolvedValue({
+        id: 'ver-1',
+        type: 'appStoreVersions',
+        attributes: { versionString: '1.0.0', appStoreState: 'PREPARE_FOR_SUBMISSION' },
+      });
+      mocks.getVersionLocalizations.mockResolvedValue([
+        {
+          id: 'loc-1',
+          type: 'appStoreVersionLocalizations',
+          attributes: { locale: 'en-US' },
+        },
+      ]);
+      mocks.getScreenshotSetsWithScreenshots.mockResolvedValue([
+        {
+          set: {
+            id: 'set-1',
+            type: 'appScreenshotSets',
+            attributes: { screenshotDisplayType: 'APP_IPHONE_65' },
+          },
+          screenshots: [
+            { id: 'ss-1', type: 'appScreenshots', attributes: { fileName: 'test.png', assetDeliveryState: { state: 'COMPLETE' } } },
+          ],
+        },
+      ]);
+
+      const result = await analyzer.analyze(mockProject, { basePath: '/test' });
+
+      // Should have some issues (missing some device sizes) but not error
+      expect(result.analyzer).toBe('ASC Screenshot Analyzer');
+    });
+  });
+
+  describe('validateByBundleId', () => {
+    it('should return error when credentials not configured', async () => {
+      mocks.hasCredentials.mockReturnValue(false);
+
+      const result = await analyzer.validateByBundleId('com.test.app');
+
+      expect(result.passed).toBe(false);
+      expect(result.issues[0]?.severity).toBe('error');
+    });
+
+    it('should validate screenshots for given bundle ID', async () => {
+      mocks.hasCredentials.mockReturnValue(true);
+      mocks.getAppByBundleId.mockResolvedValue({ id: 'app-1', type: 'apps' });
+      mocks.getEditableVersion.mockResolvedValue(null);
+
+      const result = await analyzer.validateByBundleId('com.test.app');
+
+      expect(result.analyzer).toBe('ASC Screenshot Analyzer');
+      expect(result.issues.some((i: { id: string }) => i.id === 'asc-no-editable-version')).toBe(true);
+    });
+  });
+});