118 lines
4.0 KiB
Rust
118 lines
4.0 KiB
Rust
use serde_json;
|
|
|
|
use heromodels::models::grid4::{
|
|
ComputeSlice, DeviceInfo, Node, NodeCapacity, PricingPolicy, Reservation, ReservationStatus,
|
|
SLAPolicy, StorageDevice, StorageSlice,
|
|
};
|
|
|
|
#[test]
|
|
fn build_and_serde_roundtrip_compute_storage_slices() {
|
|
let pricing = PricingPolicy::new()
|
|
.marketplace_year_discounts(vec![20, 30, 40])
|
|
.volume_discounts(vec![5, 10, 15])
|
|
.build();
|
|
|
|
let sla = SLAPolicy::new()
|
|
.sla_uptime(99)
|
|
.sla_bandwidth_mbit(1000)
|
|
.sla_penalty(150)
|
|
.build();
|
|
|
|
let cs = ComputeSlice::new()
|
|
.nodeid(42)
|
|
.slice_id(1)
|
|
.mem_gb(16.0)
|
|
.storage_gb(200.0)
|
|
.passmark(5000)
|
|
.vcores(8)
|
|
.cpu_oversubscription(2)
|
|
.storage_oversubscription(1)
|
|
.price_range(vec![0.5, 2.0])
|
|
.gpus(1)
|
|
.price_cc(1.25)
|
|
.pricing_policy(pricing.clone())
|
|
.sla_policy(sla.clone());
|
|
|
|
let ss = StorageSlice::new()
|
|
.nodeid(42)
|
|
.slice_id(2)
|
|
.price_cc(0.15)
|
|
.pricing_policy(pricing)
|
|
.sla_policy(sla);
|
|
|
|
// serde roundtrip compute slice
|
|
let s = serde_json::to_string(&cs).expect("serialize compute slice");
|
|
let cs2: ComputeSlice = serde_json::from_str(&s).expect("deserialize compute slice");
|
|
assert_eq!(cs, cs2);
|
|
|
|
// serde roundtrip storage slice
|
|
let s2 = serde_json::to_string(&ss).expect("serialize storage slice");
|
|
let ss2: StorageSlice = serde_json::from_str(&s2).expect("deserialize storage slice");
|
|
assert_eq!(ss, ss2);
|
|
}
|
|
|
|
#[test]
|
|
fn build_and_serde_roundtrip_node() {
|
|
let dev = DeviceInfo {
|
|
vendor: "AcmeVendor".into(),
|
|
storage: vec![StorageDevice { id: "sda".into(), size_gb: 512.0, description: "NVMe".into() }],
|
|
memory: vec![],
|
|
cpu: vec![],
|
|
gpu: vec![],
|
|
network: vec![],
|
|
};
|
|
|
|
let cap = NodeCapacity { storage_gb: 2048.0, mem_gb: 128.0, mem_gb_gpu: 24.0, passmark: 12000, vcores: 32 };
|
|
|
|
let cs = ComputeSlice::new().nodeid(1).slice_id(1).mem_gb(8.0).storage_gb(100.0).passmark(2500).vcores(4);
|
|
let ss = StorageSlice::new().nodeid(1).slice_id(2).price_cc(0.2);
|
|
|
|
let node = Node::new()
|
|
.nodegroupid(7)
|
|
.uptime(99)
|
|
.add_compute_slice(cs)
|
|
.add_storage_slice(ss)
|
|
.devices(dev)
|
|
.country("NL")
|
|
.capacity(cap)
|
|
.provisiontime(1710000000)
|
|
.pubkey("node_pubkey")
|
|
.signature_node("sig_node")
|
|
.signature_farmer("sig_farmer");
|
|
|
|
let s = serde_json::to_string(&node).expect("serialize node");
|
|
let node2: Node = serde_json::from_str(&s).expect("deserialize node");
|
|
|
|
assert_eq!(node.nodegroupid, node2.nodegroupid);
|
|
assert_eq!(node.uptime, node2.uptime);
|
|
assert_eq!(node.country, node2.country);
|
|
assert_eq!(node.pubkey, node2.pubkey);
|
|
assert_eq!(node.signature_node, node2.signature_node);
|
|
assert_eq!(node.signature_farmer, node2.signature_farmer);
|
|
assert_eq!(node.computeslices.len(), node2.computeslices.len());
|
|
assert_eq!(node.storageslices.len(), node2.storageslices.len());
|
|
}
|
|
|
|
#[test]
|
|
fn build_and_serde_roundtrip_reservation() {
|
|
let reservation = Reservation::new()
|
|
.customer_id(1234)
|
|
.add_compute_slice(11)
|
|
.add_storage_slice(22)
|
|
.status(ReservationStatus::Confirmed)
|
|
.obligation(true)
|
|
.start_date(1_710_000_000)
|
|
.end_date(1_720_000_000);
|
|
|
|
let s = serde_json::to_string(&reservation).expect("serialize reservation");
|
|
let reservation2: Reservation = serde_json::from_str(&s).expect("deserialize reservation");
|
|
|
|
assert_eq!(reservation.customer_id, reservation2.customer_id);
|
|
assert_eq!(reservation.status, reservation2.status);
|
|
assert_eq!(reservation.obligation, reservation2.obligation);
|
|
assert_eq!(reservation.start_date, reservation2.start_date);
|
|
assert_eq!(reservation.end_date, reservation2.end_date);
|
|
assert_eq!(reservation.compute_slices, reservation2.compute_slices);
|
|
assert_eq!(reservation.storage_slices, reservation2.storage_slices);
|
|
}
|