@pagopa/dx-savemoney 0.3.2 → 0.4.0

package/src/azure/pricing/resolvers/__tests__/app-service.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Tests for the App Service Plan Retail Prices resolver.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { FetchLike } from "../../client.js";
+import type { PricingResponse } from "../../schema.js";
+
+import { DiskCache } from "../../cache.js";
+import { PricingClient } from "../../client.js";
+import { makeTestCacheDir, removeTestCacheDir } from "../../test-cache-dir.js";
+import { resolveAppServicePlanMonthlyPrice } from "../app-service.js";
+import { HOURS_PER_MONTH } from "../vm.js";
+
+function makeFetch(body: PricingResponse): FetchLike {
+  return vi.fn<FetchLike>().mockResolvedValue({
+    json: async () => body,
+    ok: true,
+    status: 200,
+    statusText: "OK",
+  });
+}
+
+let dir: string;
+
+beforeEach(async () => {
+  dir = await makeTestCacheDir("app-service-resolver");
+});
+
+afterEach(async () => {
+  await removeTestCacheDir(dir);
+});
+
+describe("resolveAppServicePlanMonthlyPrice", () => {
+  it("returns the monthly cost for the matching Linux plan SKU and worker count", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          currencyCode: "EUR",
+          meterName: "S1 App",
+          productName: "Azure App Service Standard Plan",
+          retailPrice: 0.087758,
+          skuName: "S1",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.087758,
+        },
+        {
+          armRegionName: "westeurope",
+          currencyCode: "EUR",
+          meterName: "S1 App",
+          productName: "Azure App Service Standard Plan - Linux",
+          retailPrice: 0.08337,
+          skuName: "S1",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.08337,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body),
+    });
+
+    const money = await resolveAppServicePlanMonthlyPrice(client, {
+      armRegionName: "westeurope",
+      os: "linux",
+      skuName: "S1",
+      workerCount: 2,
+    });
+
+    expect(money).toEqual({
+      amount: Math.round(0.08337 * HOURS_PER_MONTH * 2 * 100) / 100,
+      currency: "EUR",
+    });
+  });
+
+  it("matches Retail Prices SKU names with inconsistent spacing", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          currencyCode: "EUR",
+          meterName: "P2 v3 App",
+          productName: "Azure App Service Premium v3 Plan",
+          retailPrice: 0.593243,
+          skuName: "P2 v3",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.593243,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body),
+    });
+
+    const money = await resolveAppServicePlanMonthlyPrice(client, {
+      armRegionName: "West Europe",
+      os: "windows",
+      skuName: "P2v3",
+    });
+
+    expect(money?.amount).toBeCloseTo(0.593243 * HOURS_PER_MONTH, 2);
+  });
+
+  it("ignores non-plan and non-consumption meters", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          currencyCode: "EUR",
+          meterName: "Standard Bandwidth Usage",
+          productName: "Static Web Apps",
+          retailPrice: 0.175516,
+          skuName: "Standard",
+          type: "Consumption",
+          unitOfMeasure: "1 GB",
+          unitPrice: 0.175516,
+        },
+        {
+          armRegionName: "westeurope",
+          currencyCode: "EUR",
+          meterName: "S1 App",
+          productName: "Azure App Service Standard Plan",
+          reservationTerm: "1 Year",
+          retailPrice: 640,
+          skuName: "S1",
+          type: "Reservation",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 640,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body),
+    });
+
+    const money = await resolveAppServicePlanMonthlyPrice(client, {
+      armRegionName: "westeurope",
+      skuName: "S1",
+    });
+
+    expect(money).toBeUndefined();
+  });
+});

