mirror of
https://github.com/bitburner-official/bitburner-src.git
synced 2024-09-20 12:58:33 +02:00
1318 lines
59 KiB
TypeScript
1318 lines
59 KiB
TypeScript
import { CONSTANTS } from "../src/Constants";
|
|
import { Player } from "../src/Player";
|
|
import { IMap } from "../src/types";
|
|
|
|
import { Company } from "../src/Company/Company";
|
|
import { Server } from "../src/Server/Server";
|
|
|
|
import {
|
|
buyStock,
|
|
sellStock,
|
|
shortStock,
|
|
sellShort,
|
|
} from "../src/StockMarket/BuyingAndSelling";
|
|
import { IStockMarket } from "../src/StockMarket/IStockMarket";
|
|
import { Order } from "../src/StockMarket/Order";
|
|
import {
|
|
forecastForecastChangeFromCompanyWork,
|
|
forecastForecastChangeFromHack,
|
|
influenceStockThroughCompanyWork,
|
|
influenceStockThroughServerGrow,
|
|
influenceStockThroughServerHack,
|
|
} from "../src/StockMarket/PlayerInfluencing";
|
|
import { processOrders, IProcessOrderRefs } from "../src/StockMarket/OrderProcessing";
|
|
import { Stock , StockForecastInfluenceLimit } from "../src/StockMarket/Stock";
|
|
import {
|
|
cancelOrder,
|
|
deleteStockMarket,
|
|
initStockMarket,
|
|
initSymbolToStockMap,
|
|
placeOrder,
|
|
processStockPrices,
|
|
StockMarket,
|
|
SymbolToStockMap,
|
|
} from "../src/StockMarket/StockMarket";
|
|
import {
|
|
forecastChangePerPriceMovement,
|
|
getBuyTransactionCost,
|
|
getSellTransactionGain,
|
|
processTransactionForecastMovement,
|
|
} from "../src/StockMarket/StockMarketHelpers";
|
|
import { OrderTypes } from "../src/StockMarket/data/OrderTypes"
|
|
import { PositionTypes } from "../src/StockMarket/data/PositionTypes";
|
|
|
|
import { expect } from "chai";
|
|
|
|
console.log("Beginning Stock Market Tests");
|
|
|
|
describe("Stock Market Tests", function() {
|
|
const commission = CONSTANTS.StockMarketCommission;
|
|
|
|
// Generic Stock object that can be used by each test
|
|
let stock: Stock;
|
|
const ctorParams = {
|
|
b: true,
|
|
initPrice: 10e3,
|
|
marketCap: 5e9,
|
|
mv: 2,
|
|
name: "MockStock",
|
|
otlkMag: 20,
|
|
spreadPerc: 1,
|
|
shareTxForMovement: 5e3,
|
|
symbol: "mock",
|
|
};
|
|
|
|
beforeEach(function() {
|
|
function construct(): void {
|
|
stock = new Stock(ctorParams);
|
|
}
|
|
|
|
expect(construct).to.not.throw();
|
|
});
|
|
|
|
describe("Stock Class", function() {
|
|
describe("constructor", function() {
|
|
it("should have default parameters", function() {
|
|
function construct(): void {
|
|
new Stock(); // eslint-disable-line no-new
|
|
}
|
|
expect(construct).to.not.throw();
|
|
|
|
const defaultStock = new Stock();
|
|
expect(defaultStock).to.not.equal(null);
|
|
expect(defaultStock.name).to.equal("");
|
|
});
|
|
|
|
it("should properly initialize props from parameters", function() {
|
|
expect(stock.name).to.equal(ctorParams.name);
|
|
expect(stock.symbol).to.equal(ctorParams.symbol);
|
|
expect(stock.price).to.equal(ctorParams.initPrice);
|
|
expect(stock.lastPrice).to.equal(ctorParams.initPrice);
|
|
expect(stock.b).to.equal(ctorParams.b);
|
|
expect(stock.mv).to.equal(ctorParams.mv);
|
|
expect(stock.shareTxForMovement).to.equal(ctorParams.shareTxForMovement);
|
|
expect(stock.shareTxUntilMovement).to.equal(ctorParams.shareTxForMovement);
|
|
expect(stock.maxShares).to.be.below(stock.totalShares);
|
|
expect(stock.spreadPerc).to.equal(ctorParams.spreadPerc);
|
|
expect(stock.otlkMag).to.be.a("number");
|
|
expect(stock.otlkMag).to.equal(ctorParams.otlkMag);
|
|
expect(stock.otlkMagForecast).to.equal(ctorParams.b ? 50 + ctorParams.otlkMag : 50 - ctorParams.otlkMag);
|
|
});
|
|
|
|
it ("should properly initialize props from range-values", function() {
|
|
const params = {
|
|
b: true,
|
|
initPrice: {
|
|
max: 10e3,
|
|
min: 1e3,
|
|
},
|
|
marketCap: 5e9,
|
|
mv: {
|
|
divisor: 100,
|
|
max: 150,
|
|
min: 50,
|
|
},
|
|
name: "MockStock",
|
|
otlkMag: 10,
|
|
spreadPerc: {
|
|
divisor: 10,
|
|
max: 10,
|
|
min: 1,
|
|
},
|
|
shareTxForMovement: {
|
|
max: 10e3,
|
|
min: 5e3,
|
|
},
|
|
symbol: "mock",
|
|
};
|
|
|
|
function construct(): void {
|
|
new Stock(params); // eslint-disable-line no-new
|
|
}
|
|
|
|
expect(construct).to.not.throw();
|
|
|
|
const stock = new Stock(params);
|
|
expect(stock).not.equal(null);
|
|
expect(stock.price).to.be.within(params.initPrice.min, params.initPrice.max);
|
|
expect(stock.mv).to.be.within(params.mv.min / params.mv.divisor, params.mv.max / params.mv.divisor);
|
|
expect(stock.spreadPerc).to.be.within(params.spreadPerc.min / params.spreadPerc.divisor, params.spreadPerc.max / params.spreadPerc.divisor);
|
|
expect(stock.shareTxForMovement).to.be.within(params.shareTxForMovement.min, params.shareTxForMovement.max);
|
|
});
|
|
|
|
it("should round the 'totalShare' prop to the nearest 100k", function() {
|
|
expect(stock.totalShares % 100e3).to.equal(0);
|
|
});
|
|
});
|
|
|
|
describe("#changeForecastForecast()", function() {
|
|
it("should get the stock's second-order forecast property", function() {
|
|
stock.changeForecastForecast(99);
|
|
expect(stock.otlkMagForecast).to.equal(99);
|
|
stock.changeForecastForecast(1);
|
|
expect(stock.otlkMagForecast).to.equal(1);
|
|
});
|
|
|
|
it("should prevent values outside of 0-100", function() {
|
|
stock.changeForecastForecast(101);
|
|
expect(stock.otlkMagForecast).to.equal(100);
|
|
stock.changeForecastForecast(-1);
|
|
expect(stock.otlkMagForecast).to.equal(0);
|
|
});
|
|
});
|
|
|
|
describe("#changePrice()", function() {
|
|
it("should set both the last price and current price properties", function() {
|
|
const newPrice = 20e3;
|
|
stock.changePrice(newPrice);
|
|
expect(stock.lastPrice).to.equal(ctorParams.initPrice);
|
|
expect(stock.price).to.equal(newPrice);
|
|
});
|
|
});
|
|
|
|
describe("#cycleForecast()", function() {
|
|
it("should appropriately change the otlkMag by the given amount when b=true", function() {
|
|
stock.getForecastIncreaseChance = () => { return 1; }
|
|
stock.cycleForecast(5);
|
|
expect(stock.otlkMag).to.equal(ctorParams.otlkMag + 5);
|
|
|
|
stock.getForecastIncreaseChance = () => { return 0; }
|
|
stock.cycleForecast(10);
|
|
expect(stock.otlkMag).to.equal(ctorParams.otlkMag - 5);
|
|
});
|
|
|
|
it("should NOT(!) the stock's 'b' property if it causes 'otlkMag' to go below 0", function() {
|
|
stock.getForecastIncreaseChance = () => { return 0; }
|
|
stock.cycleForecast(25);
|
|
expect(stock.otlkMag).to.equal(5);
|
|
expect(stock.b).to.equal(false);
|
|
});
|
|
});
|
|
|
|
describe("#cycleForecastForecast()", function() {
|
|
it("should increase the stock's second-order forecast by a given amount", function() {
|
|
const expected = [65, 75];
|
|
stock.cycleForecastForecast(5);
|
|
expect(stock.otlkMagForecast).to.be.oneOf(expected);
|
|
});
|
|
});
|
|
|
|
describe("#flipForecastForecast()", function() {
|
|
it("should flip the 'otlkMagForecast' property around 50", function() {
|
|
stock.otlkMagForecast = 50;
|
|
stock.flipForecastForecast();
|
|
expect(stock.otlkMagForecast).to.equal(50);
|
|
|
|
stock.otlkMagForecast = 60;
|
|
stock.flipForecastForecast();
|
|
expect(stock.otlkMagForecast).to.equal(40);
|
|
|
|
stock.otlkMagForecast = 90;
|
|
stock.flipForecastForecast();
|
|
expect(stock.otlkMagForecast).to.equal(10);
|
|
|
|
stock.otlkMagForecast = 100;
|
|
stock.flipForecastForecast();
|
|
expect(stock.otlkMagForecast).to.equal(0);
|
|
|
|
stock.otlkMagForecast = 40;
|
|
stock.flipForecastForecast();
|
|
expect(stock.otlkMagForecast).to.equal(60);
|
|
|
|
stock.otlkMagForecast = 0;
|
|
stock.flipForecastForecast();
|
|
expect(stock.otlkMagForecast).to.equal(100);
|
|
|
|
stock.otlkMagForecast = 25;
|
|
stock.flipForecastForecast();
|
|
expect(stock.otlkMagForecast).to.equal(75);
|
|
})
|
|
});
|
|
|
|
describe("#getAbsoluteForecast()", function() {
|
|
it("should return the absolute forecast on a 1-100 scale", function() {
|
|
stock.b = true;
|
|
stock.otlkMag = 10;
|
|
expect(stock.getAbsoluteForecast()).to.equal(60);
|
|
|
|
stock.b = false;
|
|
expect(stock.getAbsoluteForecast()).to.equal(40);
|
|
|
|
stock.otlkMag = 30;
|
|
expect(stock.getAbsoluteForecast()).to.equal(20);
|
|
|
|
stock.b = true;
|
|
expect(stock.getAbsoluteForecast()).to.equal(80);
|
|
|
|
stock.otlkMag = 0;
|
|
expect(stock.getAbsoluteForecast()).to.equal(50);
|
|
|
|
stock.b = false;
|
|
expect(stock.getAbsoluteForecast()).to.equal(50);
|
|
});
|
|
});
|
|
|
|
describe("#getAskPrice()", function() {
|
|
it("should return the price increased by spread percentage", function() {
|
|
const perc = stock.spreadPerc / 100;
|
|
expect(perc).to.be.at.most(1);
|
|
expect(perc).to.be.at.least(0);
|
|
|
|
const expected = stock.price * (1 + perc);
|
|
expect(stock.getAskPrice()).to.equal(expected);
|
|
});
|
|
});
|
|
|
|
describe("#getBidPrice()", function() {
|
|
it("should return the price decreased by spread percentage", function() {
|
|
const perc = stock.spreadPerc / 100;
|
|
expect(perc).to.be.at.most(1);
|
|
expect(perc).to.be.at.least(0);
|
|
|
|
const expected = stock.price * (1 - perc);
|
|
expect(stock.getBidPrice()).to.equal(expected);
|
|
});
|
|
});
|
|
|
|
describe("#getForecastIncreaseChance()", function() {
|
|
it("should return the chance that the stock has of increasing in decimal form", function() {
|
|
stock.b = true;
|
|
|
|
stock.otlkMagForecast = 90;
|
|
stock.otlkMag = 20; // Absolute forecast of 70
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.7);
|
|
|
|
stock.otlkMag = 25; // Absolute forecast of 75
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.65);
|
|
|
|
stock.otlkMagForecast = 100;
|
|
stock.otlkMag = 0; // Absolute forecast of 50
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.95);
|
|
|
|
stock.otlkMagForecast = 60;
|
|
stock.otlkMag = 25; // Absolute forecast of 75
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.35);
|
|
|
|
stock.otlkMagForecast = 10;
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.05);
|
|
|
|
stock.b = false;
|
|
|
|
stock.otlkMagForecast = 90;
|
|
stock.otlkMag = 20; // Absolute forecast of 30
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.95);
|
|
|
|
stock.otlkMagForecast = 50;
|
|
stock.otlkMag = 25; // Absolute forecast of 25
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.75);
|
|
|
|
stock.otlkMagForecast = 100;
|
|
stock.otlkMag = 0; // Absolute forecast of 50
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.95);
|
|
|
|
stock.otlkMagForecast = 5;
|
|
stock.otlkMag = 25; // Absolute forecast of 25
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.3);
|
|
|
|
stock.otlkMagForecast = 10;
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.35);
|
|
|
|
stock.otlkMagForecast = 50;
|
|
stock.otlkMag = 0;
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.5);
|
|
|
|
stock.otlkMagForecast = 25;
|
|
stock.otlkMag = 5; // Asolute forecast of 45
|
|
expect(stock.getForecastIncreaseChance()).to.equal(0.3);
|
|
});
|
|
});
|
|
|
|
describe("#influenceForecast()", function() {
|
|
beforeEach(function() {
|
|
stock.otlkMag = 10;
|
|
});
|
|
|
|
it("should change the forecast's value towards 50", function() {
|
|
stock.influenceForecast(2);
|
|
expect(stock.otlkMag).to.equal(8);
|
|
});
|
|
|
|
it("should not care about whether the stock is in bull or bear mode", function() {
|
|
stock.b = true;
|
|
stock.influenceForecast(1);
|
|
expect(stock.otlkMag).to.equal(9);
|
|
|
|
stock.b = false;
|
|
stock.influenceForecast(2);
|
|
expect(stock.otlkMag).to.equal(7);
|
|
});
|
|
|
|
it("should not influence the forecast beyond the limit", function() {
|
|
stock.influenceForecast(10);
|
|
expect(stock.otlkMag).to.equal(StockForecastInfluenceLimit);
|
|
|
|
stock.influenceForecast(10);
|
|
expect(stock.otlkMag).to.equal(StockForecastInfluenceLimit);
|
|
});
|
|
});
|
|
|
|
describe("#influenceForecastForecast()", function() {
|
|
it("should change the second-order forecast's value towards 50", function() {
|
|
stock.otlkMagForecast = 75;
|
|
stock.influenceForecastForecast(15);
|
|
expect(stock.otlkMagForecast).to.equal(60);
|
|
|
|
stock.otlkMagForecast = 25;
|
|
stock.influenceForecastForecast(15);
|
|
expect(stock.otlkMagForecast).to.equal(40);
|
|
});
|
|
|
|
it("should not change the second-order forecast past 50", function() {
|
|
stock.otlkMagForecast = 40;
|
|
stock.influenceForecastForecast(20);
|
|
expect(stock.otlkMagForecast).to.equal(50);
|
|
|
|
stock.otlkMagForecast = 60;
|
|
stock.influenceForecastForecast(20);
|
|
expect(stock.otlkMagForecast).to.equal(50);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("StockMarket object", function() {
|
|
describe("Initialization", function() {
|
|
// Keeps track of initialized stocks. Contains their symbols
|
|
const stocks: string[]= [];
|
|
|
|
before(function() {
|
|
expect(initStockMarket).to.not.throw();
|
|
expect(initSymbolToStockMap).to.not.throw();
|
|
});
|
|
|
|
it("should have Stock objects", function() {
|
|
for (const prop in StockMarket) {
|
|
const stock = StockMarket[prop];
|
|
if (stock instanceof Stock) {
|
|
stocks.push(stock.symbol);
|
|
}
|
|
}
|
|
|
|
// We'll just check that there are some stocks
|
|
expect(stocks.length).to.be.at.least(1);
|
|
});
|
|
|
|
it("should have an order book in the 'Orders' property", function() {
|
|
expect(StockMarket).to.have.property("Orders");
|
|
|
|
const orderbook = StockMarket["Orders"];
|
|
for (const symbol of stocks) {
|
|
const ordersForStock = orderbook[symbol];
|
|
expect(ordersForStock).to.be.an("array");
|
|
expect(ordersForStock.length).to.equal(0);
|
|
}
|
|
});
|
|
|
|
it("should have properties for managing game cycles", function() {
|
|
expect(StockMarket).to.have.property("storedCycles");
|
|
expect(StockMarket["storedCycles"]).to.equal(0);
|
|
expect(StockMarket).to.have.property("lastUpdate");
|
|
expect(StockMarket["lastUpdate"]).to.equal(0);
|
|
expect(StockMarket).to.have.property("ticksUntilCycle");
|
|
expect(StockMarket["ticksUntilCycle"]).to.be.a("number");
|
|
});
|
|
});
|
|
|
|
// Because 'StockMarket' is a global object, the effects of initialization from
|
|
// the block above should still stand
|
|
describe("Deletion", function() {
|
|
it("should set StockMarket to be an empty object", function() {
|
|
expect(StockMarket).to.be.an("object").that.is.not.empty;
|
|
deleteStockMarket();
|
|
expect(StockMarket).to.be.an("object").that.is.empty;
|
|
});
|
|
});
|
|
|
|
describe("processStockPrices()", function() {
|
|
before(function() {
|
|
deleteStockMarket();
|
|
initStockMarket();
|
|
initSymbolToStockMap();
|
|
});
|
|
|
|
it("should store cycles until it actually processes", function() {
|
|
expect(StockMarket["storedCycles"]).to.equal(0);
|
|
processStockPrices(10);
|
|
expect(StockMarket["storedCycles"]).to.equal(10);
|
|
});
|
|
|
|
it("should trigger a price update when it has enough cycles", function() {
|
|
// Get the initial prices
|
|
const initialValues: IMap<any> = {};
|
|
for (const stockName in StockMarket) {
|
|
const stock = StockMarket[stockName];
|
|
if (!(stock instanceof Stock)) { continue; }
|
|
initialValues[stock.symbol] = {
|
|
b: stock.b,
|
|
otlkMag: stock.otlkMag,
|
|
price: stock.price,
|
|
}
|
|
}
|
|
|
|
// Don't know or care how many exact cycles are required
|
|
StockMarket.lastUpdate = new Date().getTime() - 5e3;
|
|
processStockPrices(1e9);
|
|
|
|
// Both price and 'otlkMag' should be different
|
|
for (const stockName in StockMarket) {
|
|
const stock = StockMarket[stockName];
|
|
if (!(stock instanceof Stock)) { continue; }
|
|
expect(initialValues[stock.symbol].price).to.not.equal(stock.price);
|
|
// expect(initialValues[stock.symbol].otlkMag).to.not.equal(stock.otlkMag);
|
|
expect(initialValues[stock.symbol]).to.satisfy(function(initValue: any) {
|
|
if ((initValue.otlkMag !== stock.otlkMag) || (initValue.b !== stock.b)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("StockToSymbolMap", function() {
|
|
before(function() {
|
|
deleteStockMarket();
|
|
initStockMarket();
|
|
initSymbolToStockMap();
|
|
});
|
|
|
|
it("should map stock symbols to their corresponding Stock Objects", function() {
|
|
for (const stockName in StockMarket) {
|
|
const stock = StockMarket[stockName];
|
|
if (!(stock instanceof Stock)) { continue; }
|
|
|
|
expect(SymbolToStockMap[stock.symbol]).to.equal(stock);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("Transaction Cost Calculator Functions", function() {
|
|
describe("getBuyTransactionCost()", function() {
|
|
it("should fail on invalid 'stock' argument", function() {
|
|
const res = getBuyTransactionCost({} as Stock, 10, PositionTypes.Long);
|
|
expect(res).to.equal(null);
|
|
});
|
|
|
|
it("should fail on invalid 'shares' arg", function() {
|
|
let res = getBuyTransactionCost(stock, NaN, PositionTypes.Long);
|
|
expect(res).to.equal(null);
|
|
|
|
res = getBuyTransactionCost(stock, -1, PositionTypes.Long);
|
|
expect(res).to.equal(null);
|
|
});
|
|
|
|
it("should properly evaluate LONG transactions", function() {
|
|
const shares = ctorParams.shareTxForMovement / 2;
|
|
const res = getBuyTransactionCost(stock, shares, PositionTypes.Long);
|
|
expect(res).to.equal(shares * stock.getAskPrice() + commission);
|
|
});
|
|
|
|
it("should properly evaluate SHORT transactions", function() {
|
|
const shares = ctorParams.shareTxForMovement / 2;
|
|
const res = getBuyTransactionCost(stock, shares, PositionTypes.Short);
|
|
expect(res).to.equal(shares * stock.getBidPrice() + commission);
|
|
});
|
|
|
|
it("should cap the 'shares' argument at the stock's maximum number of shares", function() {
|
|
const maxRes = getBuyTransactionCost(stock, stock.maxShares, PositionTypes.Long);
|
|
const exceedRes = getBuyTransactionCost(stock, stock.maxShares * 10, PositionTypes.Long);
|
|
expect(maxRes).to.equal(exceedRes);
|
|
});
|
|
});
|
|
|
|
describe("getSellTransactionGain()", function() {
|
|
it("should fail on invalid 'stock' argument", function() {
|
|
const res = getSellTransactionGain({} as Stock, 10, PositionTypes.Long);
|
|
expect(res).to.equal(null);
|
|
});
|
|
|
|
it("should fail on invalid 'shares' arg", function() {
|
|
let res = getSellTransactionGain(stock, NaN, PositionTypes.Long);
|
|
expect(res).to.equal(null);
|
|
|
|
res = getSellTransactionGain(stock, -1, PositionTypes.Long);
|
|
expect(res).to.equal(null);
|
|
});
|
|
|
|
it("should properly evaluate LONG transactionst", function() {
|
|
const shares = ctorParams.shareTxForMovement / 2;
|
|
const res = getSellTransactionGain(stock, shares, PositionTypes.Long);
|
|
const expected = shares * stock.getBidPrice() - commission;
|
|
expect(res).to.equal(expected);
|
|
});
|
|
|
|
it("should properly evaluate SHORT transactions", function() {
|
|
// We need to set this property in order to calculate gains from short position
|
|
stock.playerAvgShortPx = stock.price * 2;
|
|
|
|
const shares = ctorParams.shareTxForMovement / 2;
|
|
const res = getSellTransactionGain(stock, shares, PositionTypes.Short);
|
|
const expected = (shares * stock.playerAvgShortPx) + (shares * (stock.playerAvgShortPx - stock.getAskPrice())) - commission;
|
|
expect(res).to.equal(expected);
|
|
});
|
|
|
|
it("should cap the 'shares' argument at the stock's maximum number of shares", function() {
|
|
const maxRes = getSellTransactionGain(stock, stock.maxShares, PositionTypes.Long);
|
|
const exceedRes = getSellTransactionGain(stock, stock.maxShares * 10, PositionTypes.Long);
|
|
expect(maxRes).to.equal(exceedRes);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Forecast Movement Processor Function", function() {
|
|
// N = 1 is the original forecast
|
|
function getNthForecast(origForecast: number, n: number): number {
|
|
return origForecast - forecastChangePerPriceMovement * (n - 1);
|
|
}
|
|
|
|
function getNthForecastForecast(origForecastForecast: number, n: number): number {
|
|
if (stock.otlkMagForecast > 50) {
|
|
const expected = origForecastForecast - (forecastChangePerPriceMovement * (n - 1) * (stock.mv / 100));
|
|
return expected < 50 ? 50 : expected;
|
|
} else if (stock.otlkMagForecast < 50) {
|
|
const expected = origForecastForecast + (forecastChangePerPriceMovement * (n - 1) * (stock.mv / 100));
|
|
return expected > 50 ? 50 : expected;
|
|
} else {
|
|
return 50;
|
|
}
|
|
}
|
|
|
|
describe("processTransactionForecastMovement() for buy transactions", function() {
|
|
const noMvmtShares = Math.round(ctorParams.shareTxForMovement / 2.2);
|
|
const mvmtShares = ctorParams.shareTxForMovement * 3 + noMvmtShares;
|
|
|
|
it("should do nothing on invalid 'stock' argument", function() {
|
|
const oldTracker = stock.shareTxUntilMovement;
|
|
|
|
processTransactionForecastMovement({} as Stock, mvmtShares);
|
|
expect(stock.shareTxUntilMovement).to.equal(oldTracker);
|
|
});
|
|
|
|
it("should do nothing on invalid 'shares' arg", function() {
|
|
const oldTracker = stock.shareTxUntilMovement;
|
|
|
|
processTransactionForecastMovement(stock, NaN);
|
|
expect(stock.shareTxUntilMovement).to.equal(oldTracker);
|
|
|
|
processTransactionForecastMovement(stock, -1);
|
|
expect(stock.shareTxUntilMovement).to.equal(oldTracker);
|
|
});
|
|
|
|
it("should properly evaluate a LONG transaction that doesn't trigger a forecast movement", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, noMvmtShares);
|
|
expect(stock.otlkMag).to.equal(oldForecast);
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement - noMvmtShares);
|
|
});
|
|
|
|
it("should properly evaluate a SHORT transaction that doesn't trigger a forecast movement", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, noMvmtShares);
|
|
expect(stock.otlkMag).to.equal(oldForecast);
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement - noMvmtShares);
|
|
});
|
|
|
|
it("should properly evaluate LONG transactions that triggers forecast movements", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
const oldForecastForecast = stock.otlkMagForecast;
|
|
|
|
processTransactionForecastMovement(stock, mvmtShares);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 4));
|
|
expect(stock.otlkMagForecast).to.equal(getNthForecastForecast(oldForecastForecast, 4));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement - noMvmtShares);
|
|
});
|
|
|
|
it("should properly evaluate SHORT transactions that triggers forecast movements", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
const oldForecastForecast = stock.otlkMagForecast;
|
|
|
|
processTransactionForecastMovement(stock, mvmtShares);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 4));
|
|
expect(stock.otlkMagForecast).to.equal(getNthForecastForecast(oldForecastForecast, 4));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement - noMvmtShares);
|
|
});
|
|
|
|
it("should properly evaluate LONG transactions of exactly 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
const oldForecastForecast = stock.otlkMagForecast;
|
|
|
|
processTransactionForecastMovement(stock, stock.shareTxForMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 2));
|
|
expect(stock.otlkMagForecast).to.equal(getNthForecastForecast(oldForecastForecast, 2));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
|
|
it("should properly evaluate LONG transactions that total to 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
const oldForecastForecast = stock.otlkMagForecast;
|
|
|
|
processTransactionForecastMovement(stock, Math.round(stock.shareTxForMovement / 2));
|
|
expect(stock.shareTxUntilMovement).to.be.below(stock.shareTxForMovement);
|
|
processTransactionForecastMovement(stock, stock.shareTxUntilMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 2));
|
|
expect(stock.otlkMagForecast).to.equal(getNthForecastForecast(oldForecastForecast, 2));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
|
|
it("should properly evaluate LONG transactions that are a multiple of 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
const oldForecastForecast = stock.otlkMagForecast;
|
|
|
|
processTransactionForecastMovement(stock, 3 * stock.shareTxForMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 4));
|
|
expect(stock.otlkMagForecast).to.equal(getNthForecastForecast(oldForecastForecast, 4));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
|
|
it("should properly evaluate SHORT transactions of exactly 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
const oldForecastForecast = stock.otlkMagForecast;
|
|
|
|
processTransactionForecastMovement(stock, stock.shareTxForMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 2));
|
|
expect(stock.otlkMagForecast).to.equal(getNthForecastForecast(oldForecastForecast, 2));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
|
|
it("should properly evaluate SHORT transactions that total to 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
const oldForecastForecast = stock.otlkMagForecast;
|
|
|
|
processTransactionForecastMovement(stock, Math.round(stock.shareTxForMovement / 2));
|
|
expect(stock.shareTxUntilMovement).to.be.below(stock.shareTxForMovement);
|
|
processTransactionForecastMovement(stock, stock.shareTxUntilMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 2));
|
|
expect(stock.otlkMagForecast).to.equal(getNthForecastForecast(oldForecastForecast, 2));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
|
|
it("should properly evaluate SHORT transactions that are a multiple of 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
const oldForecastForecast = stock.otlkMagForecast;
|
|
|
|
processTransactionForecastMovement(stock, 3 * stock.shareTxForMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 4));
|
|
expect(stock.otlkMagForecast).to.equal(getNthForecastForecast(oldForecastForecast, 4));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
});
|
|
|
|
describe("processTransactionForecastMovement() for sell transactions", function() {
|
|
const noMvmtShares = Math.round(ctorParams.shareTxForMovement / 2.2);
|
|
const mvmtShares = ctorParams.shareTxForMovement * 3 + noMvmtShares;
|
|
|
|
it("should do nothing on invalid 'stock' argument", function() {
|
|
const oldTracker = stock.shareTxUntilMovement;
|
|
|
|
processTransactionForecastMovement({} as Stock, mvmtShares);
|
|
expect(stock.shareTxUntilMovement).to.equal(oldTracker);
|
|
});
|
|
|
|
it("should do nothing on invalid 'shares' arg", function() {
|
|
const oldTracker = stock.shareTxUntilMovement;
|
|
|
|
processTransactionForecastMovement(stock, NaN);
|
|
expect(stock.shareTxUntilMovement).to.equal(oldTracker);
|
|
|
|
processTransactionForecastMovement(stock, -1);
|
|
expect(stock.shareTxUntilMovement).to.equal(oldTracker);
|
|
});
|
|
|
|
it("should properly evaluate a LONG transaction that doesn't trigger a price movement", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, noMvmtShares);
|
|
expect(stock.otlkMag).to.equal(oldForecast);
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement - noMvmtShares);
|
|
});
|
|
|
|
it("should properly evaluate a SHORT transaction that doesn't trigger a price movement", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, noMvmtShares);
|
|
expect(stock.otlkMag).to.equal(oldForecast);
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement - noMvmtShares);
|
|
});
|
|
|
|
it("should properly evaluate LONG transactions that trigger price movements", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, mvmtShares);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 4));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement - noMvmtShares);
|
|
});
|
|
|
|
it("should properly evaluate SHORT transactions that trigger price movements", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, mvmtShares);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 4));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement - noMvmtShares);
|
|
});
|
|
|
|
it("should properly evaluate LONG transactions of exactly 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, stock.shareTxForMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 2));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
|
|
it("should properly evaluate LONG transactions that total to 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, Math.round(stock.shareTxForMovement / 2));
|
|
expect(stock.shareTxUntilMovement).to.be.below(stock.shareTxForMovement);
|
|
processTransactionForecastMovement(stock, stock.shareTxUntilMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 2));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
|
|
it("should properly evaluate LONG transactions that are a multiple of 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, 3 * stock.shareTxForMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 4));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
|
|
it("should properly evaluate SHORT transactions of exactly 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, stock.shareTxForMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 2));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
|
|
it("should properly evaluate SHORT transactions that total to 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, Math.round(stock.shareTxForMovement / 2));
|
|
expect(stock.shareTxUntilMovement).to.be.below(stock.shareTxForMovement);
|
|
processTransactionForecastMovement(stock, stock.shareTxUntilMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 2));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
|
|
it("should properly evaluate SHORT transactions that are a multiple of 'shareTxForMovement' shares", function() {
|
|
const oldForecast = stock.otlkMag;
|
|
|
|
processTransactionForecastMovement(stock, 3 * stock.shareTxForMovement);
|
|
expect(stock.otlkMag).to.equal(getNthForecast(oldForecast, 4));
|
|
expect(stock.shareTxUntilMovement).to.equal(stock.shareTxForMovement);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Transaction (Buy/Sell) Functions", function() {
|
|
const suppressDialogOpt = { suppressDialog: true };
|
|
|
|
describe("buyStock()", function() {
|
|
it("should fail for invalid arguments", function() {
|
|
expect(buyStock({} as Stock, 1, null, suppressDialogOpt)).to.equal(false);
|
|
expect(buyStock(stock, 0, null, suppressDialogOpt)).to.equal(false);
|
|
expect(buyStock(stock, -1, null, suppressDialogOpt)).to.equal(false);
|
|
expect(buyStock(stock, NaN, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should fail if player doesn't have enough money", function() {
|
|
Player.setMoney(0);
|
|
expect(buyStock(stock, 1, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should not allow for transactions that exceed the maximum shares", function() {
|
|
const maxShares = stock.maxShares;
|
|
expect(buyStock(stock, maxShares + 1, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should return true and properly update stock properties for successful transactions", function() {
|
|
const shares = 1e3;
|
|
const cost = getBuyTransactionCost(stock, shares, PositionTypes.Long);
|
|
if (cost == null) {
|
|
expect.fail();
|
|
return;
|
|
}
|
|
|
|
Player.setMoney(cost);
|
|
|
|
expect(buyStock(stock, shares, null, suppressDialogOpt)).to.equal(true);
|
|
expect(stock.playerShares).to.equal(shares);
|
|
expect(stock.playerAvgPx).to.be.above(0);
|
|
expect(Player.money.toNumber()).to.equal(0);
|
|
});
|
|
});
|
|
|
|
describe("sellStock()", function() {
|
|
it("should fail for invalid arguments", function() {
|
|
expect(sellStock({} as Stock, 1, null, suppressDialogOpt)).to.equal(false);
|
|
expect(sellStock(stock, 0, null, suppressDialogOpt)).to.equal(false);
|
|
expect(sellStock(stock, -1, null, suppressDialogOpt)).to.equal(false);
|
|
expect(sellStock(stock, NaN, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should fail if player doesn't have any shares", function() {
|
|
Player.setMoney(0);
|
|
expect(sellStock(stock, 1, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should not allow for transactions that exceed the maximum shares", function() {
|
|
const maxShares = stock.maxShares;
|
|
expect(sellStock(stock, maxShares + 1, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should return true and properly update stock properties for successful transactions", function() {
|
|
const shares = 1e3;
|
|
stock.playerShares = shares;
|
|
stock.playerAvgPx = stock.price;
|
|
const gain = getSellTransactionGain(stock, shares, PositionTypes.Long);
|
|
Player.setMoney(0);
|
|
|
|
expect(sellStock(stock, shares, null, suppressDialogOpt)).to.equal(true);
|
|
expect(stock.playerShares).to.equal(0);
|
|
expect(stock.playerAvgPx).to.equal(0);
|
|
expect(Player.money.toNumber()).to.equal(gain);
|
|
});
|
|
|
|
it("should cap the number of sharse sold to however many the player owns", function() {
|
|
const attemptedShares = 2e3;
|
|
const actualShares = 1e3;
|
|
stock.playerShares = actualShares;
|
|
stock.playerAvgPx = stock.price;
|
|
const gain = getSellTransactionGain(stock, actualShares, PositionTypes.Long);
|
|
Player.setMoney(0);
|
|
|
|
expect(sellStock(stock, attemptedShares, null, suppressDialogOpt)).to.equal(true);
|
|
expect(stock.playerShares).to.equal(0);
|
|
expect(stock.playerAvgPx).to.equal(0);
|
|
expect(Player.money.toNumber()).to.equal(gain);
|
|
});
|
|
|
|
it("should properly update stock properties for partial transactions", function() {
|
|
const shares = 1e3;
|
|
const origPrice = stock.price;
|
|
stock.playerShares = 2 * shares;
|
|
stock.playerAvgPx = origPrice;
|
|
const gain = getSellTransactionGain(stock, shares, PositionTypes.Long);
|
|
Player.setMoney(0);
|
|
|
|
expect(sellStock(stock, shares, null, suppressDialogOpt)).to.equal(true);
|
|
expect(stock.playerShares).to.equal(shares);
|
|
expect(stock.playerAvgPx).to.equal(origPrice);
|
|
expect(Player.money.toNumber()).to.equal(gain);
|
|
});
|
|
});
|
|
|
|
describe("shortStock()", function() {
|
|
it("should fail for invalid arguments", function() {
|
|
expect(shortStock({} as Stock, 1, null, suppressDialogOpt)).to.equal(false);
|
|
expect(shortStock(stock, 0, null, suppressDialogOpt)).to.equal(false);
|
|
expect(shortStock(stock, -1, null, suppressDialogOpt)).to.equal(false);
|
|
expect(shortStock(stock, NaN, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should fail if player doesn't have enough money", function() {
|
|
Player.setMoney(0);
|
|
expect(shortStock(stock, 1, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should not allow for transactions that exceed the maximum shares", function() {
|
|
const maxShares = stock.maxShares;
|
|
expect(shortStock(stock, maxShares + 1, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should return true and properly update stock properties for successful transactions", function() {
|
|
const shares = 1e3;
|
|
const cost = getBuyTransactionCost(stock, shares, PositionTypes.Short);
|
|
if (cost == null) {
|
|
expect.fail();
|
|
return
|
|
}
|
|
|
|
Player.setMoney(cost);
|
|
|
|
expect(shortStock(stock, shares, null, suppressDialogOpt)).to.equal(true);
|
|
expect(stock.playerShortShares).to.equal(shares);
|
|
expect(stock.playerAvgShortPx).to.be.above(0);
|
|
expect(Player.money.toNumber()).to.equal(0);
|
|
});
|
|
});
|
|
|
|
describe("sellShort()", function() {
|
|
it("should fail for invalid arguments", function() {
|
|
expect(sellShort({} as Stock, 1, null, suppressDialogOpt)).to.equal(false);
|
|
expect(sellShort(stock, 0, null, suppressDialogOpt)).to.equal(false);
|
|
expect(sellShort(stock, -1, null, suppressDialogOpt)).to.equal(false);
|
|
expect(sellShort(stock, NaN, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should fail if player doesn't have any shares", function() {
|
|
Player.setMoney(0);
|
|
expect(sellShort(stock, 1, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should not allow for transactions that exceed the maximum shares", function() {
|
|
const maxShares = stock.maxShares;
|
|
expect(sellShort(stock, maxShares + 1, null, suppressDialogOpt)).to.equal(false);
|
|
});
|
|
|
|
it("should return true and properly update stock properties for successful transactions", function() {
|
|
const shares = 1e3;
|
|
stock.playerShortShares = shares;
|
|
stock.playerAvgShortPx = stock.price;
|
|
const gain = getSellTransactionGain(stock, shares, PositionTypes.Short);
|
|
Player.setMoney(0);
|
|
|
|
expect(sellShort(stock, shares, null, suppressDialogOpt)).to.equal(true);
|
|
expect(stock.playerShortShares).to.equal(0);
|
|
expect(stock.playerAvgShortPx).to.equal(0);
|
|
expect(Player.money.toNumber()).to.equal(gain);
|
|
});
|
|
|
|
it("should cap the number of sharse sold to however many the player owns", function() {
|
|
const attemptedShares = 2e3;
|
|
const actualShares = 1e3;
|
|
stock.playerShortShares = actualShares;
|
|
stock.playerAvgShortPx = stock.price;
|
|
const gain = getSellTransactionGain(stock, actualShares, PositionTypes.Short);
|
|
Player.setMoney(0);
|
|
|
|
expect(sellShort(stock, attemptedShares, null, suppressDialogOpt)).to.equal(true);
|
|
expect(stock.playerShortShares).to.equal(0);
|
|
expect(stock.playerAvgShortPx).to.equal(0);
|
|
expect(Player.money.toNumber()).to.equal(gain);
|
|
});
|
|
|
|
it("should properly update stock properties for partial transactions", function() {
|
|
const shares = 1e3;
|
|
const origPrice = stock.price;
|
|
stock.playerShortShares = 2 * shares;
|
|
stock.playerAvgShortPx = origPrice;
|
|
const gain = getSellTransactionGain(stock, shares, PositionTypes.Short);
|
|
Player.setMoney(0);
|
|
|
|
expect(sellShort(stock, shares, null, suppressDialogOpt)).to.equal(true);
|
|
expect(stock.playerShortShares).to.equal(shares);
|
|
expect(stock.playerAvgShortPx).to.equal(origPrice);
|
|
expect(Player.money.toNumber()).to.equal(gain);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Order Class", function() {
|
|
it("should throw on invalid arguments", function() {
|
|
function invalid1(): Order {
|
|
return new Order({} as string, 1, 1, OrderTypes.LimitBuy, PositionTypes.Long);
|
|
}
|
|
function invalid2(): Order {
|
|
return new Order("FOO", "z" as any as number, 0, OrderTypes.LimitBuy, PositionTypes.Short);
|
|
}
|
|
function invalid3(): Order {
|
|
return new Order("FOO", 1, {} as number, OrderTypes.LimitBuy, PositionTypes.Short);
|
|
}
|
|
function invalid4(): Order {
|
|
return new Order("FOO", 1, NaN, OrderTypes.LimitBuy, PositionTypes.Short);
|
|
}
|
|
function invalid5(): Order {
|
|
return new Order("FOO", NaN, 0, OrderTypes.LimitBuy, PositionTypes.Short);
|
|
}
|
|
|
|
expect(invalid1).to.throw();
|
|
expect(invalid2).to.throw();
|
|
expect(invalid3).to.throw();
|
|
expect(invalid4).to.throw();
|
|
expect(invalid5).to.throw();
|
|
});
|
|
});
|
|
|
|
describe("Order Placing & Processing", function() {
|
|
beforeEach(function() {
|
|
expect(initStockMarket).to.not.throw();
|
|
expect(initSymbolToStockMap).to.not.throw();
|
|
|
|
// Create an order book for our mock stock
|
|
StockMarket["Orders"][stock.symbol] = [];
|
|
});
|
|
|
|
describe("placeOrder()", function() {
|
|
it("should return false when it's called with invalid arguments", function() {
|
|
const invalid1 = placeOrder({} as Stock, 1, 1, OrderTypes.LimitBuy, PositionTypes.Long);
|
|
const invalid2 = placeOrder(stock, "foo" as any as number, 2, OrderTypes.LimitBuy, PositionTypes.Long);
|
|
const invalid3 = placeOrder(stock, 1, "foo" as any as number, OrderTypes.LimitBuy, PositionTypes.Long);
|
|
|
|
expect(invalid1).to.equal(false);
|
|
expect(invalid2).to.equal(false);
|
|
expect(invalid3).to.equal(false);
|
|
|
|
expect(StockMarket["Orders"][stock.symbol]).to.be.empty;
|
|
});
|
|
|
|
it("should return true and update the order book for valid arguments", function() {
|
|
const res = placeOrder(stock, 1e3, 9e3, OrderTypes.LimitBuy, PositionTypes.Long);
|
|
expect(res).to.equal(true);
|
|
|
|
expect(StockMarket["Orders"][stock.symbol]).to.have.lengthOf(1);
|
|
const order = StockMarket["Orders"][stock.symbol][0];
|
|
expect(order).to.be.an.instanceof(Order);
|
|
expect(order.stockSymbol).to.equal(ctorParams.symbol);
|
|
expect(order.shares).to.equal(1e3);
|
|
expect(order.price).to.equal(9e3);
|
|
expect(order.type).to.equal(OrderTypes.LimitBuy);
|
|
expect(order.pos).to.equal(PositionTypes.Long);
|
|
});
|
|
});
|
|
|
|
describe("cancelOrder()", function() {
|
|
beforeEach(function() {
|
|
StockMarket["Orders"][stock.symbol] = [];
|
|
|
|
const res = placeOrder(stock, 1e3, 9e3, OrderTypes.LimitBuy, PositionTypes.Long);
|
|
expect(res).to.equal(true);
|
|
expect(StockMarket["Orders"][stock.symbol]).to.have.lengthOf(1);
|
|
});
|
|
|
|
it("returns true & removes an Order from the order book", function() {
|
|
const order = StockMarket["Orders"][stock.symbol][0];
|
|
const res = cancelOrder({ order });
|
|
expect(res).to.equal(true);
|
|
expect(StockMarket["Orders"][stock.symbol]).to.have.lengthOf(0);
|
|
});
|
|
|
|
it("should also work when passing in order parameters separately", function() {
|
|
const res = cancelOrder({
|
|
stock,
|
|
shares: 1e3,
|
|
price: 9e3,
|
|
type: OrderTypes.LimitBuy,
|
|
pos: PositionTypes.Long,
|
|
});
|
|
expect(res).to.equal(true);
|
|
expect(StockMarket["Orders"][stock.symbol]).to.have.lengthOf(0);
|
|
});
|
|
|
|
it("should return false and do nothing when the specified order doesn't exist", function() {
|
|
// Same parameters, but its a different object
|
|
const order = new Order(stock.symbol, 1e3, 9e3, OrderTypes.LimitBuy, PositionTypes.Long);
|
|
const res = cancelOrder({ order });
|
|
expect(res).to.equal(false);
|
|
expect(StockMarket["Orders"][stock.symbol]).to.have.lengthOf(1);
|
|
|
|
const res2 = cancelOrder({
|
|
stock,
|
|
shares: 999,
|
|
price: 9e3,
|
|
type: OrderTypes.LimitBuy,
|
|
pos: PositionTypes.Long,
|
|
});
|
|
expect(res2).to.equal(false);
|
|
expect(StockMarket["Orders"][stock.symbol]).to.have.lengthOf(1);
|
|
});
|
|
});
|
|
|
|
describe("processOrders()", function() {
|
|
let processOrdersRefs: IProcessOrderRefs;
|
|
|
|
beforeEach(function() {
|
|
expect(initStockMarket).to.not.throw();
|
|
expect(initSymbolToStockMap).to.not.throw();
|
|
|
|
StockMarket[stock.name] = stock;
|
|
SymbolToStockMap[stock.symbol] = stock;
|
|
StockMarket["Orders"][stock.symbol] = [];
|
|
|
|
stock.playerShares = 1e3;
|
|
stock.playerShortShares = 1e3;
|
|
Player.setMoney(100e9);
|
|
|
|
processOrdersRefs = {
|
|
rerenderFn: () => undefined,
|
|
stockMarket: StockMarket as IStockMarket,
|
|
symbolToStockMap: SymbolToStockMap,
|
|
};
|
|
});
|
|
|
|
function checkThatOrderExists(placeOrderRes?: boolean): void {
|
|
if (typeof placeOrderRes === "boolean") {
|
|
expect(placeOrderRes).to.equal(true);
|
|
}
|
|
expect(StockMarket["Orders"][stock.symbol]).to.have.lengthOf(1);
|
|
}
|
|
|
|
function checkThatOrderExecuted(): void {
|
|
expect(StockMarket["Orders"][stock.symbol]).to.have.lengthOf(0);
|
|
}
|
|
|
|
it("should execute LONG Limit Buy orders when price <= order price", function() {
|
|
const res = placeOrder(stock, 1e3, 9e3, OrderTypes.LimitBuy, PositionTypes.Long);
|
|
checkThatOrderExists(res);
|
|
|
|
stock.changePrice(9e3);
|
|
processOrders(stock, OrderTypes.LimitBuy, PositionTypes.Long, processOrdersRefs);
|
|
checkThatOrderExecuted();
|
|
expect(stock.playerShares).to.equal(2e3);
|
|
});
|
|
|
|
it("should execute SHORT Limit Buy Orders when price >= order price", function() {
|
|
const res = placeOrder(stock, 1e3, 11e3, OrderTypes.LimitBuy, PositionTypes.Short);
|
|
checkThatOrderExists(res);
|
|
|
|
stock.changePrice(11e3);
|
|
processOrders(stock, OrderTypes.LimitBuy, PositionTypes.Short, processOrdersRefs);
|
|
checkThatOrderExecuted();
|
|
expect(stock.playerShortShares).to.equal(2e3);
|
|
});
|
|
|
|
it("should execute LONG Limit Sell Orders when price >= order price", function() {
|
|
const res = placeOrder(stock, 1e3, 11e3, OrderTypes.LimitSell, PositionTypes.Long);
|
|
checkThatOrderExists(res);
|
|
|
|
stock.changePrice(11e3);
|
|
processOrders(stock, OrderTypes.LimitSell, PositionTypes.Long, processOrdersRefs);
|
|
checkThatOrderExecuted();
|
|
expect(stock.playerShares).to.equal(0);
|
|
});
|
|
|
|
it("should execute SHORT Limit Sell Orders when price <= order price", function() {
|
|
const res = placeOrder(stock, 1e3, 9e3, OrderTypes.LimitSell, PositionTypes.Short);
|
|
checkThatOrderExists(res);
|
|
|
|
stock.changePrice(9e3);
|
|
processOrders(stock, OrderTypes.LimitSell, PositionTypes.Short, processOrdersRefs);
|
|
checkThatOrderExecuted();
|
|
expect(stock.playerShortShares).to.equal(0);
|
|
});
|
|
|
|
it("should execute LONG Stop Buy Orders when price >= order price", function() {
|
|
const res = placeOrder(stock, 1e3, 11e3, OrderTypes.StopBuy, PositionTypes.Long);
|
|
checkThatOrderExists(res);
|
|
|
|
stock.changePrice(11e3);
|
|
processOrders(stock, OrderTypes.StopBuy, PositionTypes.Long, processOrdersRefs);
|
|
checkThatOrderExecuted();
|
|
expect(stock.playerShares).to.equal(2e3);
|
|
});
|
|
|
|
it("should execute SHORT Stop Buy Orders when price <= order price", function() {
|
|
const res = placeOrder(stock, 1e3, 9e3, OrderTypes.StopBuy, PositionTypes.Short);
|
|
checkThatOrderExists(res);
|
|
|
|
stock.changePrice(9e3);
|
|
processOrders(stock, OrderTypes.StopBuy, PositionTypes.Short, processOrdersRefs);
|
|
checkThatOrderExecuted();
|
|
expect(stock.playerShortShares).to.equal(2e3);
|
|
});
|
|
|
|
it("should execute LONG Stop Sell Orders when price <= order price", function() {
|
|
const res = placeOrder(stock, 1e3, 9e3, OrderTypes.StopSell, PositionTypes.Long);
|
|
checkThatOrderExists(res);
|
|
|
|
stock.changePrice(9e3);
|
|
processOrders(stock, OrderTypes.StopSell, PositionTypes.Long, processOrdersRefs);
|
|
checkThatOrderExecuted();
|
|
expect(stock.playerShares).to.equal(0);
|
|
});
|
|
|
|
it("should execute SHORT Stop Sell Orders when price >= order price", function() {
|
|
const res = placeOrder(stock, 1e3, 11e3, OrderTypes.StopSell, PositionTypes.Short);
|
|
checkThatOrderExists(res);
|
|
|
|
stock.changePrice(11e3);
|
|
processOrders(stock, OrderTypes.StopSell, PositionTypes.Short, processOrdersRefs);
|
|
checkThatOrderExecuted();
|
|
expect(stock.playerShortShares).to.equal(0);
|
|
});
|
|
|
|
it("should execute immediately if their conditions are satisfied", function() {
|
|
placeOrder(stock, 1e3, 11e3, OrderTypes.LimitBuy, PositionTypes.Long);
|
|
checkThatOrderExecuted();
|
|
expect(stock.playerShares).to.equal(2e3);
|
|
});
|
|
});
|
|
});
|
|
|
|
// TODO
|
|
describe("Player Influencing", function() {
|
|
const server = new Server({
|
|
hostname: "mockserver",
|
|
moneyAvailable: 1e6,
|
|
organizationName: "MockStock",
|
|
});
|
|
|
|
const company = new Company({
|
|
name: "MockStock",
|
|
info: "",
|
|
companyPositions: {},
|
|
expMultiplier: 1,
|
|
salaryMultiplier: 1,
|
|
jobStatReqOffset: 1,
|
|
})
|
|
|
|
beforeEach(function() {
|
|
expect(initStockMarket).to.not.throw();
|
|
expect(initSymbolToStockMap).to.not.throw();
|
|
|
|
StockMarket[stock.name] = stock;
|
|
});
|
|
|
|
describe("influenceStockThroughServerHack()", function() {
|
|
it("should decrease a stock's second-order forecast when all of its money is hacked", function() {
|
|
const oldSecondOrderForecast = stock.otlkMagForecast;
|
|
influenceStockThroughServerHack(server, server.moneyMax);
|
|
expect(stock.otlkMagForecast).to.equal(oldSecondOrderForecast - forecastForecastChangeFromHack);
|
|
});
|
|
|
|
it("should not decrease the stock's second-order forecast when no money is stolen", function() {
|
|
const oldSecondOrderForecast = stock.otlkMagForecast;
|
|
influenceStockThroughServerHack(server, 0);
|
|
expect(stock.otlkMagForecast).to.equal(oldSecondOrderForecast);
|
|
});
|
|
});
|
|
|
|
describe("influenceStockThroughServerGrow()", function() {
|
|
it("should increase a stock's second-order forecast when all of its money is grown", function() {
|
|
const oldSecondOrderForecast = stock.otlkMagForecast;
|
|
influenceStockThroughServerGrow(server, server.moneyMax);
|
|
expect(stock.otlkMagForecast).to.equal(oldSecondOrderForecast + forecastForecastChangeFromHack);
|
|
});
|
|
|
|
it("should not increase the stock's second-order forecast when no money is grown", function() {
|
|
const oldSecondOrderForecast = stock.otlkMagForecast;
|
|
influenceStockThroughServerGrow(server, 0);
|
|
expect(stock.otlkMagForecast).to.equal(oldSecondOrderForecast);
|
|
});
|
|
});
|
|
|
|
describe("influenceStockThroughCompanyWork()", function() {
|
|
it("should increase the server's second order forecast", function() {
|
|
const oldSecondOrderForecast = stock.otlkMagForecast;
|
|
|
|
// Use 1e3 for numCycles to force a change
|
|
// (This may break later if numbers are rebalanced);
|
|
influenceStockThroughCompanyWork(company, 1, 500);
|
|
expect(stock.otlkMagForecast).to.equal(oldSecondOrderForecast + forecastForecastChangeFromCompanyWork);
|
|
});
|
|
|
|
it("should be affected by performanceMult", function() {
|
|
const oldSecondOrderForecast = stock.otlkMagForecast;
|
|
|
|
// Use 1e3 for numCycles to force a change
|
|
// (This may break later if numbers are rebalanced);
|
|
influenceStockThroughCompanyWork(company, 4, 1e3);
|
|
expect(stock.otlkMagForecast).to.equal(oldSecondOrderForecast + 4 * forecastForecastChangeFromCompanyWork);
|
|
});
|
|
});
|
|
});
|
|
});
|