rafa/test/unit/core/Stream-zip.js

Rafa.js is a Javascript framework for building concurrent applications.

module.exports = (assert, Rafa) => {
  suite("zip", () => {
    test("basics", () => {
      var values = [];
      var last;
      var outer = Rafa.stream();
      var inner = Rafa.stream();
      outer.zip(inner).each(v => values.push(v)).done(v => last = v);
      outer.write(1);
      assert.equal(values.length, 0);
      inner.write(2);
      assert.equal(values.length, 1);
      assert.equal(values[0][0], 1);
      assert.equal(values[0][1], 2);
      assert.isUndefined(last);

      inner.write(3);
      assert.equal(values.length, 1);
      outer.write(4);
      assert.equal(values.length, 2);
      assert.equal(values[1][0], 4);
      assert.equal(values[1][1], 3);
      assert.isUndefined(last);
    });

    test("errors pass through", () => {
      var values = [];
      var outer = Rafa.stream();
      var inner = Rafa.stream();
      outer.zip(inner).error(v => values.push(v));
      outer.write(new Error("outer"));
      assert.equal(values.length, 1);
      assert.equal(values[0].message, "outer");
      inner.write(new Error("inner"));
      assert.equal(values.length, 2);
      assert.equal(values[1].message, "inner");
    });

    test("done error converts to error", () => {
      var value, end;
      var outer = Rafa.stream();
      var inner = Rafa.stream();
      outer.zip(inner).error(v => value = v).done(v => end = true);
      outer.write(new Error("oops"), true);
      assert.ok(value);
      assert.ok(!end);
      assert.equal(value.message, "oops");
    });

    // if a stream produces an error, it is pushed immediately and also counts
    // as a message in the cache. the cache will be set to undefined or null 
    // and a new message is pushed
    test("error counts as value", () => {
      var value, error;
      var outer = Rafa.stream();
      var inner = Rafa.stream();
      outer.zip(inner).error(v => error = v).each(v => value = v);
      outer.write(1);
      inner.write(new Error(2));
      assert.ok(value);
      assert.ok(error);
      assert.equal(error.message, 2);
      assert.equal(value[0], 1);
      assert.isUndefined(value[1]);
    });

    // done message sent once all streams produce a done message
    test("all done", () => {
      var last;
      var outer = Rafa.stream();
      var inner = Rafa.stream();
      outer.zip(inner).done(v => last = v);
      outer.write(1, true);
      assert.isUndefined(last);
      inner.write(2, true);
      assert.ok(last);
      assert.equal(last[0], 1);
      assert.equal(last[1], 2);
    });

    // an error/done message should count as a done message, send the error
    // through immediately, and then set the cache to undefined.
    test("error/done counts as done", () => {
      var last, errors = [];
      var outer = Rafa.stream();
      var inner = Rafa.stream();
      outer.zip(inner).error(e => errors.push(e)).done(v => last = v);
      outer.write(new Error(1), true);
      assert.isUndefined(last);
      assert.ok(errors[0]);
      assert.equal(errors[0].message, 1);
      inner.write(new Error(2), true);
      assert.ok(errors[1]);
      assert.equal(errors[1].message, 2);
      assert.ok(last);
      assert.equal(last.length, 2);
      assert.isUndefined(last[0]);
      assert.isUndefined(last[1]);
    });

    test("3 streams", () => {
      var last;
      var a = Rafa.stream();
      var b = Rafa.stream();
      var c = Rafa.stream();
      a.zip(b, c).each(v => last = v);
      a.write(1);
      assert.isUndefined(last);
      b.write(2);
      assert.isUndefined(last);
      c.write(3);
      assert.ok(last);
      assert.equal(last.length, 3);
      assert.equal(last[0], 1);
      assert.equal(last[1], 2);
      assert.equal(last[2], 3);
    });

    test("destroy", () => {
      var outer = Rafa.stream();
      var inner = Rafa.stream();
      var composed = outer.zip(inner);
      composed.detach();
      assert.isNull(outer.child);
      assert.isNull(inner.child);
    });
  });
};