package/src/azure/pricing/resolvers/__tests__/disk.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Tests for the Managed Disk Retail Prices resolver.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { FetchLike } from "../../client.js";
+import type { PricingResponse } from "../../schema.js";
+
+import { DiskCache } from "../../cache.js";
+import { PricingClient } from "../../client.js";
+import { makeTestCacheDir, removeTestCacheDir } from "../../test-cache-dir.js";
+import { pickTier, resolveDiskMonthlyPrice } from "../disk.js";
+
+function makeFetch(body: PricingResponse): {
+  fetch: FetchLike;
+  spy: ReturnType<typeof vi.fn>;
+} {
+  const spy = vi.fn<FetchLike>().mockResolvedValue({
+    json: async () => body,
+    ok: true,
+    status: 200,
+    statusText: "OK",
+  });
+  return { fetch: spy, spy };
+}
+
+let dir: string;
+
+beforeEach(async () => {
+  dir = await makeTestCacheDir("disk-resolver");
+});
+
+afterEach(async () => {
+  await removeTestCacheDir(dir);
+});
+
+describe("pickTier", () => {
+  it.each([
+    [1, 1],
+    [4, 1],
+    [5, 2],
+    [128, 10],
+    [129, 15],
+    [1024, 30],
+    [32768, 80],
+  ])("maps %i GiB to tier %i", (sizeGiB, tier) => {
+    expect(pickTier(sizeGiB)).toBe(tier);
+  });
+
+  it("returns undefined for sizes above the largest tier", () => {
+    expect(pickTier(32769)).toBeUndefined();
+  });
+});
+
+describe("resolveDiskMonthlyPrice", () => {
+  it("resolves the monthly price for a Premium_LRS P10 disk", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          currencyCode: "EUR",
+          meterName: "P10 LRS Disk",
+          productName: "Premium SSD Managed Disks",
+          retailPrice: 19.71,
+          skuName: "P10 LRS",
+          type: "Consumption",
+          unitOfMeasure: "1/Month",
+          unitPrice: 19.71,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const { fetch, spy } = makeFetch(body);
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch,
+    });
+
+    const money = await resolveDiskMonthlyPrice(client, {
+      armRegionName: "westeurope",
+      diskSizeGiB: 128,
+      sku: "Premium_LRS",
+    });
+
+    expect(money).toEqual({ amount: 19.71, currency: "EUR" });
+    expect(spy).toHaveBeenCalledTimes(1);
+    // The OData filter must target the tier-derived skuName, not the raw
+    // managed-disk SKU. URLSearchParams encodes spaces as `+`.
+    const url = String(spy.mock.calls[0]?.[0]);
+    expect(url).toContain("skuName+eq+%27P10+LRS%27");
+    expect(url).toContain("productName+eq+%27Premium+SSD+Managed+Disks%27");
+  });
+
+  it("uses the ZRS product/replication for Premium_ZRS", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          currencyCode: "EUR",
+          meterName: "P10 ZRS Disk",
+          productName: "Premium SSD Managed Disks",
+          retailPrice: 24.64,
+          skuName: "P10 ZRS",
+          type: "Consumption",
+          unitOfMeasure: "1/Month",
+          unitPrice: 24.64,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const { fetch, spy } = makeFetch(body);
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch,
+    });
+
+    const money = await resolveDiskMonthlyPrice(client, {
+      armRegionName: "westeurope",
+      diskSizeGiB: 128,
+      sku: "Premium_ZRS",
+    });
+
+    expect(money).toEqual({ amount: 24.64, currency: "EUR" });
+    const url = String(spy.mock.calls[0]?.[0]);
+    expect(url).toContain("skuName+eq+%27P10+ZRS%27");
+  });
+
+  it("returns undefined when the response has no matching entry", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          currencyCode: "EUR",
+          // Per-GB-month item; resolver must skip it because of unitOfMeasure.
+          productName: "Premium SSD Managed Disks",
+          retailPrice: 0.1,
+          skuName: "P10 LRS",
+          type: "Consumption",
+          unitOfMeasure: "1 GB/Month",
+          unitPrice: 0.1,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body).fetch,
+    });
+
+    const money = await resolveDiskMonthlyPrice(client, {
+      armRegionName: "westeurope",
+      diskSizeGiB: 128,
+      sku: "Premium_LRS",
+    });
+
+    expect(money).toBeUndefined();
+  });
+
+  it("returns undefined when the disk size exceeds the largest tier", async () => {
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: vi.fn<FetchLike>(),
+    });
+
+    const money = await resolveDiskMonthlyPrice(client, {
+      armRegionName: "westeurope",
+      diskSizeGiB: 100_000,
+      sku: "Premium_LRS",
+    });
+
+    expect(money).toBeUndefined();
+  });
+
+  it("rejects invalid input via zod", async () => {
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: vi.fn<FetchLike>(),
+    });
+
+    await expect(
+      resolveDiskMonthlyPrice(client, {
+        armRegionName: "westeurope",
+        diskSizeGiB: -1,
+        sku: "Premium_LRS",
+      }),
+    ).rejects.toThrow();
+  });
+});

