lodash#extend JavaScript Examples

describe("Without browserStorage", function () {
    beforeEach(() => localStorage.clear());

    describe("on a Collection", function () {

        it("should use `ajaxSync`", function () {
            const TestCollection = Collection.extend();
            const collection = new TestCollection();
            const method = getSyncMethod(collection);
            assert.equal(method, sync);
        });
    });

    describe("on a Model", function () {

        it("should use `ajaxSync`", function () {
            const TestModel = Model.extend();
            const model = new TestModel();
            const method = getSyncMethod(model);
            assert.equal(method, sync);
        });
    });
});

makeSelectReposFormattedData = () =>
  createSelector(
    makeSelectRepos('repo'),
    makeSelectRepos('filter'),
    makeSelectRepos('search'),
    makeSelectRepos('shouldSearch'),
    (repo, filter, { contributorInput, issueInput }) => {
      const { activity, contributors, issues, ...restProps } = repo;
      const newIssues = extend([], issues);
      let returnObj = {};
      if (contributors) {
        const filteredContributors = filterContributors(
          contributors,
          contributorInput,
        );
        returnObj = { contributors: filteredContributors, ...restProps };
      }
      if (issues) {
        const filteredIssues = filterIssues(newIssues, filter, issueInput);
        returnObj = { issues: filteredIssues, ...returnObj };
      }
      if (activity) {
        const filteredActivity = activity.filter(
          el =>
            el.actionType !== 'add_watching' &&
            el.actionType !== 'remove_watching' &&
            el.actionType !== 'add_attempting' &&
            el.actionType !== 'remove_attempting',
        );
        const formattedActivity = filteredActivity.map(el =>
          formatActivity(el),
        );
        returnObj = { activity: formattedActivity, ...returnObj };
      }
      return returnObj;
    },
  )

