               options = { provider : providerSlug, machineId : machine._id.toString(), credential }
               ComputeProvider.remove client, options, (err) ->
                 if err
-                  return expect(err.message).to.be.equal notImplementedMessage
+                  expect(err.message).to.be.equal notImplementedMessage
+                  return callback()
                 queue.next()
 
             ->
               JMachine.one { _id : machine._id }, (err, machine) ->
                 expect(err).to.not.exist
                 expect(machine).to.not.exist
+                callback()
                 queue.next()
 
           ]

          ComputeProvider.fetchAvailable client, options, (err, data) ->
            expect(err?.message).to.satisfy (msg) ->
              return msg in [notImplementedMessage, 'Credential failed.']
        , done



    it 'should be able to fetch availabe object', (done) ->

      withConvertedUserAndCredential ({ client, credential }) ->
        forEachProvider (providerSlug, provider, callback) ->

          options =
            provider   : providerSlug
            credential : credential

          ComputeProvider.fetchAvailable client, options, (err, data) ->
            if err
              expect(err.message).to.be.equal notImplementedMessage
              return callback()
            expect(err).to.not.exist
            expect(data).to.be.an 'array'
            callback()
        , done


    it 'should fail if no provider is given', (done) ->

      withDummyClient ({ client }) ->
        forEachProvider (providerSlug, provider, callback) ->
          ComputeProvider.fetchAvailable client, { provider : null }, (err, data) ->
            expect(err?.message).to.be.equal 'No such provider.'
            callback()
        , done


    it 'should fail if credential is not provided', (done) ->

      withDummyClient ({ client }) ->
        forEachProvider (providerSlug, provider, callback) ->
          options = { provider : providerSlug }

          ComputeProvider.fetchAvailable client, options, (err, data) ->
            expect(err?.message).to.satisfy (msg) ->
              return msg in [notImplementedMessage, 'Credential is required.']
            callback()
        , done


    it 'should fail if given credential is not valid', (done) ->

      withDummyClient ({ client }) ->
        forEachProvider (providerSlug, provider, callback) ->

          options =
            provider   : providerSlug