package/src/azure/pricing/resolvers/__tests__/public-ip.test.ts

@@ -0,0 +1,130 @@
+/**
+ * Tests for the Public IP Retail Prices resolver.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { FetchLike } from "../../client.js";
+import type { PricingResponse } from "../../schema.js";
+
+import { DiskCache } from "../../cache.js";
+import { PricingClient } from "../../client.js";
+import { makeTestCacheDir, removeTestCacheDir } from "../../test-cache-dir.js";
+import { resolvePublicIpMonthlyPrice } from "../public-ip.js";
+import { HOURS_PER_MONTH } from "../vm.js";
+
+function makeFetch(body: PricingResponse): FetchLike {
+  return vi.fn<FetchLike>().mockResolvedValue({
+    json: async () => body,
+    ok: true,
+    status: 200,
+    statusText: "OK",
+  });
+}
+
+let dir: string;
+
+beforeEach(async () => {
+  dir = await makeTestCacheDir("public-ip-resolver");
+});
+
+afterEach(async () => {
+  await removeTestCacheDir(dir);
+});
+
+describe("resolvePublicIpMonthlyPrice", () => {
+  it("returns the monthly cost of a Standard static Public IP", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          currencyCode: "EUR",
+          meterName: "Standard Static IP Address",
+          productName: "Virtual Network",
+          retailPrice: 0.004,
+          skuName: "Standard",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.004,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body),
+    });
+
+    const money = await resolvePublicIpMonthlyPrice(client, {
+      allocation: "static",
+      armRegionName: "westeurope",
+      sku: "standard",
+    });
+
+    expect(money).toEqual({
+      amount: Math.round(0.004 * HOURS_PER_MONTH * 100) / 100,
+      currency: "EUR",
+    });
+  });
+
+  it("filters by allocation token in meterName", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          currencyCode: "EUR",
+          meterName: "Basic Dynamic IP Address",
+          productName: "Virtual Network",
+          retailPrice: 0.0036,
+          skuName: "Basic",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.0036,
+        },
+        {
+          armRegionName: "westeurope",
+          currencyCode: "EUR",
+          meterName: "Basic Static IP Address",
+          productName: "Virtual Network",
+          retailPrice: 0.0036,
+          skuName: "Basic",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.0036,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body),
+    });
+
+    const money = await resolvePublicIpMonthlyPrice(client, {
+      allocation: "dynamic",
+      armRegionName: "westeurope",
+      sku: "basic",
+    });
+
+    expect(money?.amount).toBeCloseTo(0.0036 * HOURS_PER_MONTH, 2);
+  });
+
+  it("returns undefined when no meter matches", async () => {
+    const body: PricingResponse = {
+      Items: [],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body),
+    });
+
+    const money = await resolvePublicIpMonthlyPrice(client, {
+      allocation: "static",
+      armRegionName: "westeurope",
+      sku: "standard",
+    });
+
+    expect(money).toBeUndefined();
+  });
+});

package/src/azure/pricing/resolvers/__tests__/vm.test.ts

@@ -0,0 +1,232 @@
+/**
+ * Tests for the VM Retail Prices resolver.
+ *
+ * The Retail Prices API is mocked via the `FetchLike` indirection so the
+ * tests run hermetically. Fixtures live next to the tests to keep the
+ * surface explicit.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { FetchLike } from "../../client.js";
+import type { PricingResponse } from "../../schema.js";
+
+import { DiskCache } from "../../cache.js";
+import { PricingClient } from "../../client.js";
+import { makeTestCacheDir, removeTestCacheDir } from "../../test-cache-dir.js";
+import {
+  HOURS_PER_MONTH,
+  normalizeArmRegion,
+  resolveVmMonthlyPrice,
+} from "../vm.js";
+
+function makeFetch(body: PricingResponse): FetchLike {
+  return vi.fn<FetchLike>().mockResolvedValue({
+    json: async () => body,
+    ok: true,
+    status: 200,
+    statusText: "OK",
+  });
+}
+
+let dir: string;
+
+beforeEach(async () => {
+  dir = await makeTestCacheDir("vm-resolver");
+});
+
+afterEach(async () => {
+  await removeTestCacheDir(dir);
+});
+
+describe("normalizeArmRegion", () => {
+  it.each([
+    ["westeurope", "westeurope"],
+    ["West Europe", "westeurope"],
+    ["WEST EUROPE", "westeurope"],
+    ["  West   Europe ", "westeurope"],
+    ["italynorth", "italynorth"],
+  ])("normalises %j → %j", (input, expected) => {
+    expect(normalizeArmRegion(input)).toBe(expected);
+  });
+});
+
+describe("resolveVmMonthlyPrice", () => {
+  it("picks the cheapest Linux consumption hourly item and returns 730×price", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          armSkuName: "Standard_B2s",
+          currencyCode: "EUR",
+          meterName: "B2s",
+          productName: "Virtual Machines BS Series",
+          retailPrice: 0.05,
+          skuName: "B2s",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.05,
+        },
+        {
+          armRegionName: "westeurope",
+          armSkuName: "Standard_B2s",
+          currencyCode: "EUR",
+          meterName: "B2s",
+          productName: "Virtual Machines BS Series Windows",
+          retailPrice: 0.09,
+          skuName: "B2s",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.09,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body),
+    });
+
+    const money = await resolveVmMonthlyPrice(client, {
+      armRegionName: "westeurope",
+      armSkuName: "Standard_B2s",
+    });
+
+    expect(money).toEqual({
+      amount: Math.round(0.05 * HOURS_PER_MONTH * 100) / 100,
+      currency: "EUR",
+    });
+  });
+
+  it("picks the Windows item when os hint is 'windows'", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          armSkuName: "Standard_B2s",
+          currencyCode: "EUR",
+          productName: "Virtual Machines BS Series",
+          retailPrice: 0.05,
+          skuName: "B2s",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.05,
+        },
+        {
+          armRegionName: "westeurope",
+          armSkuName: "Standard_B2s",
+          currencyCode: "EUR",
+          productName: "Virtual Machines BS Series Windows",
+          retailPrice: 0.09,
+          skuName: "B2s",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.09,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body),
+    });
+
+    const money = await resolveVmMonthlyPrice(client, {
+      armRegionName: "westeurope",
+      armSkuName: "Standard_B2s",
+      os: "windows",
+    });
+
+    expect(money?.amount).toBeCloseTo(0.09 * HOURS_PER_MONTH, 2);
+  });
+
+  it("skips Spot / Low Priority items", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          armSkuName: "Standard_B2s",
+          currencyCode: "EUR",
+          productName: "Virtual Machines BS Series",
+          retailPrice: 0.01,
+          skuName: "B2s Spot",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.01,
+        },
+        {
+          armRegionName: "westeurope",
+          armSkuName: "Standard_B2s",
+          currencyCode: "EUR",
+          productName: "Virtual Machines BS Series",
+          retailPrice: 0.05,
+          skuName: "B2s",
+          type: "Consumption",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.05,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body),
+    });
+
+    const money = await resolveVmMonthlyPrice(client, {
+      armRegionName: "westeurope",
+      armSkuName: "Standard_B2s",
+    });
+
+    expect(money?.amount).toBeCloseTo(0.05 * HOURS_PER_MONTH, 2);
+  });
+
+  it("ignores Reservation entries", async () => {
+    const body: PricingResponse = {
+      Items: [
+        {
+          armRegionName: "westeurope",
+          armSkuName: "Standard_B2s",
+          currencyCode: "EUR",
+          productName: "Virtual Machines BS Series",
+          reservationTerm: "1 Year",
+          retailPrice: 0.03,
+          skuName: "B2s",
+          type: "Reservation",
+          unitOfMeasure: "1 Hour",
+          unitPrice: 0.03,
+        },
+      ],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body),
+    });
+
+    const money = await resolveVmMonthlyPrice(client, {
+      armRegionName: "westeurope",
+      armSkuName: "Standard_B2s",
+    });
+
+    expect(money).toBeUndefined();
+  });
+
+  it("returns undefined when no items match", async () => {
+    const body: PricingResponse = {
+      Items: [],
+      NextPageLink: null,
+    };
+    const client = new PricingClient({
+      cache: new DiskCache({ dir }),
+      fetch: makeFetch(body),
+    });
+
+    const money = await resolveVmMonthlyPrice(client, {
+      armRegionName: "westeurope",
+      armSkuName: "Standard_B2s",
+    });
+
+    expect(money).toBeUndefined();
+  });
+});