'use strict'

const chai = require('chai')
const sinon = require('sinon')
const PluginSearch = require('../../../../../lib/plugins/plugin/search')
const Serverless = require('../../../../../lib/serverless')
const CLI = require('../../../../../lib/classes/cli')
chai.use(require('chai-as-promised'))
const expect = require('chai').expect

describe('PluginSearch', () => {
  let pluginSearch
  let serverless

  const plugins = [
    {
      name: 'serverless-plugin-1',
      description: 'Serverless Plugin 1',
      githubUrl: 'https://github.com/serverless/serverless-plugin-1',
    },
    {
      name: 'serverless-plugin-2',
      description: 'Serverless Plugin 2',
      githubUrl: 'https://github.com/serverless/serverless-plugin-2',
    },
    {
      name: 'serverless-existing-plugin',
      description: 'Serverless Existing plugin',
      githubUrl: 'https://github.com/serverless/serverless-existing-plugin',
    },
  ]

  beforeEach(() => {
    serverless = new Serverless({ commands: [], options: {} })
    serverless.cli = new CLI(serverless)
    const options = {}
    pluginSearch = new PluginSearch(serverless, options)
  })

  describe('#constructor()', () => {
    let searchStub

    beforeEach(() => {
      searchStub = sinon.stub(pluginSearch, 'search').returns(Promise.resolve())
    })

    afterEach(() => {
      pluginSearch.search.restore()
    })

    it('should have the sub-command "search"', () => {
      expect(pluginSearch.commands.plugin.commands.search).to.not.equal(
        undefined,
      )
    })

    it('should have the lifecycle event "search" for the "search" sub-command', () => {
      expect(
        pluginSearch.commands.plugin.commands.search.lifecycleEvents,
      ).to.deep.equal(['search'])
    })

    it('should have a required option "query" for the "search" sub-command', () => {
      // eslint-disable-next-line no-unused-expressions
      expect(
        pluginSearch.commands.plugin.commands.search.options.query.required,
      ).to.be.true
    })

    it('should have a "plugin:search:search" hook', () => {
      expect(pluginSearch.hooks['plugin:search:search']).to.not.equal(undefined)
    })

    it('should run promise chain in order for "plugin:search:search" hook', async () =>
      expect(pluginSearch.hooks['plugin:search:search']()).to.be.fulfilled.then(
        () => {
          expect(searchStub.calledOnce).to.equal(true)
        },
      ))
  })

  describe('#search()', () => {
    let getPluginsStub
    let displayStub

    beforeEach(() => {
      getPluginsStub = sinon
        .stub(pluginSearch, 'getPlugins')
        .returns(Promise.resolve(plugins))
      displayStub = sinon
        .stub(pluginSearch, 'display')
        .returns(Promise.resolve())
    })

    afterEach(() => {
      pluginSearch.getPlugins.restore()
      pluginSearch.display.restore()
    })

    it('should return a list of plugins based on the search query', async () => {
      pluginSearch.options.query = 'serverless-plugin-1'

      return expect(pluginSearch.search()).to.be.fulfilled.then(() => {
        expect(getPluginsStub.calledOnce).to.equal(true)
        expect(displayStub.calledOnce).to.equal(true)
      })
    })
  })
})