tm-apps-list-api/test/component/topStories.js

"use strict";

let assert = require("chai").assert;
let nock = require("nock");
let config = require("config");
let R = require("ramda");
let hl = require("highland");
let rewire = require("rewire");
let request = require("supertest");
let sinon = require("sinon");
let app = rewire("../../src/server");

const createPoolItem = i => {
    return {
        "Id": "nationals.2",
        "Order": i,
        "ArticleId": `nationals.${i}`
    };
};

let queryStub = sinon.stub();

let batchWriteToDynamodb = db => hl.wrapCallback((batch, cb) => {
    db.batchWrite({
        "RequestItems": {
            [config.dynamodb.tableName]: batch
        }
    }, cb);
});

function runTestsOnLocalDynmodbInstance() {
    let AWS = app.__get__("AWS");
    let dc = app.__get__("dc");
    let dynamo = new AWS.DynamoDB;
    let server = request(app(config, dc));
    return [server, dc, dynamo];
}

function mockDynamodb() {
    const db = {
        "query": (items, cb) => {
            cb(null, queryStub(items));
        }
    };
    return [request(app(config, db)), db];
}

const localOrMock = config.runTestsOnLocalDB ? runTestsOnLocalDynmodbInstance() : mockDynamodb();
let server = localOrMock[0];
let db = localOrMock[1];
let dynamo = localOrMock[2];

const createBasicArticle = id => {
    return {
        "data": {
            "id": id,
            "attributes": {}
        }
    };
};

before(() => {
    nock("http://apps-test-endpoint.com")
        .persist()
        .get(/\/(?:nationals|regionals)\/\d+\/articles\/(\d+)/)
        .reply(200, uri => createBasicArticle(R.match(/\/(?:nationals|regionals)\/\d+\/articles\/(\d+)/, uri)[1]));
});

after(() => {
    nock.restore();
});

describe("Top Stories Component", function () {

    this.timeout(5000);

    // MOCK dynmodb only
    beforeEach(() => {
        queryStub.reset();
    });

    // local dynmodb only
    before(done => {
        if (!config.runTestsOnLocalDB) return done();
        let table = require("../table.json");
        dynamo.deleteTable({
            "TableName": table.TableName
        }, () => {
            dynamo.createTable(table, done);
        });
    });

    describe("Successfully get articles", () => {

        before(done => {
            if (!config.runTestsOnLocalDB) {
                const poolItems = R.range(0, 40).map(createPoolItem);
                queryStub.returns(R.objOf("Items", poolItems));
                return done();
            }

            hl(R.range(0, 40))
                .map(i => {
                    return {
                        "Id": `nationals.2`,
                        "Order": i,
                        "ArticleId": `nationals.${i}`
                    };
                })
                .map(R.objOf("Item"))
                .map(R.objOf("PutRequest"))
                .batch(25)
                .flatMap(batchWriteToDynamodb(db))
                .collect()
                .toCallback(done);
        });

        it("get by publication id", done => {
            server
                .get("/nationals/2/top-stories")
                .end((err, res) => {
                    assert.equal(res.header['content-type'], 'application/json; charset=utf-8');
                    assert.equal(res.body.data.type, "articles");
                    assert.equal(res.body.included.length, 40);
                    res.body.included.forEach((item, i) => {
                        assert.equal(item.data.id, i);
                    });
                    done();
                });
        });
    });

    describe("Incomplete Pool", () => {

        before(done => {
            if (!config.runTestsOnLocalDB) {
                const poolItems = R.range(0, 10).map(createPoolItem);
                queryStub.returns(R.objOf("Items", poolItems));
                return done();
            }
            hl(R.range(0, 10))
                .map(i => {
                    return {
                        "Id": `nationals.1`,
                        "Order": i,
                        "ArticleId": `nationals.${i}`
                    };
                })
                .map(R.objOf("Item"))
                .map(R.objOf("PutRequest"))
                .batch(25)
                .flatMap(batchWriteToDynamodb(db))
                .collect()
                .toCallback(done);
        });

        it("handles when pool is not full", done => {
            server
                .get("/nationals/1/top-stories")
                .end((err, res) => {
                    assert.equal(res.body.data.type, "articles");
                    assert.equal(res.body.included.length, 10);
                    res.body.included.forEach((item, i) => {
                        assert.equal(item.data.id, i);
                    });
                    done();
                });
        });
    });

    describe("404 (the pool doesn't exist)", () => {

        before(() => {
            if (!config.runTestsOnLocalDB) {
                queryStub.returns(R.objOf("Items", []));
            }
        });

        it("handles when pool is not full", done => {
            server
                .get("/nationals/1234/top-stories")
                .end((err, res) => {
                    assert.equal(res.body.message, "No pools found for publication /nationals/1234");
                    assert.equal(res.body.code, "NotFoundError");
                    assert.equal(res.error.status, 404);
                    done();
                });
        });
    });

    describe("Apps Api returns error", () => {

        before(done => {
            if (!config.runTestsOnLocalDB) {
                const poolItems = R.range(0, 1).map(i => {
                    return {
                        "Id": "nationalss.3",
                        "Order": i,
                        "ArticleId": `nationalss.${i}`
                    };
                });
                queryStub.returns(R.objOf("Items", poolItems));
                return done();
            }
            hl(R.range(0, 1))
                .map(i => {
                    return {
                        "Id": `nationals.3`,
                        "Order": i,
                        "ArticleId": `nationals.${i}`
                    };
                })
                .map(R.objOf("Item"))
                .map(R.objOf("PutRequest"))
                .batch(25)
                .flatMap(batchWriteToDynamodb(db))
                .collect()
                .toCallback(done);
        });

        it("get by publication id", done => {

            nock("http://apps-test-endpoint.com")
                .get("/nationalss/3/articles/0")
                .reply(404);

            server
                .get("/nationalss/3/top-stories")
                .end((err, res) => {
                    assert.equal(res.error.status, 404);
                    // This is more to show errors do filter down correctly
                    assert.equal(res.body.message, 'No pools found for publication /nationalss/3');
                    assert.equal(res.body.code, 'NotFoundError');
                    done(err);
                });
        });
    });

    describe("Test the cache bust is called", () => {

        before(done => {
            const poolItems = R.range(0, 1).map(i => {
                return {
                    "Id": "nationals.3",
                    "Order": i,
                    "ArticleId": `nationals.${i}`
                };
            });
            queryStub.returns(R.objOf("Items", poolItems));
            return done();
        });

        it("check cache bust works", done => {
            let stub = sinon.stub();
            nock("http://org-apps-test-endpoint.com")
                .get("/nationalss/3/articles/0")
                .reply(200, () => {
                    stub();
                });
            server
                .get("/nationalss/3/top-stories?cache=false")
                .end(err => {
                    assert.equal(stub.callCount, 1);
                    done(err);
                });
        });
    });
});