@aitodotai/aito-price-tool - npm Package Compare versions

Comparing version 0.4.1 to 1.0.1

dist/src/index.d.ts

@@ -1,17 +0,12 @@
-export declare const QUERY_LIMIT_RANGES: number[];
-export declare const QUERY_PRICE_RANGES: number[];
-export declare const DATA_LIMIT_RANGES: number[];
-export declare const DATA_PRICE_RANGES: number[];
-export declare class DailyUsage {
-    dataUsage: number;
-    totalCalls: number;
-    constructor(dataUsage: number, totalCalls: number);
+export declare type Product = 'SANDBOX' | 'DEVELOPER' | 'PRODUCTION' | 'PLUS_ONE_GB';
+export interface IProductConfig {
+    price: number;
 }
-export declare const MIN_DATA_PRICE: number;
-export declare function sumOfArray(array: number[]): number;
-export declare function calculateNumberOfQueries(dailyData: DailyUsage[]): number;
-export declare function calculateAverageNumberOfQueries(dailyData: DailyUsage[]): number;
-export declare function calculateMaxData(dailyData: DailyUsage[]): number;
-export declare function calculateAverageData(dailyData: DailyUsage[]): number;
-export declare function calculatePrice(dailyData: DailyUsage[]): number;
+/**
+ * Prices given in cents per month
+ */
+export declare const PRODUCT_CONFIG: {
+    [key in Product]: IProductConfig;
+};
+export declare function calculatePrice(products: Product[], months: number): number;
 //# sourceMappingURL=index.d.ts.map

dist/src/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QUERY_LIMIT_RANGES = [
-    0,
-    1000,
-    10000,
-    100000,
-    1000000,
-    10000000,
-    100000000,
-    1000000000,
-    10000000000,
-    100000000000,
-];
-exports.QUERY_PRICE_RANGES = [
-    0.00000000,
-    0.01000000,
-    0.00655555,
-    0.00110000,
-    0.00021111,
-    0.00004333,
-    0.00001655,
-    0.00001000,
-    0.00000165,
-    0.00000165,
-];
-exports.DATA_LIMIT_RANGES = [
-    0,
-    1,
-    2,
-    4,
-    8,
-    16,
-    32,
-    64,
-    128,
-    256,
-    512,
-    1024,
-];
-exports.DATA_PRICE_RANGES = [
-    6.00000000,
-    3.00000000,
-    2.00000000,
-    0.75000000,
-    0.37500000,
-    0.25000000,
-    0.09375000,
-    0.04687500,
-    0.03125000,
-    0.01171875,
-    0.00585937,
-    0.00585937,
-];
-var DailyUsage = /** @class */ (function () {
-    function DailyUsage(dataUsage, totalCalls) {
-        this.dataUsage = dataUsage;
-        this.totalCalls = totalCalls;
-    }
-    return DailyUsage;
-}());
-exports.DailyUsage = DailyUsage;
-exports.MIN_DATA_PRICE = Math.round(exports.DATA_PRICE_RANGES[0]);
+// tslint:disable:object-literal-sort-keys
+var EURO = 100;
 /**
- * A custom function to calculate price of Aito queries.
- *
- * @param {Number} queryCount The number of queries made to Aito
- * @param {Array} queryRangeLimits List of query limits which start a new pricing range.
- *  Array length must match the pricingForRangeLimits.
- * @param {Array} pricingForRangeLimits List of prices per query for given query range
- *  limits. Array length must match the queryRangeLimits.
- * @return {Number} Price in euros.
- * @customfunction
+ * Prices given in cents per month
  */
-function calculateQueryPrice(queryCount, queryRangeLimits, pricingForRangeLimits) {
-    if (queryRangeLimits.length !== pricingForRangeLimits.length) {
-        throw new Error('queryRangeLimits and pricingForRangeLimits have same amount of elements');
+exports.PRODUCT_CONFIG = {
+    SANDBOX: { price: 0 * EURO },
+    DEVELOPER: { price: 29 * EURO },
+    PRODUCTION: { price: 249 * EURO },
+    PLUS_ONE_GB: { price: 49 * EURO },
+};
+var add = function (accumulator, current) { return accumulator + current; };
+function assertProductSetup(products) {
+    if (products === void 0) { products = []; }
+    if (!products) {
+        throw new Error("Invalid. Undefined or null products.");
     }
-    var queriesLeft = queryCount;
-    var price = 0;
-    var priceRangeIndex = 0;
-    while (queriesLeft > 0) {
-        var queryRangePricePerQuery = pricingForRangeLimits[priceRangeIndex];
-        var queryRangeStart = queryRangeLimits[priceRangeIndex];
-        var queryRangeEnd = priceRangeIndex + 1 > queryRangeLimits.length
-            ? Infinity
-            : queryRangeLimits[priceRangeIndex + 1];
-        // If the last range is exceeded, this calculation will be
-        //   queriesLeft - (Infinity - queryRangeStart) > 0
-        // where the numeric value will always evaluate to -Infinity and the expression evaluates
-        // to false. This means that there are no more queries than the range specifies, and all the
-        // rest of the queries are calculated with the same price as the final price range specifies
-        var isThereMoreQueriesThanTheRange = queriesLeft - (queryRangeEnd - queryRangeStart) > 0;
-        var queriesFromThisRange = isThereMoreQueriesThanTheRange
-            ? queryRangeEnd - queryRangeStart
-            : queriesLeft;
-        price += queriesFromThisRange * queryRangePricePerQuery;
-        priceRangeIndex += 1;
-        queriesLeft -= queriesFromThisRange;
+    if (products.indexOf('PLUS_ONE_GB') !== -1 && products.indexOf('PRODUCTION') === -1) {
+        throw new Error("Additional data can only be bought for the production subscription (" + products.join(', ') + ")");
     }
-    return price;
+    return true;
 }
-/**
- * A custom function to calculate price of data stored in Aito.
- *
- * @param {Number} dataAmountInGb The amount of data stored in Aito in GB
- * @param {Number} dayCount Amount of days the data is stored.
- * @param {Array} dataRangeLimits List of data limits which start a new pricing range.
- *  Array length must match the pricingPerDayForRangeLimits.
- * @param {Array} pricingPerDayForRangeLimits List of prices per GBs stored per day
- *  for given data range limits. Array length must match the dataRangeLimits.
- * @return {Number} Price in euros.
- * @customfunction
- */
-function calculateDataPrice(dataAmountInGb, dayCount, dataRangeLimits, pricingPerDayForRangeLimits) {
-    if (dataRangeLimits.length !== pricingPerDayForRangeLimits.length) {
-        throw new Error('queryRangeLimits and pricingPerDayForRangeLimits have same amount of elements');
+function assertUsageTime(months) {
+    if (months < 0) {
+        throw new Error("Cannot calculate prices for negative times (months provided '" + months + "')");
     }
-    var dataLeft = dataAmountInGb;
-    var price = 0;
-    var priceRangeIndex = 0;
-    while (dataLeft > 0) {
-        var dataRangePricePerQuery = pricingPerDayForRangeLimits[priceRangeIndex];
-        var dataRangeStart = dataRangeLimits[priceRangeIndex];
-        var dataRangeEnd = priceRangeIndex + 1 > dataRangeLimits.length
-            ? Infinity
-            : dataRangeLimits[priceRangeIndex + 1];
-        // If the last range is exceeded, this calculation will be
-        //   dataLeft - (dataRangeEnd - dataRangeStart) > 0
-        // where the numeric value will always evaluate to -Infinity and the expression evaluates
-        // to false. This means that there are no more data than the range specifies, and all the
-        // rest of the data are calculated with the same price as the final price range specifies
-        var isThereMoreQueriesThanTheRange = dataLeft - (dataRangeEnd - dataRangeStart) > 0;
-        var dataFromThisRange = isThereMoreQueriesThanTheRange
-            ? dataRangeEnd - dataRangeStart
-            : dataLeft;
-        price += dataFromThisRange * dataRangePricePerQuery;
-        priceRangeIndex += 1;
-        dataLeft -= dataFromThisRange;
+    return true;
+}
+function calculatePrice(products, months) {
+    assertProductSetup(products);
+    assertUsageTime(months);
+    if (products.length === 0) {
+        return 0;
     }
-    return Math.max(price, exports.MIN_DATA_PRICE) * dayCount;
+    return products.map(function (p) { return exports.PRODUCT_CONFIG[p].price; }).reduce(add, 0) * months;
 }
-function sumOfArray(array) {
-    return array.filter(function (n) { return !isNaN(n); }).reduce(function (a, b) { return a + b; }, 0);
-}
-exports.sumOfArray = sumOfArray;
-function averageOfArray(array) {
-    return sumOfArray(array) / (1.0 * array.length);
-}
-function calculateNumberOfQueries(dailyData) {
-    return sumOfArray(dailyData.map(function (dd) { return dd.totalCalls; }));
-}
-exports.calculateNumberOfQueries = calculateNumberOfQueries;
-function calculateAverageNumberOfQueries(dailyData) {
-    return averageOfArray(dailyData.map(function (dd) { return dd.totalCalls; }));
-}
-exports.calculateAverageNumberOfQueries = calculateAverageNumberOfQueries;
-function calculateMaxData(dailyData) {
-    var dailyUsages = dailyData.map(function (dd) { return dd.dataUsage; });
-    return Math.max.apply(Math, dailyUsages);
-}
-exports.calculateMaxData = calculateMaxData;
-function calculateAverageData(dailyData) {
-    return averageOfArray(dailyData.map(function (dd) { return dd.dataUsage; }));
-}
-exports.calculateAverageData = calculateAverageData;
-function calculatePrice(dailyData) {
-    var queryPrice = calculateQueryPrice(sumOfArray(dailyData.map(function (dayData) { return dayData.totalCalls; })), exports.QUERY_LIMIT_RANGES, exports.QUERY_PRICE_RANGES);
-    var dataPrice = sumOfArray(dailyData.map(function (o) { return o.dataUsage; })
-        .map(function (dayData) { return calculateDataPrice(dayData, 1, exports.DATA_LIMIT_RANGES, exports.DATA_PRICE_RANGES); }));
-    return Math.round((queryPrice + dataPrice) * 100) / 100;
-}
 exports.calculatePrice = calculatePrice;
 //# sourceMappingURL=index.js.map

dist/test/pricing.spec.js

@@ -13,49 +13,58 @@ "use strict";
 var Calculator = __importStar(require("../src/index"));
-var index_1 = require("../src/index");
 describe('Pricing module', function () {
-    var minPriceForDay = Calculator.DATA_PRICE_RANGES[0];
-    var minPricePerQuery = Calculator.QUERY_PRICE_RANGES[1];
+    var invalidProductSetups = [
+        ['SANDBOX', 'PLUS_ONE_GB'],
+        ['DEVELOPER', 'PLUS_ONE_GB'],
+        ['PLUS_ONE_GB'],
+        ['PLUS_ONE_GB', 'PLUS_ONE_GB'],
+        ['PLUS_ONE_GB', 'PLUS_ONE_GB', 'PLUS_ONE_GB'],
+    ];
     it('should give prize 0 for empty array', function () {
-        chai_1.expect(Calculator.calculatePrice([])).to.equal(0);
+        chai_1.expect(Calculator.calculatePrice([], 1)).to.equal(0);
+        chai_1.expect(Calculator.calculatePrice([], 10000)).to.equal(0);
     });
-    it('should give min price for single min data', function () {
-        chai_1.expect(Calculator.calculatePrice([new index_1.DailyUsage(0, 0)])).to.equal(minPriceForDay);
+    it('should charge nothing for sandbox', function () {
+        chai_1.expect(Calculator.calculatePrice(['SANDBOX'], 1)).to.equal(0);
+        chai_1.expect(Calculator.calculatePrice(['SANDBOX'], 10)).to.equal(0);
+        chai_1.expect(Calculator.calculatePrice(['SANDBOX'], 100000000)).to.equal(0);
     });
-    it('should allow first 1000 queries for free', function () {
-        chai_1.expect(Calculator.calculatePrice([new index_1.DailyUsage(0, 1)])).to.equal(minPriceForDay);
-        chai_1.expect(Calculator.calculatePrice([new index_1.DailyUsage(0, 999)])).to.equal(minPriceForDay);
-        chai_1.expect(Calculator.calculatePrice([new index_1.DailyUsage(0, 1000)])).to.equal(minPriceForDay);
+    it('should not charge anything for no time', function () {
+        chai_1.expect(Calculator.calculatePrice(['PRODUCTION'], 0)).to.equal(0);
     });
-    it('should start accumulating query costs after 1000', function () {
-        chai_1.expect(Calculator.calculatePrice([new index_1.DailyUsage(0, 1001)])).to.equal(minPriceForDay + minPricePerQuery);
+    it('should throw error for invalid time', function () {
+        try {
+            Calculator.calculatePrice(['SANDBOX'], -1);
+            chai_1.assert.fail("Accepted negative time (-1)");
+        }
+        catch (error) {
+            chai_1.expect(error.message).to.contain('negative time');
+            // passed
+        }
     });
-    it('should start accumulating query costs after 1000 divided on multiple days', function () {
-        var day1 = new index_1.DailyUsage(0, 333);
-        var day2 = new index_1.DailyUsage(0, 334);
-        var day3 = new index_1.DailyUsage(0, 334);
-        chai_1.expect(Calculator.calculatePrice([day1, day2, day3])).to.equal(3 * minPriceForDay + minPricePerQuery);
+    it('should throw error for invalid products', function () {
+        for (var _i = 0, invalidProductSetups_1 = invalidProductSetups; _i < invalidProductSetups_1.length; _i++) {
+            var ips = invalidProductSetups_1[_i];
+            try {
+                Calculator.calculatePrice(ips, 0);
+                chai_1.assert.fail("Accepted mismatched product setup");
+            }
+            catch (error) {
+                chai_1.expect(error.message).to.contain('only be bought');
+                // passed
+            }
+        }
     });
-    it('should not break for invalid numbers', function () {
-        chai_1.expect(Calculator.calculatePrice([new index_1.DailyUsage(0, -1)])).to.equal(minPriceForDay);
+    it('should calculate prices for single products', function () {
+        chai_1.expect(Calculator.calculatePrice(['PRODUCTION'], 1)).to.equal(24900);
     });
-    it('should calculate max and average queries', function () {
-        var day1 = new index_1.DailyUsage(0, 333);
-        var day2 = new index_1.DailyUsage(0, 334);
-        var day3 = new index_1.DailyUsage(0, 334);
-        chai_1.expect(Calculator.calculateNumberOfQueries([day1, day2, day3])).to.equal(1001);
-        chai_1.expect(Calculator.calculateAverageNumberOfQueries([day1, day2, day3])).to.be.within(333, 334);
+    it('should calculate prices for combined products', function () {
+        chai_1.expect(Calculator.calculatePrice(['PRODUCTION', 'PLUS_ONE_GB'], 1)).to.equal(24900 + 4900);
+        chai_1.expect(Calculator.calculatePrice(['PRODUCTION', 'DEVELOPER'], 1)).to.equal(24900 + 2900);
     });
-    it('should calculate the max data correctly', function () {
-        var day1 = new index_1.DailyUsage(11, 0);
-        var day2 = new index_1.DailyUsage(23, 0);
-        var day3 = new index_1.DailyUsage(13, 0);
-        chai_1.expect(Calculator.calculateMaxData([day1, day2, day3])).to.equal(23);
+    it('should calculate prices for random ordered combined products', function () {
+        chai_1.expect(Calculator.calculatePrice(['PLUS_ONE_GB', 'PRODUCTION', 'PLUS_ONE_GB', 'DEVELOPER', 'SANDBOX'], 1)).to.be.greaterThan(0);
+        chai_1.expect(Calculator.calculatePrice(['SANDBOX', 'DEVELOPER', 'DEVELOPER'], 1)).to.be.greaterThan(0);
+        chai_1.expect(Calculator.calculatePrice(['PLUS_ONE_GB', 'PRODUCTION', 'PRODUCTION', 'PRODUCTION', 'PRODUCTION'], 1)).to.be.greaterThan(0);
     });
-    it('should calculate the average data correctly', function () {
-        var day1 = new index_1.DailyUsage(1, 0);
-        var day2 = new index_1.DailyUsage(2, 0);
-        var day3 = new index_1.DailyUsage(3, 0);
-        chai_1.expect(Calculator.calculateAverageData([day1, day2, day3])).to.equal(2);
-    });
 });
 //# sourceMappingURL=pricing.spec.js.map

package.json

 {
   "name": "@aitodotai/aito-price-tool",
-  "version": "0.4.1",
+  "version": "1.0.1",
   "description": "Calculates Aito invoices",
@@ -5,0 +5,0 @@ "main": "dist/src/index.js",

test/pricing.spec.js

@@ -1,12 +0,20 @@
-import { expect } from 'chai'
+import {
+  expect,
+  fail
+} from 'chai'
 import 'mocha'
 
 import * as Calculator from '../dist/src/index'
-import { DailyUsage } from '../dist/src/index'
 
 
 describe('Pricing module', () => {
-  const minPriceForDay = Calculator.DATA_PRICE_RANGES[0]
-  const minPricePerQuery = Calculator.QUERY_PRICE_RANGES[1]
 
+  const invalidProductSetups = [
+    ['SANDBOX', 'PLUS_ONE_GB'],
+    ['DEVELOPER', 'PLUS_ONE_GB'],
+    ['PLUS_ONE_GB'],
+    ['PLUS_ONE_GB', 'PLUS_ONE_GB'],
+    ['PLUS_ONE_GB', 'PLUS_ONE_GB', 'PLUS_ONE_GB'],
+  ]
+
   it('should give prize 0 for empty array', () => {
@@ -16,43 +24,38 @@ expect(Calculator.calculatePrice([])).to.equal(0)
 
-  it('should not break for invalid numbers', () => {
-    expect(Calculator.calculatePrice([new DailyUsage(0, -1)])).to.equal(minPriceForDay)
+  it('should throw error for invalid time', () => {
+    try {
+      expect(Calculator.calculatePrice(['SANDBOX'], -1)).to.be.within(333, 334)
+      fail(`Accepted negative time (-1)`)
+    } catch (error) {
+      expect(error.message).to.contain('negative time')
+      // passed
+    }
   })
 
-  it('should calculate max and average queries', () => {
-    const day1 = new DailyUsage(0, 333)
-    const day2 = new DailyUsage(0, 334)
-    const day3 = new DailyUsage(0, 334)
-
-    expect(Calculator.calculateNumberOfQueries([day1, day2, day3])).to.equal(1001)
-    expect(Calculator.calculateAverageNumberOfQueries([day1, day2, day3])).to.be.within(333, 334)
+  it('should throw error for invalid products', () => {
+    for (const ips of invalidProductSetups) {
+      try {
+        Calculator.calculatePrice(ips, 0)
+        assert.fail(`Accepted mismatched product setup`)
+      } catch (error) {
+        expect(error.message).to.contain('only be bought')
+        // passed
+      }
+    }
   })
 
-  it('should calculate the max data correctly', () => {
-    const day1 = new DailyUsage(11, 0)
-    const day2 = new DailyUsage(23, 0)
-    const day3 = new DailyUsage(13, 0)
-
-    expect(Calculator.calculateMaxData([day1, day2, day3])).to.equal(23)
+  it('should calculate prices for single products', () => {
+    expect(Calculator.calculatePrice(['PRODUCTION'], 1)).to.equal(24900)
   })
 
-  it('should calculate sum even when nulls in array', () => {
-    expect(Calculator.sumOfArray([null, 1, null, 2, null, 3])).to.equal(6)
+  it('should calculate prices for combined products', () => {
+    expect(Calculator.calculatePrice(['PRODUCTION', 'PLUS_ONE_GB'], 1)).to.equal(24900 + 4900)
+    expect(Calculator.calculatePrice(['PRODUCTION', 'DEVELOPER'], 1)).to.equal(24900 + 2900)
   })
 
-  it('should calculate sum even when undefineds in array', () => {
-    expect(Calculator.sumOfArray([undefined, 19, undefined, 17, undefined])).to.equal(36)
+  it('should calculate prices for random ordered combined products', () => {
+    expect(Calculator.calculatePrice(['PLUS_ONE_GB', 'PRODUCTION', 'PLUS_ONE_GB', 'DEVELOPER', 'SANDBOX'], 1)).to.be.greaterThan(0)
+    expect(Calculator.calculatePrice(['SANDBOX', 'DEVELOPER', 'DEVELOPER'], 1)).to.be.greaterThan(0)
+    expect(Calculator.calculatePrice(['PLUS_ONE_GB', 'PRODUCTION', 'PRODUCTION', 'PRODUCTION', 'PRODUCTION'], 1)).to.be.greaterThan(0)
   })
-
-  it('should calculate the api calls correctly on undefineds', () => {
-    const dayPrice = 5 * minPriceForDay
-    const queryPrice = 2*1000 * minPricePerQuery
-
-    const day1 = new DailyUsage(0, 1000)
-    const day2 = new DailyUsage(0, undefined)
-    const day3 = new DailyUsage(0, 1000)
-    const day4 = new DailyUsage(0, undefined)
-    const day5 = new DailyUsage(0, 1000)
-
-    expect(Calculator.calculatePrice([day1, day2, day3, day4, day5])).to.equal(dayPrice + queryPrice)
-  })
 })

test/pricing.spec.ts

@@ -1,65 +0,76 @@
-import { expect } from 'chai'
+import {
+  assert,
+  expect
+} from 'chai'
 import 'mocha'
 
 import * as Calculator from '../src/index'
-import { DailyUsage } from '../src/index'
 
 describe('Pricing module', () => {
-  const minPriceForDay = Calculator.DATA_PRICE_RANGES[0]
-  const minPricePerQuery = Calculator.QUERY_PRICE_RANGES[1]
 
+  const invalidProductSetups: Calculator.Product[][] = [
+    ['SANDBOX', 'PLUS_ONE_GB'],
+    ['DEVELOPER', 'PLUS_ONE_GB'],
+    ['PLUS_ONE_GB'],
+    ['PLUS_ONE_GB', 'PLUS_ONE_GB'],
+    ['PLUS_ONE_GB', 'PLUS_ONE_GB', 'PLUS_ONE_GB'],
+  ]
+
   it('should give prize 0 for empty array', () => {
-    expect(Calculator.calculatePrice([])).to.equal(0)
+    expect(Calculator.calculatePrice([], 1)).to.equal(0)
+    expect(Calculator.calculatePrice([], 10000)).to.equal(0)
   })
 
-  it('should give min price for single min data', () => {
-    expect(Calculator.calculatePrice([new DailyUsage(0, 0)])).to.equal(minPriceForDay)
+  it('should charge nothing for sandbox', () => {
+    expect(Calculator.calculatePrice(['SANDBOX'], 1)).to.equal(0)
+    expect(Calculator.calculatePrice(['SANDBOX'], 10)).to.equal(0)
+    expect(Calculator.calculatePrice(['SANDBOX'], 100000000)).to.equal(0)
   })
 
-  it('should allow first 1000 queries for free', () => {
-    expect(Calculator.calculatePrice([new DailyUsage(0, 1)])).to.equal(minPriceForDay)
-    expect(Calculator.calculatePrice([new DailyUsage(0, 999)])).to.equal(minPriceForDay)
-    expect(Calculator.calculatePrice([new DailyUsage(0, 1000)])).to.equal(minPriceForDay)
+  it('should not charge anything for no time', () => {
+    expect(Calculator.calculatePrice(['PRODUCTION'], 0)).to.equal(0)
   })
 
-  it('should start accumulating query costs after 1000', () => {
-    expect(Calculator.calculatePrice([new DailyUsage(0, 1001)])).to.equal(minPriceForDay + minPricePerQuery)
+  it('should throw error for invalid time', () => {
+    try {
+      Calculator.calculatePrice(['SANDBOX'], -1)
+      assert.fail(`Accepted negative time (-1)`)
+    } catch (error) {
+      expect(error.message).to.contain('negative time')
+      // passed
+    }
   })
 
-  it('should start accumulating query costs after 1000 divided on multiple days', () => {
-    const day1 = new DailyUsage(0, 333)
-    const day2 = new DailyUsage(0, 334)
-    const day3 = new DailyUsage(0, 334)
-
-    expect(Calculator.calculatePrice([day1, day2, day3])).to.equal(3 * minPriceForDay + minPricePerQuery)
+  it('should throw error for invalid products', () => {
+    for (const ips of invalidProductSetups) {
+      try {
+        Calculator.calculatePrice(ips, 0)
+        assert.fail(`Accepted mismatched product setup`)
+      } catch (error) {
+        expect(error.message).to.contain('only be bought')
+        // passed
+      }
+    }
   })
 
-  it('should not break for invalid numbers', () => {
-    expect(Calculator.calculatePrice([new DailyUsage(0, -1)])).to.equal(minPriceForDay)
+  it('should calculate prices for single products', () => {
+    expect(Calculator.calculatePrice(['PRODUCTION'], 1)).to.equal(24900)
   })
 
-  it('should calculate max and average queries', () => {
-    const day1 = new DailyUsage(0, 333)
-    const day2 = new DailyUsage(0, 334)
-    const day3 = new DailyUsage(0, 334)
-
-    expect(Calculator.calculateNumberOfQueries([day1, day2, day3])).to.equal(1001)
-    expect(Calculator.calculateAverageNumberOfQueries([day1, day2, day3])).to.be.within(333, 334)
+  it('should calculate prices for combined products', () => {
+    expect(Calculator.calculatePrice(['PRODUCTION', 'PLUS_ONE_GB'], 1)).to.equal(24900 + 4900)
+    expect(Calculator.calculatePrice(['PRODUCTION', 'DEVELOPER'], 1)).to.equal(24900 + 2900)
   })
 
-  it('should calculate the max data correctly', () => {
-    const day1 = new DailyUsage(11, 0)
-    const day2 = new DailyUsage(23, 0)
-    const day3 = new DailyUsage(13, 0)
+  it('should calculate prices for random ordered combined products', () => {
+    expect(Calculator.calculatePrice(
+      ['PLUS_ONE_GB', 'PRODUCTION', 'PLUS_ONE_GB', 'DEVELOPER', 'SANDBOX'], 1)).to.be.greaterThan(0)
 
-    expect(Calculator.calculateMaxData([day1, day2, day3])).to.equal(23)
-  })
+    expect(Calculator.calculatePrice(
+      ['SANDBOX', 'DEVELOPER', 'DEVELOPER'], 1)).to.be.greaterThan(0)
 
-  it('should calculate the average data correctly', () => {
-    const day1 = new DailyUsage(1, 0)
-    const day2 = new DailyUsage(2, 0)
-    const day3 = new DailyUsage(3, 0)
-
-    expect(Calculator.calculateAverageData([day1, day2, day3])).to.equal(2)
+    expect(Calculator.calculatePrice(
+      ['PLUS_ONE_GB', 'PRODUCTION', 'PRODUCTION', 'PRODUCTION', 'PRODUCTION'],
+      1)).to.be.greaterThan(0)
   })
 })

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Number of low quality alerts

0

-100%

Worsened metrics

Total package byte prevSize

21396

-30.52%

Lines of code

299

-26.89%

Number of medium supply chain risk alerts

1

Infinity%

No dependency changes