Refactor database and item retreival

Change the ugly global slaves object to be a member of the db object and
implement the items database as a separate integrety verifying class in
lib/database.
This commit is contained in:
Hornwitser committed 2019-09-04 20:43:13 +02:00
1 parent 5d6f6de379
commit 651b09b613
14 files changed
+634 -188

No files matched your search

+231
View File
@@ -0,0 +1,231 @@
/**
* Implementation of master databases
*
* @module
* @author Hornwitser
*/
"use strict";
const fs = require("fs-extra");
/**
* Converts a Map with only string keys to a JavaScript object.
*
* @param {Map} map - the Map to convert to an object.
* @return {object} - Object with the mapping's key-values as properties.
* @throws {Error} if there are non-string keys in map.
*/
function mapToObject(map) {
let obj = {};
for (let [key, value] of map) {
if (typeof key !== 'string') {
throw new Error(
`Expected all keys to be string but got ${typeof key}`
);
}
obj[key] = value;
}
return obj;
}
/**
* Load JSON file as a Map
*
* Loads the JSON file specified by path an converts it into a JavaScript Map.
* Returns an empty Map if the file does not exist.
*
* @param {string} filePath - The path to the JSON file to load.
* @throws {Error} If JSON file did not contain an object.
* @throws {Error} If an error occured reading the file.
*/
async function loadJsonAsMap(filePath) {
try {
let content = await fs.readFile(filePath);
let parsed = JSON.parse(content);
if (parsed instanceof Array) {
throw new Error(`Expected object but got array`);
}
if (parsed === null) {
throw new Error(`Expected object but got null`);
}
if (typeof parsed !== "object") {
throw new Error(`Expected object but got ${typeof parsed}`);
}
return new Map(Object.entries(parsed));
} catch (err) {
if (err.code == "ENOENT") {
// File does not exist, return empty map
return new Map();
} else {
throw err;
}
}
}
/**
* Save a Map as a JSON file
*
* Save the content of a key-value Map with only string keys as a JSON file.
* If the directory the file is to be saved into doesn't exist it will be
* created.
*
* @param {string} filePath - The path to the JSON file that will be saved.
* @param {Map} map - Map with only string keys to save.
* @throws {Error} if there are non-string keys in map.
* @throws {Error} if an error occured writing to the file.
*/
async function saveMapAsJson(filePath, map) {
let obj = mapToObject(map);
await fs.outputFile(filePath, JSON.stringify(obj, null, 4));
}
function checkName(name) {
if (typeof name !== "string") {
throw new Error("name must be a string");
}
}
function checkCount(count) {
if (typeof count !== "number" || isNaN(count)) {
throw new Error("count must be a number");
}
}
/**
* Item database
*
* Stores counts of items for the master server. Items that have not been
* stored in the database are treated as having a stored count of zero. When
* serialized the database discards entries with a zero counts, and when
* deserialized the content is verified.
*/
class ItemDatabase {
/**
* Create a new item database
*
* @param {object|undefined} serialized - An object from a previous call to
* {@link module:lib/database~ItemDatabase#serialize} to restore the
* database from. An empty database will be created if this parameter
* is left undefined.
*/
constructor(serialized) {
this._items = new Map();
// Verify the content of the serialized database
if (serialized !== undefined) {
for (let [name, count] of Object.entries(serialized)) {
checkName(name);
checkCount(count);
this._items.set(name, count);
}
}
}
/**
* Serialize item database
*
* Serialize the item database into a plain JavaScript object that can be
* turned inta a string with JSON.stringify().
*
* @returns {object} Serialized representation of the database
*/
serialize() {
let obj = {};
for (let [name, count] of this._items) {
if (count !== 0) {
obj[name] = count;
}
}
return obj;
}
/**
* Approximate size of the items database.
*
* Does not account for entries being zero in the item database.
*/
get size() {
return this._items.size;
}
/**
* Get the count of an item stored in the database
*
* Returns the count of a given item that has been stored in to the
* database. If the item has not been previously stored into the database
* then 0 is returned.
*
* @param {string} name - The name of the item to get the count of.
* @returns {number} The count of the item stored.
*/
getItemCount(name) {
checkName(name);
if (!this._items.has(name)) {
return 0
}
return this._items.get(name);
}
/**
* Adds count of an item to the database
*
* Add count copies of the item specified by name to the item database.
*
* @param {string} name - The name of the item to add.
* @param {number} count - The count of item to remove.
*/
addItem(name, count) {
checkName(name);
checkCount(count);
if (this._items.has(name)) {
count += this._items.get(name);
}
this._items.set(name, count);
};
/**
* Removes count of an item from the database.
*
* Remove count copies of the item specified by name from the item database
* If count is greater than the currently stored count the stored item
* count will become negative.
*
* @param {string} name - The name of the item to remove.
* @param {number} count - The count of items to remove.
*/
removeItem(name, count) {
checkName(name);
checkCount(count);
count = -count;
if (this._items.has(name)) {
count += this._items.get(name);
}
this._items.set(name, count);
};
}
module.exports = {
mapToObject,
loadJsonAsMap,
saveMapAsJson,
ItemDatabase,
}
+212
View File
@@ -0,0 +1,212 @@
const assert = require("assert").strict;
const fs = require("fs-extra");
const database = require("lib/database");
describe("lib/database", function() {
describe("mapToObject()", function() {
it("should throw on non-string key", function() {
assert.throws(
() => database.mapToObject(new Map([[1, 1]])),
new Error("Expected all keys to be string but got number")
);
assert.throws(
() => database.mapToObject(new Map([[Symbol(), 1]])),
new Error("Expected all keys to be string but got symbol")
);
});
it("should throw convert a map to an object", function() {
assert.deepEqual(
database.mapToObject(new Map([['a', 1], ['b', true]])),
{'a': 1, 'b': true}
);
});
});
describe("loadJsonAsMap()", function() {
let badTypes = ['null', 'array', 'number', 'string', 'boolean'];
for (let type of badTypes) {
it(`should reject on ${type} JSON`, async function() {
await assert.rejects(
database.loadJsonAsMap(`test/json/${type}.json`),
new Error(`Expected object but got ${type}`)
);
});
}
it("should work on empty object JSON", async function() {
assert.deepEqual(
await database.loadJsonAsMap('test/json/object.json'),
new Map()
);
});
it("should work on object JSON", async function() {
assert.deepEqual(
await database.loadJsonAsMap('test/json/load_map.json'),
new Map([['a', 1], ['b', true]])
);
});
it("should give an empty Map for non-existant file", async function() {
assert.deepEqual(
await database.loadJsonAsMap('test/json/does-not-exist'),
new Map()
);
});
});
describe("saveMapAsJson()", function() {
it("should save a mapping as JSON", async function() {
let testFile = 'test/json/save_map.json';
async function deleteTestFile() {
try {
await fs.unlink(testFile);
} catch (err) {
/* istanbul ignore if */
if (err.code !== 'ENOENT') {
throw err;
}
}
}
await deleteTestFile();
await database.saveMapAsJson(
testFile, new Map([['c', {}], ['d', "foo"]])
);
assert.equal(
await fs.readFile(testFile, {encoding: 'utf-8'}),
'{\n "c": {},\n "d": "foo"\n}'
);
await deleteTestFile();
});
});
describe("class ItemDatabase", function() {
describe("constructor()", function() {
it("should create an empty database with no args", function() {
let items = new database.ItemDatabase();
assert.deepEqual(items._items, new Map());
});
it("should restore the passed serialized database", function() {
let items = new database.ItemDatabase({'a': 1, 'b': 2});
assert.deepEqual(items._items, new Map([['a', 1], ['b', 2]]));
});
it("should throw on invalid serialized database", function() {
assert.throws(
() => new database.ItemDatabase({'a': NaN}),
new Error("count must be a number")
);
assert.throws(
() => new database.ItemDatabase({'a': 'a'}),
new Error("count must be a number")
);
});
});
describe(".serialize()", function() {
it("should return a serialized database", function() {
let items = new database.ItemDatabase({'a': 10});
assert.deepEqual(items.serialize(), {'a': 10});
});
it("should remove zero count entries", function() {
let items = new database.ItemDatabase({'a': 0});
assert.deepEqual(items.serialize(), {});
});
});
describe(".size", function() {
it("should give an approximate size of the database", function() {
let items = new database.ItemDatabase({'a': 10});
assert.equal(items.size, 1);
});
});
describe(".getItemCount()", function() {
it("should return the count of the given item", function() {
let items = new database.ItemDatabase({'a': 10});
assert.equal(items.getItemCount('a'), 10);
});
it("should return zero if item does not exist", function() {
let items = new database.ItemDatabase();
assert.equal(items.getItemCount('b'), 0);
});
it("should throw on invalid name", function() {
let items = new database.ItemDatabase();
assert.throws(
() => items.getItemCount(2),
new Error("name must be a string")
);
});
});
describe(".addItem()", function() {
it("should add a new item", function() {
let items = new database.ItemDatabase();
items.addItem('a', 10);
assert.deepEqual(items._items, new Map([['a', 10]]));
})
it("should add an existing item", function() {
let items = new database.ItemDatabase({'a': 10});
items.addItem('a', 10);
assert.deepEqual(items._items, new Map([['a', 20]]));
})
it("should throw on invalid name", function() {
let items = new database.ItemDatabase();
assert.throws(
() => items.addItem(2, 10),
new Error("name must be a string")
);
});
it("should throw on invalid count", function() {
let items = new database.ItemDatabase();
assert.throws(
() => items.addItem('a', NaN),
new Error("count must be a number")
);
});
});
describe(".removeItem()", function() {
it("should remove an existing item", function() {
let items = new database.ItemDatabase({'a': 20});
items.removeItem('a', 10);
assert.deepEqual(items._items, new Map([['a', 10]]));
})
it("should turn a non-existing item negative", function() {
let items = new database.ItemDatabase();
items.removeItem('a', 10);
assert.deepEqual(items._items, new Map([['a', -10]]));
})
it("should throw on invalid name", function() {
let items = new database.ItemDatabase();
assert.throws(
() => items.removeItem(2, 10),
new Error("name must be a string")
);
});
it("should throw on invalid count", function() {
let items = new database.ItemDatabase();
assert.throws(
() => items.removeItem('a', 'b'),
new Error("count must be a number")
);
});
});
});
});