diff --git a/rust/agama-dbus-server/src/network/nm/dbus.rs b/rust/agama-dbus-server/src/network/nm/dbus.rs
index bfbf914781..f09dab30e1 100644
--- a/rust/agama-dbus-server/src/network/nm/dbus.rs
+++ b/rust/agama-dbus-server/src/network/nm/dbus.rs
@@ -491,9 +491,10 @@ mod test {
     };
     use crate::network::{model::*, nm::dbus::ETHERNET_KEY};
     use agama_lib::network::types::SSID;
-    use std::{collections::HashMap, net::IpAddr};
+    use cidr::IpInet;
+    use std::{collections::HashMap, net::IpAddr, str::FromStr};
     use uuid::Uuid;
-    use zbus::zvariant::{self, OwnedValue, Value};
+    use zbus::zvariant::{self, Array, Dict, OwnedValue, Value};
 
     #[test]
     fn test_connection_from_dbus() {
@@ -508,6 +509,13 @@ mod test {
             ("prefix".to_string(), Value::new(24_u32)),
         ])];
 
+        let route_v4_data = vec![HashMap::from([
+            ("dest".to_string(), Value::new("192.168.0.0")),
+            ("prefix".to_string(), Value::new(24_u32)),
+            ("next-hop".to_string(), Value::new("192.168.0.1")),
+            ("metric".to_string(), Value::new(100_u32)),
+        ])];
+
         let ipv4_section = HashMap::from([
             ("method".to_string(), Value::new("auto").to_owned()),
             (
@@ -519,6 +527,10 @@ mod test {
                 "dns-data".to_string(),
                 Value::new(vec!["192.168.0.2"]).to_owned(),
             ),
+            (
+                "route-data".to_string(),
+                Value::new(route_v4_data).to_owned(),
+            ),
         ]);
 
         let address_v6_data = vec![HashMap::from([
@@ -526,6 +538,13 @@ mod test {
             ("prefix".to_string(), Value::new(24_u32)),
         ])];
 
+        let route_v6_data = vec![HashMap::from([
+            ("dest".to_string(), Value::new("2001:db8::")),
+            ("prefix".to_string(), Value::new(64_u32)),
+            ("next-hop".to_string(), Value::new("2001:db8::1")),
+            ("metric".to_string(), Value::new(100_u32)),
+        ])];
+
         let ipv6_section = HashMap::from([
             ("method".to_string(), Value::new("auto").to_owned()),
             (
@@ -540,6 +559,10 @@ mod test {
                 "dns-data".to_string(),
                 Value::new(vec!["::ffff:c0a8:102"]).to_owned(),
             ),
+            (
+                "route-data".to_string(),
+                Value::new(route_v6_data).to_owned(),
+            ),
         ]);
 
         let match_section = HashMap::from([(
@@ -578,6 +601,24 @@ mod test {
         );
         assert_eq!(ip_config.method4, Ipv4Method::Auto);
         assert_eq!(ip_config.method6, Ipv6Method::Auto);
+        assert!(ip_config.routes4.is_some());
+        assert_eq!(
+            ip_config.routes4,
+            Some(vec![IpRoute {
+                destination: IpInet::new("192.168.0.0".parse().unwrap(), 24_u8).unwrap(),
+                next_hop: Some(IpAddr::from_str("192.168.0.1").unwrap()),
+                metric: Some(100)
+            }])
+        );
+        assert!(ip_config.routes6.is_some());
+        assert_eq!(
+            ip_config.routes6,
+            Some(vec![IpRoute {
+                destination: IpInet::new("2001:db8::".parse().unwrap(), 64_u8).unwrap(),
+                next_hop: Some(IpAddr::from_str("2001:db8::1").unwrap()),
+                metric: Some(100)
+            }])
+        );
     }
 
     #[test]
@@ -789,6 +830,16 @@ mod test {
             addresses,
             gateway4: Some("192.168.0.1".parse().unwrap()),
             gateway6: Some("::ffff:c0a8:1".parse().unwrap()),
+            routes4: Some(vec![IpRoute {
+                destination: IpInet::new("192.168.0.0".parse().unwrap(), 24_u8).unwrap(),
+                next_hop: Some(IpAddr::from_str("192.168.0.1").unwrap()),
+                metric: Some(100),
+            }]),
+            routes6: Some(vec![IpRoute {
+                destination: IpInet::new("2001:db8::".parse().unwrap(), 64_u8).unwrap(),
+                next_hop: Some(IpAddr::from_str("2001:db8::1").unwrap()),
+                metric: Some(100),
+            }]),
             ..Default::default()
         };
         BaseConnection {
@@ -811,7 +862,49 @@ mod test {
         assert_eq!(id, "agama");
 
         let ipv4_dbus = conn_dbus.get("ipv4").unwrap();
-        let gateway: &str = ipv4_dbus.get("gateway").unwrap().downcast_ref().unwrap();
-        assert_eq!(gateway, "192.168.0.1");
+        let gateway4: &str = ipv4_dbus.get("gateway").unwrap().downcast_ref().unwrap();
+        assert_eq!(gateway4, "192.168.0.1");
+        let routes4_array: Array = ipv4_dbus
+            .get("route-data")
+            .unwrap()
+            .downcast_ref::<Value>()
+            .unwrap()
+            .try_into()
+            .unwrap();
+        for route4 in routes4_array.iter() {
+            let route4_dict: Dict = route4.downcast_ref::<Value>().unwrap().try_into().unwrap();
+            let route4_hashmap: HashMap<String, Value> = route4_dict.try_into().unwrap();
+            assert!(route4_hashmap.contains_key("dest"));
+            assert_eq!(route4_hashmap["dest"], Value::from("192.168.0.0"));
+            assert!(route4_hashmap.contains_key("prefix"));
+            assert_eq!(route4_hashmap["prefix"], Value::from(24_u32));
+            assert!(route4_hashmap.contains_key("next-hop"));
+            assert_eq!(route4_hashmap["next-hop"], Value::from("192.168.0.1"));
+            assert!(route4_hashmap.contains_key("metric"));
+            assert_eq!(route4_hashmap["metric"], Value::from(100_u32));
+        }
+
+        let ipv6_dbus = conn_dbus.get("ipv6").unwrap();
+        let gateway6: &str = ipv6_dbus.get("gateway").unwrap().downcast_ref().unwrap();
+        assert_eq!(gateway6, "::ffff:192.168.0.1");
+        let routes6_array: Array = ipv6_dbus
+            .get("route-data")
+            .unwrap()
+            .downcast_ref::<Value>()
+            .unwrap()
+            .try_into()
+            .unwrap();
+        for route6 in routes6_array.iter() {
+            let route6_dict: Dict = route6.downcast_ref::<Value>().unwrap().try_into().unwrap();
+            let route6_hashmap: HashMap<String, Value> = route6_dict.try_into().unwrap();
+            assert!(route6_hashmap.contains_key("dest"));
+            assert_eq!(route6_hashmap["dest"], Value::from("2001:db8::"));
+            assert!(route6_hashmap.contains_key("prefix"));
+            assert_eq!(route6_hashmap["prefix"], Value::from(64_u32));
+            assert!(route6_hashmap.contains_key("next-hop"));
+            assert_eq!(route6_hashmap["next-hop"], Value::from("2001:db8::1"));
+            assert!(route6_hashmap.contains_key("metric"));
+            assert_eq!(route6_hashmap["metric"], Value::from(100_u32));
+        }
     }
 }