describe("Storage using localStorage", function () {

    const attributes = {
        string: "String",
        string2: "String 2",
        number: 1337
    };

    const onError = function (model, resp, options) {
        throw new Error(resp);
    };

    describe("on a Collection", function () {
        beforeEach(() => localStorage.clear());

        const TestModel = Model.extend({
            defaults: attributes
        });

        const TestCollection = Collection.extend({
            model: TestModel,
            browserStorage: new Storage("collectionStore", "local")
        });

        it("should use `localSync`", function () {
            const collection = new TestCollection();
            collection.fetch();
            const method = getSyncMethod(collection);
            assert.equal(method.__name__, 'localSync');
        });

        it("should initially be empty", function () {
            const collection = new TestCollection();
            collection.fetch();
            assert.equal(collection.length, 0);
        });


        describe("create", function () {
            beforeEach(() => localStorage.clear());

            it("should have 1 model", async function () {
                const collection = new TestCollection();
                const model = await new Promise((resolve, reject) => collection.create({}, {'success': resolve}));
                assert.equal(collection.length, 1);
            });

            it("should have a populated model", async function () {
                const collection = new TestCollection();
                const model = await new Promise((resolve, reject) => collection.create({}, {'success': resolve}));
                assert.equal(collection.length, 1);
                assert.deepEqual(model.toJSON(), extend(clone(attributes), {'id': model.id}));
            });

            it("should have assigned an `id` to the model", async function () {
                const collection = new TestCollection();
                const model = await new Promise((resolve, reject) => collection.create({}, {'success': resolve}));
                await model.collection.browserStorage.storeInitialized;
                assert.isDefined(model.id);
            });

            it("should be saved to the localstorage", async function () {
                const collection = new TestCollection();
                const model = await new Promise((resolve, reject) => collection.create({}, {'success': resolve}));
                await model.collection.browserStorage.storeInitialized;
                assert.isNotNull(root.localStorage.getItem('localforage/collectionStore'+'-'+model.id));
            });
        });

        describe("get (by `id`)", function () {
            beforeEach(() => localStorage.clear());

            it("should find the model with its `id`", async function () {
                const collection = new TestCollection();
                const model = await new Promise((resolve, reject) => collection.create({}, {'success': resolve}));
                await model.collection.browserStorage.storeInitialized;
                assert.deepEqual(collection.get(model.id), model);
            });
        });

        describe("instances", function () {
            beforeEach(() => localStorage.clear());

            describe("when saved", function () {
                beforeEach(() => localStorage.clear());

                it("should persist the changes", async function () {
                    const collection = new TestCollection();
                    const model = await new Promise((resolve, reject) => collection.create({}, {'success': resolve}));
                    model.save({'string': "String 0"});
                    collection.fetch();

                    assert.equal(model.get("string"), "String 0");
                });

                describe("with a new `id`", function () {
                    beforeEach(() => localStorage.clear());

                    it("should have a new `id`", async function () {
                        const collection = new TestCollection();
                        const model = await new Promise((resolve, reject) => collection.create({}, {'success': resolve}));
                        model.save({'id': 1});
                        collection.fetch();

                        assert.equal(model.id, 1);
                    });

                    it("should have kept its old properties", async function () {
                        const collection = new TestCollection();
                        const model = await new Promise((resolve, reject) => collection.create({}, {'success': resolve}));
                        model.save({'id': 1});
                        collection.fetch();

                        const withId = clone(attributes);
                        withId.id = 1;
                        assert.deepEqual(model.toJSON(), withId);
                    });

                    it("should be saved in localstorage by new id", async function () {
                        const collection = new TestCollection();
                        const model = await new Promise((resolve, reject) => collection.create({}, {'success': resolve}));
                        model.save({'id': 1});
                        await new Promise((resolve, reject) => collection.fetch({'success': resolve}));
                        assert.isNotNull(root.localStorage.getItem('localforage/collectionStore-1'));
                    });
                });
            });


            describe("destroy", function () {
                beforeEach(() => localStorage.clear());

                it("should remove all items from the collection and its store", async function () {
                    const collection = new TestCollection();
                    await Promise.all(range(5).map(i => new Promise((resolve, reject) => collection.create({}, {'success': resolve}))));
                    assert.equal(collection.length, 5);
                    while (collection.length) {
                        collection.at(0).destroy();
                    }
                    const beforeFetchLength = collection.length;
                    collection.fetch();
                    const afterFetchLength = collection.length;

                    assert.equal(beforeFetchLength, 0);
                    assert.equal(afterFetchLength, 0);
                });
            });

            describe("with a different `idAttribute`", function () {

                it("should use the custom `idAttribute`", async function () {
                    const TestModel = Model.extend({
                        defaults: attributes,
                        idAttribute: "_id"
                    });
                    const TestCollection = Collection.extend({
                        model: TestModel,
                        browserStorage: new Storage("collection2Store", "local")
                    });

                    const collection = new TestCollection();
                    const model = await new Promise(resolve => collection.create({}, {'success': resolve}));
                    assert.equal(collection.first().id, collection.first().get("_id"));
                });
            });
        });
    });

    describe("on a Model", function () {
        beforeEach(() => localStorage.clear());

        const TestModel = Model.extend({
            defaults: attributes,
            browserStorage: new Storage("modelStore", "local")
        });

        it("should use `localSync`", function () {
            const model = new TestModel();
            assert.equal(getSyncMethod(model).__name__, 'localSync');
        });

        describe("fetch", function () {
            beforeEach(() => localStorage.clear());

            it('should fire sync event on fetch', function(done) {
                const model = new TestModel(attributes);
                model.on('sync', () => done());
                model.fetch();
            });
        });

        describe("save", function () {
            beforeEach(() => localStorage.clear());

            it("should have assigned an `id` to the model", async function () {
                const model = new TestModel();
                await new Promise((resolve, reject) => model.save(null, {'success': resolve}));
                model.fetch();
                assert.isDefined(model.id);
            });

            it("should be saved to the localstorage", async function () {
                const model = new TestModel();
                await new Promise((resolve, reject) => model.save(null, {'success': resolve}));
                assert.isNotNull(root.localStorage.getItem('localforage/modelStore'+'-'+model.id));
            });

            describe("with new attributes", function () {

                it("should persist the changes", async function () {
                    const model = new TestModel();
                    await new Promise((resolve, reject) => model.save({number: 42}, {'success': resolve}));
                    model.fetch();
                    assert.deepEqual(model.toJSON(), extend(clone(attributes), {id: model.id, number: 42}));
                });
            });

            describe('fires events', function () {

                it('should fire sync event on save', function(done) {
                    const model = new TestModel();
                    model.on('sync', () => done());
                    model.save({foo: 'baz'});
                });
            });
        });

        describe("destroy", function () {

            it("should have removed the instance from the store", async function () {
                const model = new TestModel();
                await new Promise((resolve, reject) => model.save(null, {'success': resolve}));
                const store = model.browserStorage.store;
                let item = await store.getItem(model.browserStorage.getItemName(model.id));
                assert.isNotNull(item);
                await new Promise((resolve, reject) => model.destroy({'success': resolve}));
                item = await store.getItem(model.browserStorage.getItemName(model.id));
                assert.isNull(item);
            });
        });
    });
});