Цепочка асинхронных промисов с 1 разрешением и 1 отклонением?

Вы можете буквально переписать свое решение для обещаний:

function sleep(ms) {
    return new Promise(function(resolve) {
        setTimeout(resolve, ms);
    });
}

function clickSpeed() {
    if ( test('one') ) {
        return sleep(500).then(function() {
            if ( test('two') ) {
                return sleep(500).then(function() {
                    if ( test('three') ) {
                        return sleep(500).then(function() {
                            console.log('resolving...');
                        });
                    }
                    console.log('rejecting...');
                    return Promise.reject();
                });
            }
            console.log('rejecting...');
            return Promise.reject();
        });
    }
    console.log('rejecting...');
    return Promise.reject();
}

Тем не менее, это все еще довольно некрасиво. Я бы предпочел обратить if/else в качестве первого шага:

function clickSpeed() {
    if (!test('one')) {
        console.log('rejecting...');
        return Promise.reject();
    }
    return sleep(500).then(function() {
        if (!test('two')) {
            console.log('rejecting...');
            return Promise.reject();
        }
        return sleep(500).then(function() {
            if (!test('three')) {
                console.log('rejecting...');
                return Promise.reject();
            }
            return sleep(500).then(function() {
                console.log('resolving...');
            });
        });
    });
}

Но затем мы также можем отменить эти обратные вызовы. Обычно это невозможно, когда вы выполняете ветвление с помощью if, но в этом случае единственным альтернативным результатом является отклонение, похожее на throwing, и не будет выполняться цепочка обратных вызовов then.

function clickSpeed() {
    return Promise.resolve() // only so that the callbacks look alike, and to use throw
    .then(function() {
        if (!test('one')) {
            console.log('rejecting...');
            throw;
        }
        return sleep(500);
    }).then(function() {
        if (!test('two')) {
            console.log('rejecting...');
            throw;
        }
        return sleep(500)
    }).then(function() {
        if (!test('three')) {
            console.log('rejecting...');
            throw;
        }
        return sleep(500);
    }).then(function() {
        console.log('resolving...');
    });
}

Теперь вы можете заставить эти test вызывать само исключение, чтобы вам больше не нужны были if, и вы можете переместить оператор console.log('rejecting...'); в .catch().

И хотя я предполагаю, что это только ваш пример, где все шаги выглядят одинаково, вы также можете легко создать цепочку обещаний динамически из списка:

function clickSpeed() {
    return ['one', 'two', 'three'].reduce(function(p, cur) {
        return p.then(function() {
            if (!test(cur))
                throw new Error('rejecting...');
            else
                return sleep(500);
        });
    }, Promise.resolve());
}

Поскольку ваше время монотонно, а ваша «работа» предопределена, я бы реорганизовал код, чтобы использовать setInterval() с контекстом, чтобы отслеживать требуемую «работу» или «шаг». На самом деле вам даже не обязательно использовать Promise при этом, хотя вы все равно можете, и если вы хотите добавить обработчики цепочек, это хорошая идея:

function clickSpeed(resolve, reject) {
  var interval = setInterval(function(work) {
    try {
      var current = work.shift();
      if(!test(current)) { // Do current step's "work"
        clearInterval(interval); // reject on failure and clear interval
        console.log('rejecting...', current);
        reject();
      }
      else if(!work.length) { // If this was the last step
        clearInterval(interval); // resolve (success!) and clear interval
        console.log('resolving...');
        resolve();
      }
    }
    catch(ex) { // reject on exceptions as well
      reject(ex);
      clearInterval(interval);
    }
  }, 500, ['one', 'two', 'three']); // "work" array
}

Функция может быть вызвана «напрямую» с обработчиками разрешения/отклонения или использована в качестве аргумента конструктора Promise.

См. полный пример в модифицированном JSFiddle.

Чтобы ответить на комментарий Берги слишком много шаблонного кода, код можно написать более лаконично, без ведения журнала:

function clickSpeed(resolve, reject) {
    function done(success, val) {
        clearInterval(interval);
        success ? resolve(val) : reject(val);
    }

    var interval = setInterval(function(work) {
        try {
            if(test(work.shift()) || done(false)) {
                work.length || done(true);
            }
        }
        catch(ex) { // reject on exceptions as well
            done(false, ex);
        }
    }, 500, ['one', 'two', 'three']); // "work" array
}

Во-первых, давайте очень тонко изменим вступительную фразу, чтобы отразить более типичное и более подходящее использование обещаний.

Вместо :

функция, которая должна что-то сделать асинхронно, за несколько шагов

скажем:

функция, которая должна что-то сделать за несколько асинхронных шагов

Таким образом, мы могли бы сначала написать функцию, которая выполняет цепочку промисов и возвращает результирующий промис:

function doAnAsyncSequence() {
    return Promise.resolve()
    .then(function() {
        doSomethingAsync('one');
    })
    .then(function() {
        doSomethingAsync('two');
    })
    .then(function() {
        doSomethingAsync('three');
    });
}

И ради демонстрации мы можем написать doSomethingAsync() так, чтобы он возвращал обещание, которое имеет шанс 50:50 быть разрешенным: отклоненным (что здесь более полезно, чем задержка):

function doSomethingAsync(x) {
    return new Promise(function(resolve, reject) {
        if(Math.random() > 0.5 ) {
            resolve(x);
        } else {
            reject(x); // importantly, this statement reports the input argument `x` as the reason for failure, which can be read and acted on where doSomethingAsync() is called.
        }
    });
}

Затем центральная часть вопроса:

когда это не удается?

можно перефразировать:

когда это не удалось?

это более реалистичный вопрос, потому что обычно мы вызываем асинхронные процессы, на которые у нас мало влияния (они могут работать на каком-то сервере где-то еще в мире) и которые, как мы надеемся, завершатся успешно, но могут случайно выйти из строя. Если это так, наш код (и/или наши конечные пользователи) хотели бы знать, какой из них не удался и почему.

В случае doAnAsyncSequence() мы можем сделать это следующим образом:

doAnAsyncSequence().then(function(result) {
    console.log(result); // if this line executes, it will always log "three", the result of the *last* step in the async sequence.
}, function(reason) {
    console.log('error: ' + reason);
});

Хотя в doAnAsyncSequence() или doSomethingAsync() нет оператора console.log() :

• в случае успеха мы можем наблюдать общий результат (который в этом примере всегда будет «три»).
• в случае ошибки мы точно знаем, какой из асинхронных шагов вызвал сбой процесса («один», «два» или «три»).

Попробуйте

Итак, это теория.

Чтобы ответить на конкретный вопрос (как я понимаю)...

для doSomethingAsync() напишите:

function test_(value, delay) {
    return new Promise(function(resolve, reject) {
        //call your own test() function immediately
        var result = test(value);
        // resolve/reject the returned promise after a delay
        setTimeout(function() {
            result ? resolve() : reject(value);
        }, delay);
    });
}

для doAnAsyncSequence() напишите:

function clickSpeed() {
    var delayAfterTest = 500;
    return Promise.resolve()
    .then(function() {
        test_('one', delayAfterTest);
    })
    .then(function() {
        test_('two', delayAfterTest);
    })
    .then(function() {
        test_('three', delayAfterTest);
    });
}

И вызовите следующим образом:

clickSpeed().then(function() {
    console.log('all tests passed');
}, function(reason) {
    console.log('test sequence failed at: ' + reason);
});