     it 'should be able to fetch availabe object', (done) ->
 
       withConvertedUserAndCredential ({ client, credential }) ->
-        forEachProvider (providerSlug) ->
+        forEachProvider (providerSlug, provider, callback) ->
 
           options =
             provider   : providerSlug
             credential : credential
 
           ComputeProvider.fetchAvailable client, options, (err, data) ->
-            return expect(err.message).to.be.equal notImplementedMessage  if err
+            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) ->
+        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) ->
+        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) ->
+        forEachProvider (providerSlug, provider, callback) ->
 
           options =
             provider   : providerSlug

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

            ->
              JMachine.one { _id : machine._id }, (err, machine) ->
                expect(err).to.not.exist
                expect(machine).to.not.exist
                queue.next()

          ]

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


