'use strict';

/* eslint-disable no-unused-expressions */

const chai = require('chai');
const overrideEnv = require('process-utils/override-env');
const overrideArgv = require('process-utils/override-argv');
const runServerless = require('../../../utils/run-serverless');
const fixtures = require('../../../fixtures/programmatic');
const Serverless = require('../../../../lib/serverless');
const CLI = require('../../../../lib/classes/cli');
const resolveInput = require('../../../../lib/cli/resolve-input');
const Create = require('../../../../lib/plugins/create/create');
const ServerlessError = require('../../../../lib/serverless-error');
const getRequire = require('../../../../lib/utils/get-require');

const path = require('path');
const fsp = require('fs').promises;
const fse = require('fs-extra');
const mockRequire = require('mock-require');
const sinon = require('sinon');
const proxyquire = require('proxyquire');
const { installPlugin } = require('../../../utils/plugins');
const { getTmpDirPath } = require('../../../utils/fs');

chai.use(require('chai-as-promised'));
chai.use(require('sinon-chai'));

const expect = chai.expect;

class PromisePluginMock {
  constructor() {
    this.commands = {
      deploy: {
        usage: 'Deploy to the default infrastructure',
        lifecycleEvents: ['resources', 'functions'],
        options: {
          resource: {
            usage: 'The resource you want to deploy (e.g. --resource db)',
          },
          function: {
            usage: 'The function you want to deploy (e.g. --function create)',
          },
        },
        commands: {
          onpremises: {
            usage: 'Deploy to your On-Premises infrastructure',
            lifecycleEvents: ['resources', 'functions'],
            options: {
              resource: {
                usage: 'The resource you want to deploy (e.g. --resource db)',
              },
              function: {
                usage: 'The function you want to deploy (e.g. --function create)',
              },
            },
          },
          other: {
            usage: 'Deploy to other infrastructure',
            lifecycleEvents: ['resources', 'functions'],
          },
        },
      },
    };

    this.hooks = {
      'deploy:functions': async () => this.functions(),
      'before:deploy:onpremises:functions': async () => this.resources(),
    };

    // used to test if the function was executed correctly
    this.deployedFunctions = 0;
    this.deployedResources = 0;
  }

  async functions() {
    this.deployedFunctions += 1;
  }

  async resources() {
    this.deployedResources += 1;
  }
}

class SynchronousPluginMock {
  constructor() {
    this.commands = {
      deploy: {
        usage: 'Deploy to the default infrastructure',
        lifecycleEvents: ['resources', 'functions'],
        options: {
          resource: {
            usage: 'The resource you want to deploy (e.g. --resource db)',
            type: 'string',
          },
          function: {
            usage: 'The function you want to deploy (e.g. --function create)',
            type: 'string',
          },
        },
        commands: {
          onpremises: {
            usage: 'Deploy to your On-Premises infrastructure',
            lifecycleEvents: ['resources', 'functions'],
            options: {
              resource: {
                usage: 'The resource you want to deploy (e.g. --resource db)',
                type: 'string',
              },
              function: {
                usage: 'The function you want to deploy (e.g. --function create)',
                type: 'string',
              },
            },
          },
        },
      },
    };

    this.hooks = {
      'deploy:functions': async () => this.functions(),
      'before:deploy:onpremises:functions': async () => this.resources(),
    };

    // used to test if the function was executed correctly
    this.deployedFunctions = 0;
    this.deployedResources = 0;
  }

  functions() {
    this.deployedFunctions += 1;
  }

  resources() {
    this.deployedResources += 1;
  }
}

