guv/spec/governor.coffee

Grid Utilization Virgilante

chai = require 'chai'
async = require 'async'

guv = require '..'
mocks = require './mocks'
mocks.enable = true

describe 'Governor', ->
  governor = null
  
  before () ->
    cfg = guv.config.parse ""
    broker = cfg['*'].broker
    # check that required envvars for the tests
    chai.expect(broker, 'GUV_BROKER envvar not set').to.exist
    chai.expect(broker).to.include 'amqp://'
    chai.expect(process.env['HEROKU_API_KEY'], 'HEROKU_API_KEY envvar not set').to.exist
    mocks.startRecord()

  after () ->
    mocks.stopRecord()

  # Happy cases
  describe 'is happy', ->
    c = \
    """
    '*': { app: 'guv-test' }
    my: {queue: 'myrole.IN', worker: web, minimum: 0, max: 1}
    """
    cfg = guv.config.parse c
    beforeEach (done) ->
      governor = new guv.governor.Governor cfg
      done()

    beforeEach (done) ->
      governor.stop()
      done()

    describe 'no messages in queue', ->
      it 'should scale to minimum', (done) ->
        mocks.Heroku.setCurrentWorkers 'guv-test', { web: 1 }
        mocks.RabbitMQ.setQueues
          'myrole.IN':
            'messages': 0
        setWorkers = mocks.Heroku.expectWorkers 'guv-test',
          'web': cfg.my.minimum

        governor.once 'error', (err) ->
          chai.expect(err).to.not.exist

        governor.once 'state', (state) ->
          chai.expect(state).to.include.keys 'my'
          chai.expect(state.my.current_jobs).to.equal 0
          chai.expect(state.my.new_workers).to.equal cfg.my.minimum
          setWorkers.done()
          done()
        governor.start()

    describe 'lots of messages in queue', ->
      it 'should scale to maximum', (done) ->
        mocks.Heroku.setCurrentWorkers 'guv-test', { web: 0 }
        mocks.RabbitMQ.setQueues
          'myrole.IN':
            'messages': 1000
        setWorkers = mocks.Heroku.expectWorkers 'guv-test',
          'web': cfg.my.maximum

        governor.once 'error', (err) ->
          chai.expect(err).to.not.exist

        governor.once 'state', (state) ->
          chai.expect(state).to.include.keys 'my'
          chai.expect(state.my.current_jobs).to.equal 1000
          chai.expect(state.my.new_workers).to.equal cfg.my.maximum
          setWorkers.done()
          done()
        governor.start()

    describe 'lots of messages then less', ->
      setWorkers = null

      it 'should scale up quickly then slowly down again', (done) ->
        governor.once 'error', (err) ->
          chai.expect(err, JSON.stringify(err) ).to.not.exist

        series = [
          { messages: 0, current: 99, next: cfg.my.minimum } # filling up history
          { messages: 0, current: cfg.my.minimum, next: null }
          { messages: 0, current: cfg.my.minimum, next: null }
          { messages: 0, current: cfg.my.minimum, next: null }
          { messages: 100, current: cfg.my.minimum, next: cfg.my.maximum } # fast up
          { messages: 0, current: cfg.my.maximum, next: null } # no-op for 120 seconds, 4 iterations
          { messages: 0, current: cfg.my.maximum, next: null }
          { messages: 0, current: cfg.my.maximum, next: null }
          { messages: 0, current: cfg.my.maximum, next: null }
          { messages: 0, current: cfg.my.maximum, next: cfg.my.minimum } # down
        ]
        series = series.map (s, idx) ->
          s.name = "iteration #{idx} of #{series.length}"
          return s

        iteration = (data, callback) ->

          setTimeout () ->
            # prep this iteration
            mocks.Heroku.setCurrentWorkers 'guv-test', { web: data.current }
            mocks.RabbitMQ.setQueues { 'myrole.IN': { 'messages': data.messages }}
            if data.next?
              setWorkers = mocks.Heroku.expectWorkers 'guv-test', { 'web': data.next }
            else
              setWorkers = null

            # run
            governor.runOnce (err, state) ->
              return callback err if err

              # verify
              try
                if setWorkers
                  setWorkers.done()
              catch e
                return callback e if e
              return callback null, state

          , 10

        async.mapSeries series, iteration, (err) ->
          return done err

  # Complicated config
  describe 'complicated config', ->
    c = \
    """
    '*': { app: 'guv-test' }
    my: { queue: 'myrole.IN', worker: web, minimum: 0, max: 1 }
    ours: { queue: 'myrole.DRAIN', worker: web, minimum: 1, max: 1, app: 'other' }
    """
    cfg = guv.config.parse c
    beforeEach (done) ->
      governor = new guv.governor.Governor cfg
      done()

    beforeEach (done) ->
      governor.stop()
      done()

    describe 'scales correctly', ->
      it 'should scale both correctly', (done) ->
        mocks.Heroku.setCurrentWorkers 'guv-test', { web: 1 }
        mocks.Heroku.setCurrentWorkers 'other', { web: 0 }
        mocks.RabbitMQ.setQueues
          'myrole.IN':
            'messages': 0
          'myrole.DRAIN':
            'messages': 100
        setWorkers1 = mocks.Heroku.expectWorkers 'guv-test',
          'web': cfg.my.minimum

        setWorkers2 = mocks.Heroku.expectWorkers 'other',
          'web': cfg.ours.maximum

        governor.once 'error', (err) ->
          chai.expect(err).to.not.exist

        governor.once 'state', (state) ->
          chai.expect(state).to.include.keys 'my'
          chai.expect(state).to.include.keys 'ours'
          chai.expect(state.my.current_jobs).to.equal 0
          chai.expect(state.my.new_workers).to.equal cfg.my.minimum
          chai.expect(state.ours.new_workers).to.equal cfg.ours.maximum
          setWorkers1.done()
          setWorkers2.done()
          done()
        governor.start()

  # Error cases
  describe 'Errors', ->

    describe 'cannot connect to Heroku', ->
      it 'should emit error'
    describe 'specified worker does not exist', ->
      it 'should emit error'
      it 'other workers should be unaffected'

    describe 'cannot connect to RabbitMQ', ->
      it 'should emit error'

    describe 'specified queue does not exist', ->
      newState = null
      cfg = null
      setWorkers = null

      it 'should emit error', (done) ->
        c = """
        '*': { app: 'guv-test'}
        wrongqueue: {queue: 'myrole.NONEXIST', worker: wrongworker, minimum: 0, max: 1}
        correctqueue: {queue: 'myrole.IN', worker: correctworker, minimum: 0, max: 1}
        """
        cfg = guv.config.parse c
        gov = new guv.governor.Governor cfg
        mocks.RabbitMQ.setQueues { 'myrole.IN': { 'messages': 334 } }
        mocks.Heroku.setCurrentWorkers 'guv-test', { correctworker: 99 }
        setWorkers = mocks.Heroku.expectWorkers 'guv-test', { 'correctworker': cfg.correctqueue.maximum }

        gov.once 'error', (err) ->
          chai.expect(err).to.exist
          chai.expect(err.message).to.contain cfg.wrongqueue.queue
          done()
        gov.once 'state', (state) ->
          newState = state
        gov.start()

      it 'should still send state update', ->
        chai.expect(newState).to.exist
        chai.expect(newState).to.have.keys ['correctqueue', 'wrongqueue']
        chai.expect(newState.correctqueue.new_workers).to.equal cfg.correctqueue.maximum

      it 'should still scale the other workers', () ->
        setWorkers.done()