GS-2555

alex

15 hours ago a82027a51a3056e574b9c6c8941a7a16f5841126

 test/testKursLp.js

@@ -1,11 +1,9 @@
const expect = require("chai").expect

const settings = require("../settings")
const libIlias = require("../lib/libIlias")
const db = require("../lib/db")
const testData = require("./data")
const dayjs = require("dayjs");
const {auswerten, partitionDates} = require("../lib/libLp");
const {alleAuswerten, auswerten, partitionDates} = require("../lib/libLp");

/////////////////////////////////////////////////////////////////////////

@@ -221,6 +219,136 @@
         expect(auswerten([item(0, recent()), item(0, recent()), item(0, recent())])).to.equal(0)
      })

      /////// stale dates (outside the one-month ballpark)

      it("stale: should return the status when all items are stale and equal", function () {
         expect(auswerten([item(2, stale()), item(2, stale())])).to.equal(2)
      })

      it("stale: should return 1 when all stale items are mixed (0,2)", function () {
         expect(auswerten([item(0, stale()), item(2, stale())])).to.equal(1)
      })

      it("stale: should return 3 when all stale items are 3", function () {
         expect(auswerten([item(3, stale()), item(3, stale())])).to.equal(3)
      })

      it("stale: should return the status for a single stale item", function () {
         expect(auswerten([item(2, stale())])).to.equal(2)
         expect(auswerten([item(3, stale())])).to.equal(3)
      })

      it("stale: a stale 3 should not force 3 when a recent item exists", function () {
         expect(auswerten([item(3, stale()), item(2, recent())])).to.equal(1)
      })

      it("stale: a stale 3 should still force 3 when a recent 3 exists", function () {
         expect(auswerten([item(3, stale()), item(3, recent())])).to.equal(3)
      })

      it("stale: should return 1 when all recent statuses are equal but a stale item exists", function () {
         expect(auswerten([item(0, recent()), item(0, recent()), item(0, stale())])).to.equal(1)
      })

      it("stale: should return 1 for a recent 2 plus a stale 2", function () {
         expect(auswerten([item(2, recent()), item(2, stale())])).to.equal(1)
      })

      it("stale: should ignore a stale item when recent statuses are already mixed", function () {
         expect(auswerten([item(0, recent()), item(2, recent()), item(0, stale())])).to.equal(1)
      })

      it("stale: boundary - item just inside the month counts as recent", function () {
         const now = dayjs()
         const inside = now.subtract(1, "month").add(1, "day").toDate()
         expect(auswerten([item(0, now.toDate()), item(0, inside)])).to.equal(0)
      })

      it("stale: boundary - item just outside the month counts as stale", function () {
         const now = dayjs()
         const outside = now.subtract(1, "month").subtract(1, "day").toDate()
         expect(auswerten([item(0, now.toDate()), item(0, outside)])).to.equal(1)
      })

   })

   describe('the function alleAuswerten()', function () {

      const recent = () => dayjs().subtract(1, "day").toDate()
      const stale = () => dayjs().subtract(2, "month").toDate()
      // build a raw row like the ones coming from getKursUnterobjektLp()
      const row = (usr_id, status, date, extra = {}) => Object.assign({
         usr_id,
         login: `login${usr_id}`,
         firstname: `First${usr_id}`,
         lastname: `Last${usr_id}`,
         obj_id: 32212,
         item_id: 1,
         item_obj_id: 100,
         status,
         status_changed: date,
      }, extra)

      it("should return an empty array for empty input", function () {
         expect(alleAuswerten([])).to.be.an("array").and.to.have.lengthOf(0)
      })

      it("should return one row per user", function () {
         const res = alleAuswerten([
            row(1, 0, recent()), row(1, 2, recent()), row(1, 1, recent()),
            row(2, 2, recent()),
         ])
         expect(res).to.be.an("array").and.to.have.lengthOf(2)
         expect(res.map(r => r.usr_id).sort()).to.deep.equal([1, 2])
      })

      it("should group all items of a user into a single result row", function () {
         const res = alleAuswerten([
            row(1, 0, recent()), row(1, 0, recent()), row(1, 0, recent()),
         ])
         expect(res).to.have.lengthOf(1)
         expect(res[0].usr_id).to.equal(1)
      })

      it("should keep users separated", function () {
         const res = alleAuswerten([
            row(1, 0, recent()), row(1, 2, recent()),  // user 1 -> mixed -> 1
            row(2, 2, recent()), row(2, 2, recent()),  // user 2 -> all 2 -> 2
         ])
         const byId = Object.fromEntries(res.map(r => [r.usr_id, r.status]))
         expect(byId[1]).to.equal(1)
         expect(byId[2]).to.equal(2)
      })

      it("should order the result by usr_id ascending", function () {
         const res = alleAuswerten([
            row(7, 0, recent()), row(3, 0, recent()), row(7, 1, recent()),
         ])
         expect(res.map(r => r.usr_id)).to.deep.equal([3, 7])
      })

      /////// stale dates (outside the one-month ballpark)

      it("stale: should return the status when all of a user's items are stale and equal", function () {
         const res = alleAuswerten([row(1, 2, stale()), row(1, 2, stale())])
         expect(res[0].status).to.equal(2)
      })

      it("stale: should return 1 when a user's stale items are mixed", function () {
         const res = alleAuswerten([row(1, 0, stale()), row(1, 2, stale())])
         expect(res[0].status).to.equal(1)
      })

      it("stale: a stale item should turn equal recent statuses into 1", function () {
         const res = alleAuswerten([row(1, 0, recent()), row(1, 0, stale())])
         expect(res[0].status).to.equal(1)
      })

      it("stale: should still return 3 when a recent item of the user is 3", function () {
         const res = alleAuswerten([row(1, 3, recent()), row(1, 3, stale())])
         expect(res[0].status).to.equal(3)
      })

   })

})