describe('PluginManager', () => {
  let pluginManager;
  let serverless;

  class ServicePluginMock1 {}

  class ServicePluginMock2 {}

  class EnterprisePluginMock {}

  const brokenPluginError = new Error('Broken plugin');
  class BrokenPluginMock {
    constructor() {
      throw brokenPluginError;
    }
  }

  class Provider1PluginMock {
    constructor() {
      this.provider = 'provider1';

      this.commands = {
        deploy: {
          lifecycleEvents: ['resources'],
        },
      };

      this.hooks = {
        'deploy:functions': async () => this.functions(),
      };

      // used to test if the function was executed correctly
      this.deployedFunctions = 0;
    }

    functions() {
      this.deployedFunctions += 1;
    }
  }

  class Provider2PluginMock {
    constructor() {
      this.provider = 'provider2';

      this.commands = {
        deploy: {
          lifecycleEvents: ['resources'],
        },
      };

      this.hooks = {
        'deploy:functions': async () => this.functions(),
      };

      // used to test if the function was executed correctly
      this.deployedFunctions = 0;
    }

    functions() {
      this.deployedFunctions += 1;
    }
  }

  class AliasPluginMock {
    constructor() {
      this.commands = {
        deploy: {
          usage: 'Deploy to the default infrastructure',
          lifecycleEvents: ['resources', 'functions'],
          options: {
            resource: {
              usage: 'The resource you want to deploy (e.g. --resource db)',
              type: 'string',
            },
            function: {
              usage: 'The function you want to deploy (e.g. --function create)',
              type: 'string',
            },
          },
          commands: {
            onpremises: {
              usage: 'Deploy to your On-Premises infrastructure',
              lifecycleEvents: ['resources', 'functions'],
              aliases: ['on:premise', 'premise'],
              options: {
                resource: {
                  usage: 'The resource you want to deploy (e.g. --resource db)',
                  type: 'string',
                },
                function: {
                  usage: 'The function you want to deploy (e.g. --function create)',
                  type: 'string',
                },
              },
            },
          },
        },
      };

      this.hooks = {
        'deploy:functions': async () => this.functions(),
        'before:deploy:onpremises:functions': async () => this.resources(),
      };

      // used to test if the function was executed correctly
      this.deployedFunctions = 0;
      this.deployedResources = 0;
    }

    functions() {
      this.deployedFunctions += 1;
    }

    resources() {
      this.deployedResources += 1;
    }
  }

  class EntrypointPluginMock {
    constructor() {
      this.commands = {
        myep: {
          type: 'entrypoint',
          lifecycleEvents: ['initialize', 'finalize'],
          commands: {
            // EP, not public command because its parent is decalred as EP
            mysubep: {
              lifecycleEvents: ['initialize', 'finalize'],
            },
            // EP that will spawn sub lifecycles
            spawnep: {
              lifecycleEvents: ['event1', 'event2'],
            },
          },
        },
        // public command
        mycmd: {
          lifecycleEvents: ['run'],
          commands: {
            // public subcommand
            mysubcmd: {
              lifecycleEvents: ['initialize', 'finalize'],
            },
            // command that will spawn sub lifecycles
            spawncmd: {
              lifecycleEvents: ['event1', 'event2'],
            },
            spawnep: {
              type: 'entrypoint',
              lifecycleEvents: ['event1', 'event2'],
            },
          },
        },
      };

      this.hooks = {
        'myep:initialize': async () => this.initialize(),
        'myep:finalize': async () => this.finalize(),
        'myep:mysubep:initialize': async () => this.subEPInitialize(),
        'myep:mysubep:finalize': async () => this.subEPFinalize(),
        'mycmd:mysubcmd:initialize': async () => this.subInitialize(),
        'mycmd:mysubcmd:finalize': async () => this.subFinalize(),
        'mycmd:run': async () => this.run(),
        // Event1 spawns mysubcmd, then myep
        // Event2 spawns mycmd, then mysubep
        'myep:spawnep:event1': async () =>
          pluginManager.spawn(['mycmd', 'mysubcmd']).then(() => pluginManager.spawn(['myep'])),
        'myep:spawnep:event2': async () =>
          pluginManager.spawn(['mycmd']).then(() => pluginManager.spawn(['myep', 'mysubep'])),
        'mycmd:spawncmd:event1': async () =>
          pluginManager.spawn(['mycmd', 'mysubcmd']).then(() => pluginManager.spawn(['myep'])),
        'mycmd:spawncmd:event2': async () =>
          pluginManager.spawn(['mycmd']).then(() => pluginManager.spawn(['myep', 'mysubep'])),
      };

      this.callResult = '';
    }

    initialize() {
      this.callResult += '>initialize';
    }

    finalize() {
      this.callResult += '>finalize';
    }

    subEPInitialize() {
      this.callResult += '>subEPInitialize';
    }

    subEPFinalize() {
      this.callResult += '>subEPFinalize';
    }

    subInitialize() {
      this.callResult += '>subInitialize';
    }

    subFinalize() {
      this.callResult += '>subFinalize';
    }

    run() {
      this.callResult += '>run';
    }
  }

  class ContainerPluginMock {
    constructor() {
      this.commands = {
        // not a public command because its declared as a Container
        mycontainer: {
          type: 'container',
          commands: {
            // public command because its children of a container
            mysubcmd: {
              lifecycleEvents: ['event1', 'event2'],
            },
          },
        },
      };

      this.hooks = {
        'mycontainer:mysubcmd:event1': async () => this.eventOne(),
        'mycontainer:mysubcmd:event2': async () => this.eventTwo(),
      };

      this.callResult = '';
    }

    eventOne() {
      this.callResult += '>mysubcmdEvent1';
    }

    eventTwo() {
      this.callResult += '>mysubcmdEvent2';
    }
  }

  class DeprecatedLifecycleEventsPluginMock {
    constructor() {
      this.hooks = {
        'deprecated:deprecated': async () => this.deprecated(), // NOTE: we assume that this is deprecated
        'untouched:untouched': async () => this.untouched(),
      };
    }

    deprecated() {
      return;
    }

    untouched() {
      return;
    }
  }

  const resolveStub = (directory, pluginPath) => {
    switch (pluginPath) {
      case 'BrokenPluginMock':
      case 'ServicePluginMock1':
      case 'ServicePluginMock2':
        return pluginPath;
      case './RelativePath/ServicePluginMock2':
        return `${serviceDir}/RelativePath/ServicePluginMock2`;
      default:
        return getRequire(directory).resolve(pluginPath);
    }
  };

  let restoreEnv;
  let serviceDir;
  const PluginManager = proxyquire('../../../../lib/classes/plugin-manager', {
    '../utils/get-require': (directory) => {
      const resultRequire = require('module').createRequire(path.resolve(directory, 'req'));
      resultRequire.resolve = (pluginPath) => resolveStub(directory, pluginPath);
      return resultRequire;
    },
  });

  beforeEach(() => {
    ({ restoreEnv } = overrideEnv({ whitelist: ['APPDATA', 'PATH'] }));
    serverless = new Serverless({ commands: [], options: {} });
    serverless.cli = new CLI();
    serverless.processedInput = { commands: ['print'], options: {} };
    pluginManager = new PluginManager(serverless);
    serviceDir = pluginManager.serverless.serviceDir = 'foo';
  });

  afterEach(() => restoreEnv());

  describe('#constructor()', () => {
    it('should set the serverless instance', () => {
      expect(pluginManager.serverless).to.deep.equal(serverless);
    });

    it('should create an empty cliOptions object', () => {
      expect(pluginManager.cliOptions).to.deep.equal({});
    });

    it('should create an empty cliCommands array', () => {
      expect(pluginManager.cliCommands.length).to.equal(0);
    });

    it('should create an empty plugins array', () => {
      expect(pluginManager.plugins.length).to.equal(0);
    });

    it('should create an empty commands object', () => {
      expect(pluginManager.commands).to.deep.equal({});
    });
  });

  describe('#setCliOptions()', () => {
    it('should set the cliOptions object', () => {
      const options = { foo: 'bar' };
      pluginManager.setCliOptions(options);

      expect(pluginManager.cliOptions).to.deep.equal(options);
    });
  });

  describe('#setCliCommands()', () => {
    it('should set the cliCommands array', () => {
      const commands = ['foo', 'bar'];
      pluginManager.setCliCommands(commands);

      expect(pluginManager.cliCommands).to.equal(commands);
    });
  });

  describe('#convertShortcutsIntoOptions()', () => {
    it('should convert shortcuts into options when a one level deep command matches', () => {
      const cliOptionsMock = { r: 'eu-central-1', region: 'us-east-1' };
      const cliCommandsMock = ['deploy']; // command with one level deepness
      const commandMock = {
        options: {
          region: {
            shortcut: 'r',
          },
        },
      };
      pluginManager.setCliCommands(cliCommandsMock);
      pluginManager.setCliOptions(cliOptionsMock);

      pluginManager.convertShortcutsIntoOptions(commandMock);

      expect(pluginManager.cliOptions.region).to.equal(cliOptionsMock.r);
    });

    it('should not convert shortcuts into options when the shortcut is not given', () => {
      const cliOptionsMock = { r: 'eu-central-1', region: 'us-east-1' };
      const cliCommandsMock = ['deploy'];
      const commandMock = {
        options: {
          region: {},
        },
      };
      pluginManager.setCliCommands(cliCommandsMock);
      pluginManager.setCliOptions(cliOptionsMock);

      pluginManager.convertShortcutsIntoOptions(commandMock);

      expect(pluginManager.cliOptions.region).to.equal(cliOptionsMock.region);
    });
  });

  describe('#addPlugin()', () => {
    it('should add a plugin instance to the plugins array', () => {
      pluginManager.addPlugin(SynchronousPluginMock);

      expect(pluginManager.plugins[0]).to.be.instanceof(SynchronousPluginMock);
    });

    it('should load two plugins that happen to have the same class name', () => {
      function getFirst() {
        return class PluginMock {};
      }

      function getSecond() {
        return class PluginMock {};
      }

      const first = getFirst();
      const second = getSecond();

      pluginManager.addPlugin(first);
      pluginManager.addPlugin(second);

      expect(pluginManager.plugins[0]).to.be.instanceof(first);
      expect(pluginManager.plugins[1]).to.be.instanceof(second);
      expect(pluginManager.plugins.length).to.equal(2);
    });

    it('should load the plugin commands', () => {
      pluginManager.addPlugin(SynchronousPluginMock);

      expect(pluginManager.commands).to.have.property('deploy');
    });

    it('should skip service related plugins which not match the services provider', () => {
      pluginManager.serverless.service.provider.name = 'someProvider';
      class Plugin {
        constructor() {
          this.provider = 'someOtherProvider';
        }
      }

      pluginManager.addPlugin(Plugin);

      expect(pluginManager.plugins.length).to.equal(0);
    });

    it('should add service related plugins when provider property is the providers name', () => {
      pluginManager.serverless.service.provider.name = 'someProvider';
      class Plugin {
        constructor() {
          this.provider = 'someProvider';
        }
      }

      pluginManager.addPlugin(Plugin);

      expect(pluginManager.plugins[0]).to.be.an.instanceOf(Plugin);
    });

    it('should add service related plugins when provider propery is provider plugin', () => {
      pluginManager.serverless.service.provider.name = 'someProvider';
      class ProviderPlugin {
        static getProviderName() {
          return 'someProvider';
        }
      }
      const providerPlugin = new ProviderPlugin();
      class Plugin {
        constructor() {
          this.provider = providerPlugin;
        }
      }

      pluginManager.addPlugin(Plugin);

      expect(pluginManager.plugins[0]).to.be.an.instanceOf(Plugin);
    });
  });

  describe('#asyncPluginInit()', () => {
    it('should call async init on plugins that have it', async () => {
      const plugin1 = new ServicePluginMock1();
      plugin1.asyncInit = sinon.stub().returns(Promise.resolve());
      pluginManager.plugins = [plugin1];
      return pluginManager.asyncPluginInit().then(() => {
        expect(plugin1.asyncInit.calledOnce).to.equal(true);
      });
    });
  });

  describe('#loadAllPlugins()', () => {
    beforeEach(() => {
      mockRequire('ServicePluginMock1', ServicePluginMock1);
      mockRequire('ServicePluginMock2', ServicePluginMock2);
      mockRequire('BrokenPluginMock', BrokenPluginMock);
      mockRequire('@serverless/dashboard-plugin', EnterprisePluginMock);
    });

    it('should load only core plugins when no service plugins are given', async () => {
      // Note: We need the Create plugin for this test to pass
      await pluginManager.loadAllPlugins();

      // note: this test will be refactored as the Create plugin will be moved
      // to another directory
      expect(pluginManager.plugins.length).to.be.above(0);
    });

    it('should load all plugins when service plugins are given', async () => {
      const servicePlugins = ['ServicePluginMock1', 'ServicePluginMock2'];
      await pluginManager.loadAllPlugins(servicePlugins);

      expect(pluginManager.plugins.some((plugin) => plugin instanceof ServicePluginMock1)).to.equal(
        true
      );
      expect(pluginManager.plugins.some((plugin) => plugin instanceof ServicePluginMock2)).to.equal(
        true
      );
      expect(
        pluginManager.plugins.some((plugin) => plugin instanceof EnterprisePluginMock)
      ).to.equal(true);
      // note: this test will be refactored as the Create plugin will be moved
      // to another directory
      expect(pluginManager.plugins.length).to.be.above(2);
    });

    it('should load all plugins in the correct order', async () => {
      const servicePlugins = ['ServicePluginMock1', 'ServicePluginMock2'];

      await pluginManager.loadAllPlugins(servicePlugins);

      const pluginIndexes = [
        pluginManager.plugins.findIndex((plugin) => plugin instanceof Create),
        pluginManager.plugins.findIndex((plugin) => plugin instanceof ServicePluginMock1),
        pluginManager.plugins.findIndex((plugin) => plugin instanceof ServicePluginMock2),
        pluginManager.plugins.findIndex((plugin) => plugin instanceof EnterprisePluginMock),
      ];
      expect(pluginIndexes).to.deep.equal(pluginIndexes.slice().sort((a, b) => a - b));
    });

    it('should load the Serverless core plugins', async () => {
      await pluginManager.loadAllPlugins();

      expect(pluginManager.plugins.length).to.be.above(1);
    });

    it('should throw an error when trying to load unknown plugin', () => {
      const servicePlugins = ['ServicePluginMock3', 'ServicePluginMock1'];

      return expect(pluginManager.loadAllPlugins(servicePlugins)).to.be.rejectedWith(
        ServerlessError
      );
    });

    it('should not throw error when trying to load unknown plugin with help flag', async () => {
      const servicePlugins = ['ServicePluginMock3', 'ServicePluginMock1'];

      pluginManager.setCliOptions({ help: true });

      resolveInput.clear();
      return overrideArgv({ args: ['serverless', '--help'] }, () => {
        return expect(pluginManager.loadAllPlugins(servicePlugins)).to.not.be.rejectedWith(
          ServerlessError
        );
      });
    });

    it('should pass through an error when plugin load fails', () => {
      const servicePlugins = ['BrokenPluginMock'];

      return expect(pluginManager.loadAllPlugins(servicePlugins)).to.be.rejectedWith(
        brokenPluginError
      );
    });

    it('should not throw error when running the plugin commands and given plugins does not exist', () => {
      const servicePlugins = ['ServicePluginMock3'];
      const cliCommandsMock = ['plugin'];
      pluginManager.setCliCommands(cliCommandsMock);

      return expect(pluginManager.loadAllPlugins(servicePlugins)).to.not.be.rejectedWith(
        ServerlessError
      );
    });

    afterEach(() => {
      mockRequire.stop('ServicePluginMock1');
      mockRequire.stop('ServicePluginMock2');
      mockRequire.stop('BrokenPluginMock');
      mockRequire.stop('@serverless/dashboard-plugin');
    });
  });

  describe('#resolveServicePlugins()', () => {
    beforeEach(() => {
      mockRequire('ServicePluginMock1', ServicePluginMock1);
      // Plugins loaded via a relative path should be required relative to the service path
      mockRequire(`${serviceDir}/RelativePath/ServicePluginMock2`, ServicePluginMock2);
    });

    it('should resolve the service plugins', async () => {
      const servicePlugins = ['ServicePluginMock1', './RelativePath/ServicePluginMock2'];
      expect(await pluginManager.resolveServicePlugins(servicePlugins)).to.deep.equal([
        ServicePluginMock1,
        ServicePluginMock2,
      ]);
    });

    it('should not error if plugins = null', () => {
      // Happens when `plugins` property exists but is empty
      const servicePlugins = null;
      return expect(pluginManager.resolveServicePlugins(servicePlugins)).to.not.be.rejected;
    });

    it('should not error if plugins = undefined', () => {
      // Happens when `plugins` property does not exist
      const servicePlugins = undefined;
      return expect(pluginManager.resolveServicePlugins(servicePlugins)).to.not.be.rejected;
    });

    afterEach(() => {
      mockRequire.stop('ServicePluginMock1');
      mockRequire.stop('ServicePluginMock2');
    });
  });

  describe('#parsePluginsObject()', () => {
    const parsePluginsObjectAndVerifyResult = (servicePlugins, expectedResult) => {
      const result = pluginManager.parsePluginsObject(servicePlugins);
      expect(result).to.deep.equal(expectedResult);
    };

    it('should parse array object', () => {
      const servicePlugins = ['ServicePluginMock1', 'ServicePluginMock2'];

      parsePluginsObjectAndVerifyResult(servicePlugins, {
        modules: servicePlugins,
        localPath: path.join(serverless.serviceDir, '.serverless_plugins'),
      });
    });

    it('should parse plugins object', () => {
      const servicePlugins = {
        modules: ['ServicePluginMock1', 'ServicePluginMock2'],
        localPath: './myplugins',
      };

      parsePluginsObjectAndVerifyResult(servicePlugins, {
        modules: servicePlugins.modules,
        localPath: servicePlugins.localPath,
      });
    });

    it('should parse plugins object if format is not correct', () => {
      const servicePlugins = {};

      parsePluginsObjectAndVerifyResult(servicePlugins, {
        modules: [],
        localPath: path.join(serverless.serviceDir, '.serverless_plugins'),
      });
    });

    it('should parse plugins object if modules property is not an array', () => {
      const servicePlugins = { modules: {} };

      parsePluginsObjectAndVerifyResult(servicePlugins, {
        modules: [],
        localPath: path.join(serverless.serviceDir, '.serverless_plugins'),
      });
    });

    it('should parse plugins object if localPath is not correct', () => {
      const servicePlugins = {
        modules: ['ServicePluginMock1', 'ServicePluginMock2'],
        localPath: {},
      };

      parsePluginsObjectAndVerifyResult(servicePlugins, {
        modules: servicePlugins.modules,
        localPath: path.join(serverless.serviceDir, '.serverless_plugins'),
      });
    });
  });

  describe('command aliases', () => {
    describe('#getAliasCommandTarget', () => {
      it('should return an alias target', () => {
        pluginManager.aliases = {
          cmd1: {
            cmd2: {
              command: 'command1',
            },
            cmd3: {
              cmd4: {
                command: 'command2',
              },
            },
          },
        };
        expect(pluginManager.getAliasCommandTarget(['cmd1', 'cmd2'])).to.equal('command1');
        expect(pluginManager.getAliasCommandTarget(['cmd1', 'cmd3', 'cmd4'])).to.equal('command2');
      });

      it('should return undefined if alias does not exist', () => {
        pluginManager.aliases = {
          cmd1: {
            cmd2: {
              command: 'command1',
            },
            cmd3: {
              cmd4: {
                command: 'command2',
              },
            },
          },
        };
        expect(pluginManager.getAliasCommandTarget(['cmd1'])).to.be.undefined;
        expect(pluginManager.getAliasCommandTarget(['cmd1', 'cmd3'])).to.be.undefined;
      });
    });

    describe('#createCommandAlias', () => {
      it('should create an alias for a command', () => {
        pluginManager.aliases = {};
        expect(pluginManager.createCommandAlias('cmd1:alias2', 'cmd2:cmd3:cmd4')).to.not.throw;
        expect(pluginManager.createCommandAlias('cmd1:alias2:alias3', 'cmd2:cmd3:cmd5')).to.not
          .throw;
        expect(pluginManager.aliases).to.deep.equal({
          cmd1: {
            alias2: {
              command: 'cmd2:cmd3:cmd4',
              alias3: {
                command: 'cmd2:cmd3:cmd5',
              },
            },
          },
        });
      });

      it('should fail if the alias already exists', () => {
        pluginManager.aliases = {
          cmd1: {
            alias2: {
              command: 'cmd2:cmd3:cmd4',
              alias3: {
                command: 'cmd2:cmd3:cmd5',
              },
            },
          },
        };
        expect(() => pluginManager.createCommandAlias('cmd1:alias2', 'mycmd')).to.throw(
          /Alias "cmd1:alias2" is already defined/
        );
      });

      it('should fail if the alias overwrites a command', () => {
        const synchronousPluginMockInstance = new SynchronousPluginMock();
        pluginManager.loadCommands(synchronousPluginMockInstance);
        expect(() => pluginManager.createCommandAlias('deploy', 'mycmd')).to.throw(
          /Command "deploy" cannot be overriden/
        );
      });

      it('should fail if the alias overwrites the very own command', () => {
        const synchronousPluginMockInstance = new SynchronousPluginMock();
        synchronousPluginMockInstance.commands.deploy.commands.onpremises.aliases = ['deploy'];
        expect(() => pluginManager.loadCommands(synchronousPluginMockInstance)).to.throw(
          /Command "deploy" cannot be overriden/
        );
      });
    });
  });

  describe('#loadCommands()', () => {
    it('should load the plugin commands', () => {
      const synchronousPluginMockInstance = new SynchronousPluginMock();
      pluginManager.loadCommands(synchronousPluginMockInstance);

      expect(pluginManager.commands).to.have.property('deploy');
    });

    it('should merge plugin commands', () => {
      pluginManager.loadCommands({
        commands: {
          deploy: {
            lifecycleEvents: ['one'],
            options: {
              foo: {},
            },
          },
        },
      });

      pluginManager.loadCommands({
        commands: {
          deploy: {
            lifecycleEvents: ['one', 'two'],
            options: {
              bar: {},
            },
            commands: {
              fn: {},
            },
          },
        },
      });

      expect(pluginManager.commands.deploy)
        .to.have.property('options')
        .that.has.all.keys('foo', 'bar');
      expect(pluginManager.commands.deploy)
        .to.have.property('lifecycleEvents')
        .that.is.an('array')
        .that.deep.equals(['one', 'two']);
      expect(pluginManager.commands.deploy.commands).to.have.property('fn');
    });

    it('should fail if there is already an alias for a command', () => {
      pluginManager.aliases = {
        deploy: {
          command: 'my:deploy',
        },
      };

      const synchronousPluginMockInstance = new SynchronousPluginMock();
      expect(() => pluginManager.loadCommands(synchronousPluginMockInstance)).to.throw(
        /Command "deploy" cannot override an existing alias/
      );
    });
  });

  describe('#loadHooks()', () => {
    let deprecatedPluginInstance;

    beforeEach(() => {
      deprecatedPluginInstance = new DeprecatedLifecycleEventsPluginMock();
      pluginManager.deprecatedEvents = {
        'deprecated:deprecated': 'new:new',
      };
    });

    afterEach(() => {
      pluginManager.deprecatedEvents = {};
    });

    it('should replace deprecated events with the new ones', () => {
      pluginManager.loadHooks(deprecatedPluginInstance);

      expect(pluginManager.hooks['deprecated:deprecated']).to.equal(undefined);
      expect(pluginManager.hooks['new:new'][0].pluginName).to.equal(
        'DeprecatedLifecycleEventsPluginMock'
      );
      expect(pluginManager.hooks['untouched:untouched'][0].pluginName).to.equal(
        'DeprecatedLifecycleEventsPluginMock'
      );
    });
  });

  describe('#getPlugins()', () => {
    beforeEach(() => {
      mockRequire('ServicePluginMock1', ServicePluginMock1);
      mockRequire('ServicePluginMock2', ServicePluginMock2);
    });

    it('should return all loaded plugins', async () => {
      const servicePlugins = ['ServicePluginMock1', 'ServicePluginMock2'];
      await pluginManager.loadAllPlugins(servicePlugins);

      const plugins = pluginManager.getPlugins();
      expect(plugins.length).to.be.above(3);
      expect(plugins.some((plugin) => plugin instanceof ServicePluginMock1)).to.be.true;
      expect(plugins.some((plugin) => plugin instanceof ServicePluginMock2)).to.be.true;
    });

    afterEach(() => {
      mockRequire.stop('ServicePluginMock1');
      mockRequire.stop('ServicePluginMock2');
    });
  });

  describe('#validateCommand()', () => {
    it('should find commands', () => {
      pluginManager.addPlugin(EntrypointPluginMock);

      expect(() => pluginManager.validateCommand(['mycmd', 'mysubcmd'])).to.not.throw(
        ServerlessError
      );
    });

    it('should find container children commands', () => {
      pluginManager.addPlugin(ContainerPluginMock);

      expect(() => pluginManager.validateCommand(['mycontainer', 'mysubcmd'])).to.not.throw(
        ServerlessError
      );
    });
  });

  describe('#assignDefaultOptions()', () => {
    it('should assign default values to empty options', () => {
      pluginManager.commands = {
        foo: {
          options: {
            bar: {
              required: true,
              default: 'foo',
            },
          },
        },
      };

      const foo = pluginManager.commands.foo;
      pluginManager.assignDefaultOptions(foo);

      expect(pluginManager.cliOptions.bar).to.equal(foo.options.bar.default);
    });

    it('should not assign default values to non-empty options', () => {
      pluginManager.commands = {
        foo: {
          options: {
            bar: {
              required: true,
              default: 'foo',
            },
          },
        },
      };

      const foo = pluginManager.commands.foo;
      pluginManager.setCliOptions({ bar: 100 });
      pluginManager.assignDefaultOptions(foo);

      expect(pluginManager.cliOptions.bar).to.equal(100);
    });

    [0, '', false].forEach((defaultValue) => {
      it(`assigns valid falsy default value '${defaultValue} to empty options`, () => {
        pluginManager.commands = {
          foo: {
            options: {
              bar: {
                required: true,
                default: defaultValue,
              },
            },
          },
        };

        const foo = pluginManager.commands.foo;
        pluginManager.assignDefaultOptions(foo);

        expect(pluginManager.cliOptions.bar).to.equal(defaultValue);
      });
    });
  });

  describe('#validateServerlessConfigDependency()', () => {
    let serverlessInstance;
    let pluginManagerInstance;

    beforeEach(() => {
      serverlessInstance = new Serverless({ commands: [], options: {} });
      serverlessInstance.configurationInput = null;
      serverlessInstance.serviceDir = 'my-service';
      pluginManagerInstance = new PluginManager(serverlessInstance);
    });

    it('should continue loading if the configDependent property is absent', () => {
      pluginManagerInstance.commands = {
        foo: {},
      };

      const foo = pluginManagerInstance.commands.foo;

      expect(pluginManagerInstance.validateServerlessConfigDependency(foo)).to.be.undefined;
    });

    it('should load if the configDependent property is false and config is null', () => {
      pluginManagerInstance.commands = {
        foo: {
          configDependent: false,
        },
      };

      const foo = pluginManagerInstance.commands.foo;

      expect(pluginManagerInstance.validateServerlessConfigDependency(foo)).to.be.undefined;
    });

    it('should throw an error if configDependent is true and no config is found', () => {
      pluginManagerInstance.commands = {
        foo: {
          configDependent: true,
        },
      };

      const foo = pluginManagerInstance.commands.foo;

      expect(() => {
        pluginManager.validateServerlessConfigDependency(foo);
      }).to.throw(Error);
    });

    it('should throw an error if configDependent is true and config is an empty string', () => {
      pluginManagerInstance.commands = {
        foo: {
          configDependent: true,
        },
      };

      const foo = pluginManagerInstance.commands.foo;

      expect(() => {
        pluginManager.validateServerlessConfigDependency(foo);
      }).to.throw(Error);
    });

    it('should load if the configDependent property is true and config exists', () => {
      pluginManagerInstance.serverless.configurationInput = {
        servicePath: 'foo',
      };

      pluginManagerInstance.commands = {
        foo: {
          configDependent: true,
        },
      };

      const foo = pluginManagerInstance.commands.foo;

      expect(pluginManagerInstance.validateServerlessConfigDependency(foo)).to.be.undefined;
    });
  });

  describe('#run()', () => {
    it('should throw an error when the given command is not available', () => {
      pluginManager.addPlugin(SynchronousPluginMock);

      const commandsArray = ['foo'];

      return expect(pluginManager.run(commandsArray)).to.be.rejectedWith(Error);
    });

    it('should throw an error when the given command is an entrypoint', () => {
      pluginManager.addPlugin(EntrypointPluginMock);

      const commandsArray = ['myep'];

      return expect(pluginManager.run(commandsArray)).to.be.rejectedWith(Error);
    });

    it('should NOT throw an error when the given command is a child of a container', () => {
      pluginManager.addPlugin(ContainerPluginMock);

      const commandsArray = ['mycontainer', 'mysubcmd'];

      return expect(pluginManager.run(commandsArray)).to.not.be.rejectedWith(Error);
    });

    it('should throw an error when the given command is a child of an entrypoint', () => {
      pluginManager.addPlugin(EntrypointPluginMock);

      const commandsArray = ['mysubcmd'];

      return expect(pluginManager.run(commandsArray)).to.be.rejectedWith(Error);
    });

    it('should run the hooks in the correct order', async () => {
      class CorrectHookOrderPluginMock {
        constructor() {
          this.commands = {
            run: {
              usage: 'Pushes the current hook status on the hookStatus array',
              lifecycleEvents: ['beforeHookStatus', 'midHookStatus', 'afterHookStatus'],
            },
          };

          this.hooks = {
            'initialize': async () => this.initializeHookStatus(),
            'before:run:beforeHookStatus': async () => this.beforeHookStatus(),
            'run:midHookStatus': async () => this.midHookStatus(),
            'after:run:afterHookStatus': async () => this.afterHookStatus(),
          };

          // used to test if the hooks were run in the correct order
          this.hookStatus = [];
        }

        initializeHookStatus() {
          this.hookStatus.push('initialize');
        }

        beforeHookStatus() {
          this.hookStatus.push('before');
        }

        midHookStatus() {
          this.hookStatus.push('mid');
        }

        afterHookStatus() {
          this.hookStatus.push('after');
        }
      }

      pluginManager.addPlugin(CorrectHookOrderPluginMock);
      const commandsArray = ['run'];
      return pluginManager.run(commandsArray).then(() => {
        expect(pluginManager.plugins[0].hookStatus[0]).to.equal('initialize');
        expect(pluginManager.plugins[0].hookStatus[1]).to.equal('before');
        expect(pluginManager.plugins[0].hookStatus[2]).to.equal('mid');
        expect(pluginManager.plugins[0].hookStatus[3]).to.equal('after');
      });
    });

    describe('when using a synchronous hook function', () => {
      beforeEach(() => {
        pluginManager.addPlugin(SynchronousPluginMock);
      });

      describe('when running a simple command', () => {
        it('should run a simple command', async () => {
          const commandsArray = ['deploy'];
          return pluginManager
            .run(commandsArray)
            .then(() => expect(pluginManager.plugins[0].deployedFunctions).to.equal(1));
        });
      });

      describe('when running a nested command', () => {
        it('should run the nested command', async () => {
          const commandsArray = ['deploy', 'onpremises'];
          return pluginManager
            .run(commandsArray)
            .then(() => expect(pluginManager.plugins[0].deployedResources).to.equal(1));
        });
      });
    });

    describe('when using a promise based hook function', () => {
      beforeEach(() => {
        pluginManager.addPlugin(PromisePluginMock);
      });

      describe('when running a simple command', () => {
        it('should run the simple command', async () => {
          const commandsArray = ['deploy'];
          return pluginManager
            .run(commandsArray)
            .then(() => expect(pluginManager.plugins[0].deployedFunctions).to.equal(1));
        });
      });

      describe('when running a nested command', () => {
        it('should run the nested command', async () => {
          const commandsArray = ['deploy', 'onpremises'];
          return pluginManager
            .run(commandsArray)
            .then(() => expect(pluginManager.plugins[0].deployedResources).to.equal(1));
        });
      });
    });

    describe('when using provider specific plugins', () => {
      beforeEach(() => {
        pluginManager.serverless.service.provider.name = 'provider1';

        pluginManager.addPlugin(Provider1PluginMock);
        pluginManager.addPlugin(Provider2PluginMock);

        // this plugin should be run each and every time as it doesn't specify any provider
        pluginManager.addPlugin(SynchronousPluginMock);
      });

      it('should load only the providers plugins (if the provider is specified)', async () => {
        const commandsArray = ['deploy'];
        return pluginManager.run(commandsArray).then(() => {
          expect(pluginManager.plugins.length).to.equal(2);
          expect(pluginManager.plugins[0].deployedFunctions).to.equal(1);
          expect(pluginManager.plugins[0].provider).to.equal('provider1');
          expect(pluginManager.plugins[1].deployedFunctions).to.equal(1);
          expect(pluginManager.plugins[1].provider).to.equal(undefined);
        });
      });
    });

    it('should run commands with internal lifecycles', async () => {
      pluginManager.addPlugin(EntrypointPluginMock);

      const commandsArray = ['mycmd', 'spawncmd'];

      return pluginManager.run(commandsArray).then(() => {
        expect(pluginManager.plugins[0].callResult).to.equal(
          '>subInitialize>subFinalize>initialize>finalize>run>subEPInitialize>subEPFinalize'
        );
      });
    });
  });

  describe('#getCommands()', () => {
    it('should hide entrypoints on any level and only return commands', () => {
      pluginManager.addPlugin(EntrypointPluginMock);

      const commands = pluginManager.getCommands();
      expect(commands).to.have.a.property('mycmd');
      expect(commands).to.have.a.nested.property('mycmd.commands.mysubcmd');
      expect(commands).to.have.a.nested.property('mycmd.commands.spawncmd');
      // Check for omitted entrypoints
      expect(commands).to.not.have.a.property('myep');
      expect(commands).to.not.have.a.nested.property('myep.commands.mysubep');
      expect(commands).to.not.have.a.nested.property('mycmd.commands.spawnep');
    });

    it('should return aliases', () => {
      pluginManager.addPlugin(AliasPluginMock);

      const commands = pluginManager.getCommands();
      expect(commands).to.have.a.property('on').that.has.a.nested.property('commands.premise');
      expect(commands).to.have.a.property('premise');
    });
  });

  describe('#getCommand()', () => {
    beforeEach(() => {
      pluginManager.addPlugin(SynchronousPluginMock);
      pluginManager.serverless.cli.loadedCommands = {
        create: {
          usage: 'Create new Serverless service',
          lifecycleEvents: ['create'],
          options: {
            template: {
              usage: 'Template for the service. Available templates: ", "aws-nodejs", "..."',
              shortcut: 't',
            },
          },
          key: 'create',
          pluginName: 'Create',
        },
        deploy: {
          usage: 'Deploy a Serverless service',
          configDependent: true,
          lifecycleEvents: ['cleanup', 'initialize'],
          options: {
            conceal: {
              usage: 'Hide secrets from the output (e.g. API Gateway key values)',
            },
            stage: {
              usage: 'Stage of the service',
              shortcut: 's',
            },
          },
          key: 'deploy',
          pluginName: 'Deploy',
          commands: {
            function: {
              usage: 'Deploy a single function from the service',
              lifecycleEvents: ['initialize', 'packageFunction', 'deploy'],
              options: {
                function: {
                  usage: 'Name of the function',
                  shortcut: 'f',
                  required: true,
                },
              },
              key: 'deploy:function',
              pluginName: 'Deploy',
            },
            list: {
              usage: 'List deployed version of your Serverless Service',
              lifecycleEvents: ['log'],
              key: 'deploy:list',
              pluginName: 'Deploy',
              commands: {
                functions: {
                  usage: 'List all the deployed functions and their versions',
                  lifecycleEvents: ['log'],
                  key: 'deploy:list:functions',
                  pluginName: 'Deploy',
                },
              },
            },
          },
        },
      };
    });
  });

  describe('#spawn()', () => {
    it('should throw an error when the given command is not available', async () => {
      pluginManager.addPlugin(EntrypointPluginMock);

      const commandsArray = ['foo'];

      return expect(pluginManager.spawn(commandsArray)).to.eventually.be.rejectedWith(Error);
    });

    describe('when invoking a command', () => {
      it('should succeed', async () => {
        pluginManager.addPlugin(EntrypointPluginMock);

        const commandsArray = ['mycmd'];

        return pluginManager.spawn(commandsArray).then(() => {
          expect(pluginManager.plugins[0].callResult).to.equal('>run');
        });
      });

      it('should spawn nested commands', async () => {
        pluginManager.addPlugin(EntrypointPluginMock);

        const commandsArray = ['mycmd', 'mysubcmd'];

        return pluginManager.spawn(commandsArray).then(() => {
          expect(pluginManager.plugins[0].callResult).to.equal('>subInitialize>subFinalize');
        });
      });

      it('should terminate the hook chain if requested', async () => {
        pluginManager.addPlugin(EntrypointPluginMock);

        const commandsArray = ['mycmd', 'mysubcmd'];

        return expect(
          pluginManager.spawn(commandsArray, { terminateLifecycleAfterExecution: true })
        )
          .to.be.rejectedWith('Terminating mycmd:mysubcmd')
          .then(() => {
            expect(pluginManager.plugins[0].callResult).to.equal('>subInitialize>subFinalize');
          });
      });
    });

    describe('when invoking a container', () => {
      it('should spawn nested commands', async () => {
        pluginManager.addPlugin(ContainerPluginMock);

        const commandsArray = ['mycontainer', 'mysubcmd'];

        return pluginManager.spawn(commandsArray).then(() => {
          expect(pluginManager.plugins[0].callResult).to.equal('>mysubcmdEvent1>mysubcmdEvent2');
        });
      });
    });

    describe('when invoking an entrypoint', () => {
      it('should succeed', async () => {
        pluginManager.addPlugin(EntrypointPluginMock);

        const commandsArray = ['myep'];

        return pluginManager.spawn(commandsArray).then(() => {
          expect(pluginManager.plugins[0].callResult).to.equal('>initialize>finalize');
        });
      });

      it('should spawn nested entrypoints', async () => {
        pluginManager.addPlugin(EntrypointPluginMock);

        const commandsArray = ['myep', 'mysubep'];

        return pluginManager.spawn(commandsArray).then(() => {
          expect(pluginManager.plugins[0].callResult).to.equal('>subEPInitialize>subEPFinalize');
        });
      });

      describe('with string formatted syntax', () => {
        it('should succeed', async () => {
          pluginManager.addPlugin(EntrypointPluginMock);

          return pluginManager.spawn('myep').then(() => {
            expect(pluginManager.plugins[0].callResult).to.equal('>initialize>finalize');
          });
        });

        it('should spawn nested entrypoints', async () => {
          pluginManager.addPlugin(EntrypointPluginMock);

          return pluginManager.spawn('myep:mysubep').then(() => {
            expect(pluginManager.plugins[0].callResult).to.equal('>subEPInitialize>subEPFinalize');
          });
        });
      });
    });

    it('should spawn entrypoints with internal lifecycles', async () => {
      pluginManager.addPlugin(EntrypointPluginMock);

      const commandsArray = ['myep', 'spawnep'];

      return pluginManager.spawn(commandsArray).then(() => {
        expect(pluginManager.plugins[0].callResult).to.equal(
          '>subInitialize>subFinalize>initialize>finalize>run>subEPInitialize>subEPFinalize'
        );
      });
    });
  });

  describe('Plugin / Load local plugins', () => {
    const cwd = process.cwd();
    let tmpDir;
    beforeEach(() => {
      tmpDir = getTmpDirPath();
      serviceDir = path.join(tmpDir, 'service');
      fse.mkdirsSync(serviceDir);
      process.chdir(serviceDir);
      pluginManager.serverless.serviceDir = serviceDir;
    });

    it('should load plugins from .serverless_plugins', async () => {
      const localPluginDir = path.join(serviceDir, '.serverless_plugins', 'local-plugin');
      installPlugin(localPluginDir, SynchronousPluginMock);

      await pluginManager.loadAllPlugins(['local-plugin']);
      expect(pluginManager.plugins).to.satisfy((plugins) =>
        plugins.some((plugin) => plugin.constructor.name === 'SynchronousPluginMock')
      );
    });

    it('should load plugins from custom folder', async () => {
      const localPluginDir = path.join(serviceDir, 'serverless-plugins-custom', 'local-plugin');
      installPlugin(localPluginDir, SynchronousPluginMock);

      await pluginManager.loadAllPlugins({
        localPath: path.join(serviceDir, 'serverless-plugins-custom'),
        modules: ['local-plugin'],
      });
      // Had to use constructor.name because the class will be loaded via
      // require and the reference will not match with SynchronousPluginMock
      expect(pluginManager.plugins).to.satisfy((plugins) =>
        plugins.some((plugin) => plugin.constructor.name === 'SynchronousPluginMock')
      );
    });

    it('should load plugins from custom folder outside of serviceDir', async () => {
      serviceDir = path.join(tmpDir, 'serverless-plugins-custom');
      const localPluginDir = path.join(serviceDir, 'local-plugin');
      installPlugin(localPluginDir, SynchronousPluginMock);

      await pluginManager.loadAllPlugins({
        localPath: serviceDir,
        modules: ['local-plugin'],
      });
      // Had to use constructor.name because the class will be loaded via
      // require and the reference will not match with SynchronousPluginMock
      expect(pluginManager.plugins).to.satisfy((plugins) =>
        plugins.some((plugin) => plugin.constructor.name === 'SynchronousPluginMock')
      );
    });

    afterEach(() => {
      process.chdir(cwd);
      try {
        fse.removeSync(tmpDir);
      } catch (e) {
        // Couldn't delete temporary file
      }
    });
  });
});

