Offer parsing tests

Test semantic errors when parsing offer bytes.

Author: jkczyz

lightning/src/offers/offer.rs

@@ -595,7 +595,7 @@ mod tests {
 	use core::time::Duration;
 	use ln::features::OfferFeatures;
 	use ln::msgs::MAX_VALUE_MSAT;
-	use offers::parse::SemanticError;
+	use offers::parse::{ParseError, SemanticError};
 	use onion_message::{BlindedHop, BlindedPath};
 	use util::ser::Writeable;
 
@@ -966,6 +966,186 @@ mod tests {
 			Err(e) => assert_eq!(e, SemanticError::InvalidQuantity),
 		}
 	}
+
+	#[test]
+	fn parses_offer_with_chains() {
+		let offer = OfferBuilder::new("foo".into(), pubkey(42))
+			.chain(Network::Bitcoin)
+			.chain(Network::Testnet)
+			.build()
+			.unwrap();
+		if let Err(e) = offer.to_string().parse::<Offer>() {
+			panic!("error parsing offer: {:?}", e);
+		}
+
+		let unsupported_chain = ChainHash::from(&[42; 32][..]);
+		let mut builder = OfferBuilder::new("foo".into(), pubkey(42));
+		builder.offer.chains = Some(vec![unsupported_chain]);
+
+		let offer = builder.build().unwrap();
+		match offer.to_string().parse::<Offer>() {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnsupportedChain)),
+		}
+	}
+
+	#[test]
+	fn parses_offer_with_amount() {
+		let offer = OfferBuilder::new("foo".into(), pubkey(42))
+			.amount(Amount::Bitcoin { amount_msats: 1000 })
+			.build()
+			.unwrap();
+		if let Err(e) = offer.to_string().parse::<Offer>() {
+			panic!("error parsing offer: {:?}", e);
+		}
+
+		let mut tlv_stream = offer.as_tlv_stream();
+		tlv_stream.currency = Some(b"USD");
+
+		let mut encoded_offer = Vec::new();
+		tlv_stream.write(&mut encoded_offer).unwrap();
+
+		match Offer::try_from(encoded_offer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => {
+				assert_eq!(e, ParseError::InvalidSemantics(SemanticError::UnsupportedCurrency));
+			},
+		}
+
+		let mut tlv_stream = offer.as_tlv_stream();
+		tlv_stream.amount = None;
+		tlv_stream.currency = Some(b"USD");
+
+		let mut encoded_offer = Vec::new();
+		tlv_stream.write(&mut encoded_offer).unwrap();
+
+		match Offer::try_from(encoded_offer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingAmount)),
+		}
+	}
+
+	#[test]
+	fn parses_offer_with_description() {
+		let offer = OfferBuilder::new("foo".into(), pubkey(42)).build().unwrap();
+		if let Err(e) = offer.to_string().parse::<Offer>() {
+			panic!("error parsing offer: {:?}", e);
+		}
+
+		let mut tlv_stream = offer.as_tlv_stream();
+		tlv_stream.description = None;
+
+		let mut encoded_offer = Vec::new();
+		tlv_stream.write(&mut encoded_offer).unwrap();
+
+		match Offer::try_from(encoded_offer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => {
+				assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingDescription));
+			},
+		}
+	}
+
+	#[test]
+	fn parses_offer_with_paths() {
+		let offer = OfferBuilder::new("foo".into(), pubkey(42))
+			.path(BlindedPath {
+				introduction_node_id: pubkey(40),
+				blinding_point: pubkey(41),
+				blinded_hops: vec![
+					BlindedHop { blinded_node_id: pubkey(43), encrypted_payload: vec![0; 43] },
+					BlindedHop { blinded_node_id: pubkey(44), encrypted_payload: vec![0; 44] },
+				],
+			})
+			.path(BlindedPath {
+				introduction_node_id: pubkey(40),
+				blinding_point: pubkey(41),
+				blinded_hops: vec![
+					BlindedHop { blinded_node_id: pubkey(45), encrypted_payload: vec![0; 45] },
+					BlindedHop { blinded_node_id: pubkey(46), encrypted_payload: vec![0; 46] },
+				],
+			})
+			.build()
+			.unwrap();
+		if let Err(e) = offer.to_string().parse::<Offer>() {
+			panic!("error parsing offer: {:?}", e);
+		}
+
+		let mut builder = OfferBuilder::new("foo".into(), pubkey(42));
+		builder.offer.paths = Some(vec![]);
+
+		let offer = builder.build().unwrap();
+		match offer.to_string().parse::<Offer>() {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingPaths)),
+		}
+	}
+
+	#[test]
+	fn parses_offer_with_quantity() {
+		let five = NonZeroU64::new(5).unwrap();
+		let ten = NonZeroU64::new(10).unwrap();
+
+		let offer = OfferBuilder::new("foo".into(), pubkey(42))
+			.quantity_range(five..=ten)
+			.build()
+			.unwrap();
+		if let Err(e) = offer.to_string().parse::<Offer>() {
+			panic!("error parsing offer: {:?}", e);
+		}
+
+		// quantity_min < 1
+		let mut builder = OfferBuilder::new("foo".into(), pubkey(42));
+		builder.offer.quantity_min = Some(0);
+
+		let offer = builder.build().unwrap();
+		match offer.to_string().parse::<Offer>() {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::InvalidQuantity)),
+		}
+
+		// quantity_min > quantity_max
+		let mut tlv_stream = offer.as_tlv_stream();
+		tlv_stream.quantity_min = Some(5);
+		tlv_stream.quantity_max = Some(4);
+
+		let mut encoded_offer = Vec::new();
+		tlv_stream.write(&mut encoded_offer).unwrap();
+
+		match Offer::try_from(encoded_offer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::InvalidQuantity)),
+		}
+
+		// quantity_max < 1
+		tlv_stream.quantity_min = None;
+		tlv_stream.quantity_max = Some(0);
+
+		let mut encoded_offer = Vec::new();
+		tlv_stream.write(&mut encoded_offer).unwrap();
+
+		match Offer::try_from(encoded_offer) {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::InvalidQuantity)),
+		}
+	}
+
+	#[test]
+	fn parses_offer_with_node_id() {
+		let offer = OfferBuilder::new("foo".into(), pubkey(42)).build().unwrap();
+		if let Err(e) = offer.to_string().parse::<Offer>() {
+			panic!("error parsing offer: {:?}", e);
+		}
+
+		let mut builder = OfferBuilder::new("foo".into(), pubkey(42));
+		builder.offer.signing_pubkey = None;
+
+		let offer = builder.build().unwrap();
+		match offer.to_string().parse::<Offer>() {
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, ParseError::InvalidSemantics(SemanticError::MissingNodeId)),
+		}
+	}
 }
 
 #[cfg(test)]