move available; expose available as part of user quota

node_modules/c9/available.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _ = require("lodash");
+
+/**
+ * Substract all values of used from quota + extra
+ * This is the so-called "uncountedQuota" logic.
+ */
+function available(quota, used, extra) {
+    var keys = _.union(_.keys(quota), _.keys(used));
+
+    extra = extra || {};
+
+    return keys.reduce(function(available, key) {
+        available[key] = quota[key] || 0;
+        extra[key] = extra[key] || 0;
+
+        if (!used[key])
+            return available;
+
+        var needed = used[key] - extra[key];
+
+        if (!needed)
+            return available;
+
+        available[key] = available[key] - needed;
+        return available;
+    }, {});
+}
+
+module.exports = available;

node_modules/c9/available_test.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+"use strict";
+"use server";
+
+require("c9/setup_paths");
+require("c9/inline-mocha")(module);
+
+var assert = require("assert-diff");
+var available = require("./available");
+
+describe(__filename, function() {
+    it("Should do basic math for shared keys in the input", function() {
+        var cases = [{
+            label: "When total < used",
+            total: {
+                ram: 10,
+                disk: 5,
+            },
+            used: {
+                ram: 20,
+                disk: 5,
+            },
+            avail: {
+                ram: -10,
+                disk: 0
+            }
+        }, {
+            label: "When keys in total not in used",
+            total: {
+                ram: 10,
+                disk: 5,
+                foo: 10,
+            },
+            used: {
+                ram: 10,
+                disk: 5,
+            },
+            avail: {
+                ram: 0,
+                disk: 0,
+                foo: 10
+            }
+        }, {
+            label: "When keys in used not in total",
+            total: {
+                ram: 10,
+                disk: 5,
+            },
+            used: {
+                foo: 10,
+                ram: 10,
+                disk: 5,
+            },
+            avail: {
+                ram: 0,
+                disk: 0,
+                foo: -10
+            }
+        }, {
+            label: "When all looks normal",
+            total: {
+                ram: 10,
+                disk: 5,
+            },
+            used: {
+                ram: 5,
+                disk: 2,
+            },
+            avail: {
+                ram: 5,
+                disk: 3,
+            }
+        }, {
+            label: "With a little extra",
+            total: {
+                ram: 10,
+                disk: 6,
+            },
+            used: {
+                ram: 10,
+                disk: 5,
+            },
+            extra: {
+                ram: 3,
+                disk: 3
+            },
+            avail: {
+                ram: 3,
+                disk: 4,
+            }
+        }, {
+            label: "But extra is not more",
+            total: {
+                ram: 10,
+                disk: 10,
+            },
+            used: {
+                ram: 5,
+                disk: 5,
+            },
+            extra: {
+                ram: 5,
+                disk: 3
+            },
+            avail: {
+                ram: 10,
+                disk: 8,
+            }
+        }];
+
+        cases.forEach(function(testCase) {
+            var avail = available(testCase.total, testCase.used, testCase.extra);
+            assert.deepEqual(avail, testCase.avail, testCase.label);
+        });
+    });
+});