describe('test/unit/lib/classes/PluginManager.test.js', () => {
  it('should load plugins relatively to the working directory', async () => {
    const { servicePath: serviceDir } = await fixtures.setup('aws');
    const localPluginDir = path.join(serviceDir, 'node_modules', 'local-plugin');
    const parentPluginDir = path.join(serviceDir, '..', 'node_modules', 'parent-plugin');
    installPlugin(localPluginDir, SynchronousPluginMock);
    installPlugin(parentPluginDir, PromisePluginMock);
    await fsp.appendFile(
      path.join(serviceDir, 'serverless.yml'),
      'plugins:\n  - local-plugin\n  - parent-plugin'
    );

    const { serverless } = await runServerless({
      cwd: serviceDir,
      command: 'print',
    });

    const pluginNames = new Set(
      serverless.pluginManager.plugins.map((plugin) => plugin.constructor.name)
    );
    expect(pluginNames).to.contain('SynchronousPluginMock');
    expect(pluginNames).to.contain('PromisePluginMock');
  });

  it('should pass log writers to external plugins', async () => {
    const { serverless } = await runServerless({
      fixture: 'plugin',
      command: 'print',
    });
    const plugin = Array.from(serverless.pluginManager.externalPlugins).find(
      (externalPlugin) => externalPlugin.constructor.name === 'TestPlugin'
    );
    expect(typeof plugin.utils.log).to.equal('function');
    expect(typeof plugin.utils.progress.create).to.equal('function');
    expect(typeof plugin.utils.writeText).to.equal('function');
  });

  it('should error out for duplicate plugin definiton', async () => {
    await expect(
      runServerless({
        fixture: 'plugin',
        command: 'print',
        configExt: {
          plugins: ['./plugin', './plugin'],
        },
      })
    ).to.be.eventually.rejected.and.have.property('code', 'DUPLICATE_PLUGIN_DEFINITION');
  });

  it('should pass through an error when trying to load a plugin with error', async () => {
    await expect(
      runServerless({
        fixture: 'plugin',
        command: 'print',
        configExt: {
          plugins: ['./broken-plugin'],
        },
      })
    ).to.be.eventually.rejectedWith(Error, 'failed to load plugin');
  });

  it('should load ESM plugins', async () => {
    const { serverless } = await runServerless({
      fixture: 'plugin',
      command: 'print',
      configExt: {
        plugins: ['./local-esm-plugin', 'esm-plugin'],
      },
    });

    const pluginNames = new Set(
      serverless.pluginManager.plugins.map((plugin) => plugin.constructor.name)
    );
    expect(pluginNames).to.include('LocalESMPlugin');
    expect(pluginNames).to.include('ESMPlugin');
  });
});
