test_connection_closes_all_pools.js

Enable keyboard shortcuts

/* Any copyright is dedicated to the Public Domain.

   http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

const { Pool } = require("resource://devtools/shared/protocol/Pool.js");

const {

  DevToolsServerConnection,

} = require("resource://devtools/server/devtools-server-connection.js");

const {

  LocalDebuggerTransport,

} = require("resource://devtools/shared/transport/local-transport.js");

// Helper class to assert how many times a Pool was destroyed

class FakeActor extends Pool {

  constructor(...args) {

    super(...args);

    this.destroyedCount = 0;

  destroy() {

    this.destroyedCount++;

    super.destroy();

add_task(async function () {

  const transport = new LocalDebuggerTransport();

  const conn = new DevToolsServerConnection("prefix", transport);

  // Setup a flat pool hierarchy with multiple pools:

//

  // - pool1

  //   |

  //   \- actor1

//

  // - pool2

  //   |

  //   |- actor2a

  //   |

  //   \- actor2b

//

  // From the point of view of the DevToolsServerConnection, the only pools

  // registered in _extraPools should be pool1 and pool2. Even though actor1,

  // actor2a and actor2b extend Pool, they don't manage other pools.

  const actor1 = new FakeActor(conn);

  const pool1 = new Pool(conn, "pool-1");

  pool1.manage(actor1);

  const actor2a = new FakeActor(conn);

  const actor2b = new FakeActor(conn);

  const pool2 = new Pool(conn, "pool-2");

  pool2.manage(actor2a);

  pool2.manage(actor2b);

  ok(!!actor1.actorID, "actor1 has a valid actorID");

  ok(!!actor2a.actorID, "actor2a has a valid actorID");

  ok(!!actor2b.actorID, "actor2b has a valid actorID");

  conn.close();

  equal(actor1.destroyedCount, 1, "actor1 was successfully destroyed");

  equal(actor2a.destroyedCount, 1, "actor2 was successfully destroyed");

  equal(actor2b.destroyedCount, 1, "actor2 was successfully destroyed");

});

add_task(async function () {

  const transport = new LocalDebuggerTransport();

  const conn = new DevToolsServerConnection("prefix", transport);

  // Setup a nested pool hierarchy:

//

  // - pool

  //   |

  //   \- parentActor

  //      |

  //      \- childActor

//

  // Since parentActor is also a Pool from the point of view of the

  // DevToolsServerConnection, it will attempt to destroy it when looping on

  // this._extraPools. But since `parentActor` is also a direct child of `pool`,

  // it has already been destroyed by the Pool destroy() mechanism.

//

  // Here we check that we don't call destroy() too many times on a single Pool.

  // Even though Pool::destroy() is stable when called multiple times, we can't

  // guarantee the same for classes inheriting Pool.

  const childActor = new FakeActor(conn);

  const parentActor = new FakeActor(conn);

  const pool = new Pool(conn, "pool");

  pool.manage(parentActor);

  parentActor.manage(childActor);

  ok(!!parentActor.actorID, "customActor has a valid actorID");

  ok(!!childActor.actorID, "childActor has a valid actorID");

  conn.close();

  equal(parentActor.destroyedCount, 1, "parentActor was destroyed once");

  equal(parentActor.destroyedCount, 1, "customActor was destroyed once");

});