feat(upgrade): added running upgrade.yml tasks

Author: Murat

src/__tests__/unit/tasks/buildGradleTask.spec.ts

@@ -469,6 +469,51 @@ buildscript {
         test2;
         test3;`);
   });
+  it('should append in non existing deep path correctly', async () => {
+    let content = `
+buildscript {
+    ext {
+        debug {
+            test1;
+            test3;
+        }
+    }
+    random {
+        release {
+            test1;
+            test3;
+        }
+    }
+}
+`;
+    const task: BuildGradleTaskType = {
+      type: 'build_gradle',
+      actions: [
+        {
+          block: 'buildscript.ext.release',
+          append: 'test2;',
+        },
+      ],
+    };
+
+    content = await buildGradleTask({
+      configPath: 'path/to/config',
+      task: task,
+      content,
+      packageName: 'test-package',
+    });
+    expect(content).toContain(`
+    ext {
+        debug {
+            test1;
+            test3;
+        }
+    
+        release {
+            test2;
+        }
+    }`);
+  });
   it('should skip if condition not met', async () => {
     let content = `
 buildscript {

src/__tests__/unit/upgrade.spec.ts

@@ -14,6 +14,10 @@ const mockRestoreBackupFiles = jest.spyOn(
   require('../../utils/upgrade/restoreBackupFiles'),
   'restoreBackupFiles'
 );
+const mockRunUpgradeTasks = jest.spyOn(
+  require('../../utils/upgrade/runUpgradeTasks'),
+  'runUpgradeTasks'
+);
 
 import { Constants } from '../../constants';
 import { upgrade } from '../../upgrade';
@@ -50,6 +54,45 @@ describe('upgrade', () => {
       expect.stringContaining('skipping import from old project')
     );
   });
+  it('should execute upgrade.yml', async () => {
+    mockPrompter.text.mockImplementationOnce(() => '');
+    mockRunUpgradeTasks.mockResolvedValueOnce({
+      didRun: true,
+      completedTaskCount: 1,
+    });
+    mockPrompter.log.success.mockClear();
+
+    await upgrade();
+
+    expect(mockPrompter.log.success).toHaveBeenCalledWith(
+      expect.stringContaining('task(s) successfully')
+    );
+  });
+  it('should handle upgrade.yml execution error', async () => {
+    mockPrompter.text.mockImplementationOnce(() => '');
+    mockRunUpgradeTasks.mockRejectedValueOnce(new Error('test'));
+    mockPrompter.log.warning.mockClear();
+
+    await upgrade();
+
+    expect(mockPrompter.log.warning).toHaveBeenCalledWith(
+      expect.stringContaining('test')
+    );
+  });
+  it('should handle upgrade.yml failed tasks', async () => {
+    mockPrompter.text.mockImplementationOnce(() => '');
+    mockRunUpgradeTasks.mockResolvedValueOnce({
+      didRun: true,
+      failedTaskCount: 1,
+    });
+    mockPrompter.log.warning.mockClear();
+
+    await upgrade();
+
+    expect(mockPrompter.log.warning).toHaveBeenCalledWith(
+      expect.stringContaining('task(s) - please complete upgrade manually')
+    );
+  });
   it('should not run tasks when lock does not exist', async () => {
     const spinner = mockPrompter.spinner();
     spinner.stop.mockReset();

src/__tests__/unit/utils/upgrade/runUpgradeTasks.spec.ts

@@ -0,0 +1,92 @@
+require('../../../mocks/mockAll');
+const mockRunTask = jest.spyOn(require('../../../../utils/runTask'), 'runTask');
+
+import path from 'path';
+import { getProjectPath } from '../../../../utils/getProjectPath';
+import { runUpgradeTasks } from '../../../../utils/upgrade/runUpgradeTasks';
+import { mockFs } from '../../../mocks/mockFs';
+
+describe('runUpgradeTasks', () => {
+  afterEach(() => {
+    mockRunTask.mockReset();
+  });
+  it('should execute upgrade.yml tasks', async () => {
+    mockRunTask.mockResolvedValueOnce(undefined);
+    mockFs.writeFileSync(
+      path.join(getProjectPath(), '.upgrade/upgrade.yml'),
+      `
+env:
+  value: true
+tasks:
+  - type: app_delegate
+    label: AppDelegate.mm modification
+    actions:
+      - append: test`
+    );
+
+    const result = await runUpgradeTasks();
+
+    expect(result.didRun).toBeTruthy();
+    expect(mockRunTask).toHaveBeenCalledWith({
+      configPath: path.join(getProjectPath(), '.upgrade/upgrade.yml'),
+      packageName: 'upgrade.yml',
+      task: {
+        type: 'app_delegate',
+        label: 'AppDelegate.mm modification',
+        actions: [{ append: 'test' }],
+      },
+    });
+  });
+  it('should not execute when tasks does not meet condition', async () => {
+    mockRunTask.mockResolvedValueOnce(undefined);
+    mockFs.writeFileSync(
+      path.join(getProjectPath(), '.upgrade/upgrade.yml'),
+      `
+env:
+  value: true
+tasks:
+  - type: app_delegate
+    when:
+      value: false
+    actions:
+      - append: test`
+    );
+
+    const result = await runUpgradeTasks();
+
+    expect(result.didRun).toBeTruthy();
+    expect(mockRunTask).not.toHaveBeenCalled();
+  });
+  it('should handle not finding upgrade.yml', async () => {
+    const result = await runUpgradeTasks();
+
+    expect(result.didRun).toBeFalsy();
+  });
+  it('should handle invalid upgrade.yml', async () => {
+    mockFs.writeFileSync(
+      path.join(getProjectPath(), '.upgrade/upgrade.yml'),
+      'random'
+    );
+    const result = await runUpgradeTasks();
+
+    expect(result.didRun).toBeFalsy();
+  });
+  it('should handle failed tasks', async () => {
+    mockRunTask.mockRejectedValueOnce(new Error('random'));
+    mockFs.writeFileSync(
+      path.join(getProjectPath(), '.upgrade/upgrade.yml'),
+      `
+tasks:
+  - type: app_delegate
+    actions:
+      - append: test`
+    );
+
+    const result = await runUpgradeTasks();
+
+    expect(result.didRun).toBeTruthy();
+    if (result.didRun) {
+      expect(result.failedTaskCount).toBe(1);
+    }
+  });
+});

src/constants.ts

@@ -2,6 +2,7 @@ export const Constants = {
   CURRENT_LOCK_VERSION: 1,
   LOCK_FILE_NAME: 'integrate-lock.json',
   UPGRADE_FOLDER_NAME: '.upgrade',
+  UPGRADE_CONFIG_FILE_NAME: 'upgrade.yml',
   GIT_FOLDER_NAME: '.git',
   PACKAGE_JSON_FILE_NAME: 'package.json',
   APP_DELEGATE_FILE_NAME: 'AppDelegate.mm',

src/getInfo.ts

@@ -78,8 +78,9 @@ export async function getInfo(packageName: string): Promise<void> {
 
   let config: IntegrationConfig | undefined;
   if (localPathExists && localConfigPath) {
-    config = parseConfig(localConfigPath);
-  } else if (remoteFileContent) config = parseConfigString(remoteFileContent);
+    config = parseConfig(localConfigPath) as IntegrationConfig;
+  } else if (remoteFileContent)
+    config = parseConfigString(remoteFileContent) as IntegrationConfig;
   if (config) {
     const _config = config;
     logSuccess(

src/integrate.ts

@@ -94,7 +94,7 @@ export async function integrate(packageName?: string): Promise<void> {
       else {
         let config: IntegrationConfig;
         try {
-          config = parseConfig(configPath);
+          config = parseConfig(configPath) as IntegrationConfig;
         } catch (e) {
           logError(
             color.bold(color.bgRed(' error ')) +

src/schema/integrate.schema.json

@@ -576,13 +576,6 @@
                 }
             ]
         },
-        "MultiselectOptionValue": {
-            "type": [
-                "string",
-                "number",
-                "boolean"
-            ]
-        },
         "NotificationServiceTaskType": {
             "additionalProperties": false,
             "properties": {
@@ -661,6 +654,16 @@
             ],
             "type": "object"
         },
+        "ObjectModifierStrategy": {
+            "enum": [
+                "append",
+                "assign",
+                "merge",
+                "merge_concat",
+                "merge_distinct"
+            ],
+            "type": "string"
+        },
         "ObjectModifierType": {
             "additionalProperties": false,
             "properties": {
@@ -672,14 +675,7 @@
                     "type": "object"
                 },
                 "strategy": {
-                    "enum": [
-                        "append",
-                        "assign",
-                        "merge",
-                        "merge_concat",
-                        "merge_distinct"
-                    ],
-                    "type": "string"
+                    "$ref": "#/definitions/ObjectModifierStrategy"
                 },
                 "when": {
                     "$ref": "#/definitions/AnyObject"
@@ -690,6 +686,13 @@
             ],
             "type": "object"
         },
+        "OptionValue": {
+            "type": [
+                "string",
+                "number",
+                "boolean"
+            ]
+        },
         "PlistTaskType": {
             "additionalProperties": false,
             "properties": {
@@ -949,7 +952,7 @@
                     "properties": {
                         "initialValues": {
                             "items": {
-                                "$ref": "#/definitions/MultiselectOptionValue"
+                                "$ref": "#/definitions/OptionValue"
                             },
                             "type": "array"
                         },
@@ -967,7 +970,7 @@
                                         "type": "string"
                                     },
                                     "value": {
-                                        "$ref": "#/definitions/MultiselectOptionValue"
+                                        "$ref": "#/definitions/OptionValue"
                                     }
                                 },
                                 "required": [