@qooxdoo/framework/source/class/qx/test/data/store/Offline.js

The JS Framework for Coders

/* ************************************************************************

   qooxdoo - the new era of web development

   http://qooxdoo.org

   Copyright:
     2004-2011 1&1 Internet AG, Germany, http://www.1und1.de

   License:
     MIT: https://opensource.org/licenses/MIT
     See the LICENSE file in the project's top-level directory for details.

   Authors:
     * Martin Wittemann (martinwittemann)

************************************************************************ */
qx.Class.define("qx.test.data.store.Offline", {
  extend: qx.dev.unit.TestCase,
  include: [qx.dev.unit.MRequirements, qx.dev.unit.MMock],

  members: {
    __store: null,
    __testKey: "qx-unit-test",

    hasLocalStorage() {
      return qx.core.Environment.get("html.storage.local");
    },

    hasQxDebug() {
      return qx.core.Environment.get("qx.debug");
    },

    setUp() {
      this.require(["localStorage"]);
    },

    tearDown() {
      this.getSandbox().restore();

      if (this.__store) {
        this.__store.dispose();
      }
      // erase the data from the storages
      qx.bom.Storage.getLocal().removeItem(this.__testKey);
    },

    __initDefaultStore() {
      this.__store = new qx.data.store.Offline(this.__testKey, "local");
    },

    __createDefaultModel() {
      return qx.data.marshal.Json.createModel({ a: "a" }, true);
    },

    testCreate() {
      this.require(["qxDebug"]);

      var store;
      this.assertException(function () {
        store = new qx.data.store.Offline();
      });

      // fallback for the storage is local
      store = new qx.data.store.Offline(this.__testKey);
      this.assertEquals(store._storage, qx.bom.Storage.getLocal());
      store.dispose();

      // assert no exception
      this.__initDefaultStore();
      this.assertEquals(this.__testKey, this.__store.getKey());
    },

    testCreateWithDelegate() {
      var del = {};
      var spy = this.spy(qx.data.marshal, "Json");
      var store = new qx.data.store.Offline(this.__testKey, "local", del);
      this.assertCalledWith(spy, del);

      store.dispose();
    },

    testCheckEmptyModel() {
      this.__initDefaultStore();
      this.assertNull(this.__store.getModel());

      var model = this.__createDefaultModel();
      this.__store.setModel(model);
      this.__store.setModel(null);

      this.wait(
        1000,
        function () {
          this.assertNull(this.__store.getModel());

          model.dispose();
        }.bind(this)
      );
    },

    testSetModel() {
      this.__initDefaultStore();

      var model = this.__createDefaultModel();
      this.__store.setModel(model);
      this.wait(
        1000,
        function () {
          this.assertEquals("a", this.__store.getModel().getA());

          model.dispose();
        }.bind(this)
      );
    },

    testSetModelDebounce() {
      this.__initDefaultStore();

      var storeModelCallback = this.spy(this.__store._storage, "setItem");
      var model = this.__createDefaultModel();
      this.__store.setModel(model);
      model.setA("b");
      model.setA("c");

      this.wait(
        1000,
        function () {
          this.assertCalledOnce(storeModelCallback);
        },
        this
      );
    },

    testChangeModel() {
      this.__initDefaultStore();

      var model = this.__createDefaultModel();
      this.__store.setModel(model);

      this.wait(
        1000,
        function () {
          this.assertEquals("a", this.__store.getModel().getA());

          model.setA("A");
          this.assertEquals("A", this.__store.getModel().getA());

          model.dispose();
        }.bind(this)
      );
    },

    testModelWriteRead() {
      this.__initDefaultStore();

      var model = this.__createDefaultModel();
      this.__store.setModel(model);

      this.wait(
        1000,
        function () {
          this.assertEquals("a", this.__store.getModel().getA());

          // dispose the store to test the load of the model
          this.__store.dispose();
          model.dispose();

          this.__initDefaultStore();
          this.assertNotNull(this.__store.getModel());
          this.assertEquals("a", this.__store.getModel().getA());
        }.bind(this)
      );
    },

    testModelRead() {
      this.stub(qx.bom.Storage.getLocal(), "getItem").returns({ b: "b" });
      this.__initDefaultStore();

      this.assertNotUndefined(this.__store.getModel());
      this.assertFunction(this.__store.getModel().getB);
      this.assertEquals("b", this.__store.getModel().getB());
    },

    testUpdateModel() {
      this.__initDefaultStore();

      var model = this.__createDefaultModel();
      this.__store.setModel(model);

      this.wait(
        1000,
        function () {
          this.assertEquals("a", this.__store.getModel().getA());

          // dispose the store to test the load of the model
          this.__store.dispose();
          model.dispose();

          this.__initDefaultStore();
          this.assertNotNull(this.__store.getModel());
          this.__store.getModel().setA("b");

          this.wait(
            1000,
            function () {
              this.assertEquals("b", this.__store.getModel().getA(), "1");

              // dispose the store to test the load of the model
              this.__store.dispose();

              this.__initDefaultStore();
              this.assertNotNull(this.__store.getModel());
              this.assertEquals("b", this.__store.getModel().getA(), "2");
            }.bind(this)
          );
        }.bind(this)
      );
    },

    testReplaceModel() {
      this.__initDefaultStore();

      var model1 = this.__createDefaultModel();
      this.__store.setModel(model1);

      var model2 = qx.data.marshal.Json.createModel({ x: "x" }, true);
      this.__store.setModel(model2);

      this.wait(
        1000,
        function () {
          this.__initDefaultStore();
          this.assertNotNull(this.__store.getModel());
          this.assertFunction(this.__store.getModel().getX);
          this.assertEquals("x", this.__store.getModel().getX());

          // get rid of all the created stuff
          this.__store.dispose();
          model1.dispose();
          model2.dispose();
        }.bind(this)
      );
    },

    testBigModel() {
      var data = { a: [{ b: 1, C: true }, 12.567, "a"] };
      var model = qx.data.marshal.Json.createModel(data, true);

      this.__initDefaultStore();

      this.__store.setModel(model);

      this.wait(
        1000,
        function () {
          this.assertEquals(
            1,
            this.__store.getModel().getA().getItem(0).getB()
          );

          this.assertEquals(
            true,
            this.__store.getModel().getA().getItem(0).getC()
          );

          this.assertEquals("a", this.__store.getModel().getA().getItem(2));

          model.dispose();
        }.bind(this)
      );
    }
  }
});