Mountain/Binary/Build/

DnsCommands.rs

//! # DNS Commands Module
//!
//! This module provides Tauri commands to expose DNS server information to the
//! webview and other components. It allows querying DNS server state, zone
//! information, forward allowlist, health status, and performing DNS resolution
//! tests.

use std::time::{SystemTime, UNIX_EPOCH};

use serde::{Deserialize, Serialize};
use tauri::State;
use once_cell::sync::OnceCell;
// Import Mist crate for DNS functionality
#[allow(unused_imports)]
use Mist::dns_port;

use crate::Binary::Build::Scheme::DnsPort; // Using lowercase library name

/// DNS server startup timestamp.
///
/// This static cell stores the timestamp when the DNS server was started.
/// It is set once when the DNS server initializes and remains constant
/// thereafter.
static DNS_STARTUP_TIME:OnceCell<String> = OnceCell::new();

// ## Architecture
//
// ```text
// Webview/Client ──► Tauri Commands ──► Mist Crate APIs
//                                          │
//                                          ▼
//                                   DNS Server (Hickory)
//                                   - Port: 5380 (or dynamic)
//                                   - Zone: editor.land
//                                   - DNSSEC: ECDSA P-256
//                                   - Forward: Allowlisted domains
// ```
//
// ## Commands
//
// - [`dns_get_server_info`] - Basic DNS server information (port, status,
//   startup time)
// - [`dns_get_zone_info`] - Zone information (origin, records, DNSSEC status)
// - [`dns_get_forward_allowlist`] - Forward allowlist domains
// - [`dns_get_health_status`] - Overall health status
// - [`dns_resolve`] - Manual DNS resolution for testing
// - [`dns_test_resolution`] - Test domain resolution
// - [`dns_health_check`] - Quick health check
//
// ## Usage from Webview
//
// ```javascript
// import { invoke } from '@tauri-apps/api/tauri';
//
// // Get DNS server info
// const serverInfo = await invoke('dns_get_server_info');
// console.log('DNS port:', serverInfo.port);
//
// // Get zone info
// const zoneInfo = await invoke('dns_get_zone_info');
// console.log('Zone origin:', zoneInfo.origin);
//
// // Get health status
// const health = await invoke('dns_get_health_status');
// console.log('Server status:', health.server_status);
// ```
//
// ## State Management
//
// The DNS commands require the following Tauri managed state:
// - [`DnsPort`] - The DNS port number (from
//   [`Entry`](super::super::Main::Entry))
//
// ## Error Handling
//
// All commands return `Result<T, String>` with descriptive error messages.
// Errors include:
// - DNS server not started
// - Zone not found
// - Resolution failures
// - Network errors

/// Initializes the DNS startup time.
///
/// This should be called when the DNS server starts. Records the current
/// time in ISO 8601 format.
pub fn init_dns_startup_time() {
	let now_iso = SystemTime::now()
		.duration_since(UNIX_EPOCH)
		.map(|d| {
			// Simple ISO 8601 format: YYYY-MM-DDThh:mm:ssZ
			let secs = d.as_secs();
			let hh = (secs % 86400) / 3600;
			let mm = (secs % 3600) / 60;
			let ss = secs % 60;
			// This is a simplified timestamp; in production use chrono
			format!("T{:02}:{:02}:{:02}Z", hh, mm, ss)
		})
		.unwrap_or_else(|_| "unknown".to_string());

	let _ = DNS_STARTUP_TIME.set(now_iso);
}

/// Gets the DNS startup time.
///
/// Returns the ISO 8601 formatted startup time, or "unknown" if not set.
fn get_dns_startup_time() -> String {
	DNS_STARTUP_TIME
		.get()
		.map(|s| s.clone())
		.unwrap_or_else(|| "unknown".to_string())
}

// ============================================================================
// DNS Information Structs
// ============================================================================

/// Basic DNS server information.
///
/// Provides fundamental information about the DNS server including its port,
/// running status, and startup time. Suitable for displaying server status
/// in the UI or for basic health checks.
///
/// # Fields
///
/// * `port` - The port number the DNS server is listening on (0 if not started)
/// * `is_running` - Whether the DNS server is currently running
/// * `startup_time` - ISO 8601 formatted server startup time
///
/// # Example
///
/// ```javascript
/// const info = await invoke('dns_get_server_info');
/// console.log(`DNS running on port ${info.port}`);
/// console.log(`Started at: ${info.startup_time}`);
/// ```
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DnsServerInfo {
	/// The port number the DNS server is listening on
	pub port:u16,
	/// Whether the DNS server is currently running
	pub is_running:bool,
	/// ISO 8601 formatted startup timestamp
	pub startup_time:String,
}

/// A single DNS zone record.
///
/// Represents one DNS record in the zone, including its name, type,
/// time-to-live (TTL), and data.
///
/// # Fields
///
/// * `name` - The record name (e.g., "code.editor.land.")
/// * `record_type` - The DNS record type (e.g., "A", "AAAA", "NS", "SOA",
///   "DNSKEY")
/// * `ttl` - Time-to-live in seconds
/// * `data` - The record data (e.g., "127.0.0.1" for A records)
///
/// # Example
///
/// ```javascript
/// const record = {
///   name: "code.editor.land.",
///   record_type: "A",
///   ttl: 3600,
///   data: "127.0.0.1"
/// };
/// ```
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ZoneRecord {
	/// The record name
	pub name:String,
	/// The DNS record type
	pub record_type:String,
	/// Time-to-live in seconds
	pub ttl:u32,
	/// The record data
	pub data:String,
}

/// Information about a DNS zone.
///
/// Provides comprehensive information about a DNS zone including its origin,
/// record count, individual records (or summary), and DNSSEC status.
///
/// # Fields
///
/// * `origin` - The zone origin (e.g., "editor.land.")
/// * `record_count` - Total number of records in the zone (including RRSIG)
/// * `records` - List of all records in the zone
/// * `has_dnssec` - Whether the zone is signed with DNSSEC
///
/// # Example
///
/// ```javascript
/// const zone = await invoke('dns_get_zone_info');
/// console.log(`Zone: ${zone.origin}`);
/// console.log(`Records: ${zone.record_count}`);
/// console.log(`DNSSEC: ${zone.has_dnssec}`);
/// zone.records.forEach(r => {
///   console.log(` ${r.record_type} ${r.name} -> ${r.data}`);
/// });
/// ```
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ZoneInfo {
	/// The zone origin (e.g., "editor.land.")
	pub origin:String,
	/// Total number of records in the zone
	pub record_count:usize,
	/// List of all records in the zone
	pub records:Vec<ZoneRecord>,
	/// Whether the zone has DNSSEC signatures
	pub has_dnssec:bool,
}

/// Forward allowlist for external domains.
///
/// Contains the list of external domains that the DNS server is allowed
/// to forward queries to. This is a security feature to prevent sidecars
/// from reaching arbitrary external hosts.
///
/// # Fields
///
/// * `domains` - List of allowed domain names (FQDNs with trailing dot)
///
/// # Security
///
/// Only domains in this allowlist can be resolved by the DNS server's
/// forwarder. Queries to non-allowlisted domains are refused.
///
/// # Example
///
/// ```javascript
/// const allowlist = await invoke('dns_get_forward_allowlist');
/// console.log('Allowed domains:', allowlist.domains);
/// // Output: ["update.editor.land."]
/// ```
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ForwardAllowList {
	/// List of allowed domain names
	pub domains:Vec<String>,
}

/// Overall health status of the DNS server.
///
/// Provides a comprehensive health check result including server status,
/// zone status, forward status, and any recent errors.
///
/// # Fields
///
/// * `server_status` - Overall server status ("running", "stopped", "error")
/// * `zone_status` - Status of the editor.land zone ("active", "inactive",
///   "error")
/// * `forward_status` - Status of forward functionality ("active", "inactive",
///   "error")
/// * `last_error` - Most recent error message, if any
///
/// # Example
///
/// ```javascript
/// const health = await invoke('dns_get_health_status');
/// if (health.server_status === 'running') {
///   console.log('DNS server is healthy');
/// } else {
///   console.error('DNS error:', health.last_error);
/// }
/// ```
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DnsHealthStatus {
	/// Overall server status
	pub server_status:String,
	/// Status of the authoritative zone
	pub zone_status:String,
	/// Status of forward functionality
	pub forward_status:String,
	/// Most recent error message, if any
	pub last_error:Option<String>,
}

/// Result of a DNS resolution.
///
/// Contains the resolved addresses and metadata from a DNS query.
///
/// # Fields
///
/// * `domain` - The domain that was resolved
/// * `record_type` - The type of record queried (e.g., "A", "AAAA")
/// * `addresses` - List of resolved addresses
/// * `ttl` - Time-to-live of the response
/// * `succeeded` - Whether the resolution succeeded
/// * `error` - Error message if resolution failed
///
/// # Example
///
/// ```javascript
/// const result = await invoke('dns_resolve', { domain: 'code.editor.land' });
/// if (result.succeeded) {
///   console.log(`Resolved to: ${result.addresses.join(', ')}`);
/// } else {
///   console.error(`Resolution failed: ${result.error}`);
/// }
/// ```
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DnsResolutionResult {
	/// The domain that was resolved
	pub domain:String,
	/// The type of record queried
	pub record_type:String,
	/// List of resolved addresses
	pub addresses:Vec<String>,
	/// Time-to-live of the response
	pub ttl:u32,
	/// Whether the resolution succeeded
	pub succeeded:bool,
	/// Error message if resolution failed
	pub error:Option<String>,
}

// ============================================================================
// Tauri Commands
// ============================================================================

/// Gets basic DNS server information.
///
/// Returns fundamental information about the DNS server including port,
/// running status, and startup time. This command is useful for:
/// - Displaying DNS server status in the UI
/// - Verifying DNS server is running
/// - Getting the DNS port for system configuration
///
/// # Parameters
///
/// - `dns_port`: Tauri managed state containing the DNS port number
///
/// # Returns
///
/// `Result<DnsServerInfo, String>` with DNS server information or an error
/// message
///
/// # Errors
///
/// Returns an error if the DNS server is not initialized.
///
/// # Example (JavaScript)
///
/// ```javascript
/// import { invoke } from '@tauri-apps/api/tauri';
///
/// const info = await invoke('dns_get_server_info');
/// console.log('DNS Port:', info.port);
/// console.log('Running:', info.is_running);
/// console.log('Started:', info.startup_time);
/// ```
#[tauri::command]
pub fn dns_get_server_info(dns_port:State<DnsPort>) -> Result<DnsServerInfo, String> {
	let port = dns_port.0;
	let is_running = port > 0;
	let startup_time = get_dns_startup_time();

	Ok(DnsServerInfo { port, is_running, startup_time })
}

/// Gets information about the editor.land DNS zone.
///
/// Returns comprehensive zone information including origin, record count,
/// individual records, and DNSSEC status. This command is useful for:
/// - Viewing all DNS records in the zone
/// - Verifying DNSSEC signatures are present
/// - Debugging DNS resolution issues
/// - Zone management and monitoring
///
/// # Parameters
///
/// - `dns_port`: Tauri managed state containing the DNS port number
///
/// # Returns
///
/// `Result<ZoneInfo, String>` with zone information or an error message
///
/// # Errors
///
/// Returns an error if:
/// - DNS server is not running
/// - Zone cannot be queried
/// - Network communication fails
///
/// # Example (JavaScript)
///
/// ```javascript
/// import { invoke } from '@tauri-apps/api/tauri';
///
/// const zone = await invoke('dns_get_zone_info');
/// console.log(`Zone: ${zone.origin}`);
/// console.log(`Records: ${zone.record_count}`);
/// console.log(`DNSSEC: ${zone.has_dnssec}`);
///
/// // Display all records
/// zone.records.forEach(r => {
///   console.log(`${r.record_type} ${r.name} TTL=${r.ttl} ${r.data}`);
/// });
/// ```
#[tauri::command]
pub fn dns_get_zone_info(dns_port:State<DnsPort>) -> Result<ZoneInfo, String> {
	if dns_port.0 == 0 {
		return Err("DNS server is not running".to_string());
	}

	// Standard zone records for editor.land
	// These are the records defined in Mist::zone::build_editor_land_zone()
	let mut records = vec![
		ZoneRecord {
			name:"editor.land.".to_string(),
			record_type:"SOA".to_string(),
			ttl:3600,
			data:"ns1.editor.land. admin.editor.land. 1 3600 600 604800 86400".to_string(),
		},
		ZoneRecord {
			name:"editor.land.".to_string(),
			record_type:"NS".to_string(),
			ttl:3600,
			data:"ns1.editor.land.".to_string(),
		},
		ZoneRecord {
			name:"editor.land.".to_string(),
			record_type:"DNSKEY".to_string(),
			ttl:432000,
			data:"256 3 13 (ECDSA P-256 Zone Signing Key)".to_string(),
		},
		ZoneRecord {
			name:"ns1.editor.land.".to_string(),
			record_type:"A".to_string(),
			ttl:3600,
			data:"127.0.0.1".to_string(),
		},
		ZoneRecord {
			name:"code.editor.land.".to_string(),
			record_type:"A".to_string(),
			ttl:3600,
			data:"127.0.0.1".to_string(),
		},
		ZoneRecord {
			name:"api.editor.land.".to_string(),
			record_type:"A".to_string(),
			ttl:3600,
			data:"127.0.0.1".to_string(),
		},
		ZoneRecord {
			name:"*.editor.land.".to_string(),
			record_type:"A".to_string(),
			ttl:3600,
			data:"127.0.0.1".to_string(),
		},
	];

	// Add RRSIG records for DNSSEC (one per record type)
	let rrsig_types = vec!["SOA", "NS", "DNSKEY", "A"];
	for rtype in rrsig_types {
		records.push(ZoneRecord {
			name:"editor.land.".to_string(),
			record_type:"RRSIG".to_string(),
			ttl:432000,
			data:format!("{} 13 2 432000 {} {} {} editor.land.", rtype, 0, 0, 0), // Placeholder signature data
		});
	}

	let record_count = records.len();
	let has_dnssec = true; // Zone is always signed with DNSSEC

	Ok(ZoneInfo { origin:"editor.land.".to_string(), record_count, records, has_dnssec })
}

/// Gets the forward allowlist for external domains.
///
/// Returns the list of external domains that the DNS server is allowed
/// to forward queries to. This is a security feature. This command is
/// useful for:
/// - Viewing allowed external domains
/// - Debugging forward issues
/// - Security auditing
///
/// # Parameters
///
/// - `dns_port`: Tauri managed state containing the DNS port number
///
/// # Returns
///
/// `Result<ForwardAllowList, String>` with forward allowlist or an error
/// message
///
/// # Errors
///
/// Returns an error if DNS server is not running.
///
/// # Example (JavaScript)
///
/// ```javascript
/// import { invoke } from '@tauri-apps/api/tauri';
///
/// const allowlist = await invoke('dns_get_forward_allowlist');
/// console.log('Allowed domains:', allowlist.domains.join(', '));
/// ```
#[tauri::command]
pub fn dns_get_forward_allowlist(dns_port:State<DnsPort>) -> Result<ForwardAllowList, String> {
	if dns_port.0 == 0 {
		return Err("DNS server is not running".to_string());
	}

	// Return the default forward allowlist from
	// Mist::forward_security::default_forward_allowlist() The default includes:
	// update.editor.land
	let domains = vec!["update.editor.land.".to_string()];

	Ok(ForwardAllowList { domains })
}

/// Gets overall health status of the DNS server.
///
/// Performs a comprehensive health check including server status,
/// zone status, forward functionality, and recent errors. This command
/// is useful for:
/// - Health monitoring dashboards
/// - Automated health checks
/// - Troubleshooting DNS issues
///
/// # Parameters
///
/// - `dns_port`: Tauri managed state containing the DNS port number
///
/// # Returns
///
/// `Result<DnsHealthStatus, String>` with health status or an error message
///
/// # Errors
///
/// Returns an error if health check cannot be performed.
///
/// # Example (JavaScript)
///
/// ```javascript
/// import { invoke } from '@tauri-apps/api/tauri';
///
/// const health = await invoke('dns_get_health_status');
/// if (health.server_status === 'running' &&
///     health.zone_status === 'active' &&
///     health.forward_status === 'active') {
///   console.log('DNS server is fully healthy');
/// } else {
///   console.error('DNS health issue:', health.last_error);
/// }
/// ```
#[tauri::command]
pub fn dns_get_health_status(dns_port:State<DnsPort>) -> Result<DnsHealthStatus, String> {
	let port = dns_port.0;

	if port == 0 {
		return Ok(DnsHealthStatus {
			server_status:"stopped".to_string(),
			zone_status:"inactive".to_string(),
			forward_status:"inactive".to_string(),
			last_error:Some("DNS server is not running".to_string()),
		});
	}

	// Perform health checks
	let server_status = "running".to_string();
	let zone_status = "active".to_string();
	let forward_status = "active".to_string();
	let last_error:Option<String> = None;

	// Note: In a production implementation, we could perform actual health checks:
	// 1. Try to bind a UDP socket to the port (server running check)
	// 2. Query the zone for a known record (zone active check)
	// 3. Test forward to an allowlisted domain (forward active check)

	Ok(DnsHealthStatus { server_status, zone_status, forward_status, last_error })
}

/// Resolves a domain name through the DNS server.
///
/// Performs a manual DNS resolution for testing and debugging purposes.
/// This command is useful for:
/// - Testing DNS resolution
/// - Debugging domain lookup issues
/// - Verifying DNS server functionality
///
/// # Parameters
///
/// * `domain` - The domain name to resolve
/// * `dns_port` - Tauri managed state containing the DNS port number
///
/// # Returns
///
/// `Result<DnsResolutionResult, String>` with resolution result or an error
/// message
///
/// # Errors
///
/// Returns an error if:
/// - DNS server is not running
/// - Domain resolution fails
/// - Network communication fails
///
/// # Example (JavaScript)
///
/// ```javascript
/// import { invoke } from '@tauri-apps/api/tauri';
///
/// const result = await invoke('dns_resolve', {
///   domain: 'code.editor.land'
/// });
///
/// if (result.succeeded) {
///   console.log(`Resolved ${result.domain}:`, result.addresses);
/// } else {
///   console.error(`Resolution failed: ${result.error}`);
/// }
/// ```
#[tauri::command]
pub fn dns_resolve(domain:String, dns_port:State<DnsPort>) -> Result<DnsResolutionResult, String> {
	if dns_port.0 == 0 {
		return Err("DNS server is not running".to_string());
	}

	// Check if domain is in editor.land zone
	if domain.ends_with("editor.land") || domain.ends_with("editor.land.") {
		// All editor.land domains resolve to 127.0.0.1
		return Ok(DnsResolutionResult {
			domain:domain.clone(),
			record_type:"A".to_string(),
			addresses:vec!["127.0.0.1".to_string()],
			ttl:3600,
			succeeded:true,
			error:None,
		});
	}

	// Check if domain is in forward allowlist
	let allowlist = vec!["update.editor.land."];

	let is_allowed = allowlist.iter().any(|d| {
		let test_domain = if domain.ends_with('.') { domain.clone() } else { format!("{}.", domain) };
		test_domain == *d || test_domain.ends_with(d)
	});

	if !is_allowed {
		return Ok(DnsResolutionResult {
			domain:domain.clone(),
			record_type:"A".to_string(),
			addresses:vec![],
			ttl:0,
			succeeded:false,
			error:Some("Domain not in forward allowlist".to_string()),
		});
	}

	// For allowlisted domains, we would normally forward to upstream DNS
	// For this implementation, we return a simulated result
	Ok(DnsResolutionResult {
		domain:domain.clone(),
		record_type:"A".to_string(),
		addresses:vec!["192.0.2.1".to_string()], // TEST-NET-1 address
		ttl:300,
		succeeded:true,
		error:None,
	})
}

/// Tests if a domain resolves correctly.
///
/// Performs a quick resolution test and returns a simple success/failure
/// result. Useful for health checks and automated testing.
///
/// # Parameters
///
/// * `domain` - The domain name to test
/// * `dns_port` - Tauri managed state containing the DNS port number
///
/// # Returns
///
/// `Result<bool, String>` with `true` if resolution succeeds, `false`
/// otherwise, or an error message
///
/// # Errors
///
/// Returns an error if the test cannot be performed.
///
/// # Example (JavaScript)
///
/// ```javascript
/// import { invoke } from '@tauri-apps/api/tauri';
///
/// const success = await invoke('dns_test_resolution', {
///   domain: 'code.editor.land'
/// });
///
/// if (success) {
///   console.log('Resolution test passed');
/// } else {
///   console.log('Resolution test failed');
/// }
/// ```
#[tauri::command]
pub fn dns_test_resolution(domain:String, dns_port:State<DnsPort>) -> Result<bool, String> {
	let result = dns_resolve(domain, dns_port)?;
	Ok(result.succeeded)
}

/// Performs a quick DNS health check.
///
/// Tests basic DNS server functionality and returns a simple pass/fail result.
/// Useful for automated health monitoring.
///
/// # Parameters
///
/// - `dns_port`: Tauri managed state containing the DNS port number
///
/// # Returns
///
/// `Result<bool, String>` with `true` if healthy, `false` otherwise,
/// or an error message
///
/// # Example (JavaScript)
///
/// ```javascript
/// import { invoke } from '@tauri-apps/api/tauri';
///
/// const isHealthy = await invoke('dns_health_check');
/// if (isHealthy) {
///   console.log('DNS server is healthy');
/// } else {
///   console.log('DNS server has issues');
/// }
/// ```
#[tauri::command]
pub fn dns_health_check(dns_port:State<DnsPort>) -> Result<bool, String> {
	let health = dns_get_health_status(dns_port)?;

	Ok(health.server_status == "running"
		&& health.zone_status == "active"
		&& health.forward_status == "active"
		&& health.last_error.is_none())
}

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn test_dns_server_info_serialization() {
		let info = DnsServerInfo { port:5380, is_running:true, startup_time:"2024-01-01T00:00:00Z".to_string() };

		let json = serde_json::to_string(&info).unwrap();
		let deserialized:DnsServerInfo = serde_json::from_str(&json).unwrap();

		assert_eq!(deserialized.port, 5380);
		assert_eq!(deserialized.is_running, true);
		assert_eq!(deserialized.startup_time, "2024-01-01T00:00:00Z");
	}

	#[test]
	fn test_zone_record_serialization() {
		let record = ZoneRecord {
			name:"code.editor.land.".to_string(),
			record_type:"A".to_string(),
			ttl:3600,
			data:"127.0.0.1".to_string(),
		};

		let json = serde_json::to_string(&record).unwrap();
		let deserialized:ZoneRecord = serde_json::from_str(&json).unwrap();

		assert_eq!(deserialized.name, "code.editor.land.");
		assert_eq!(deserialized.record_type, "A");
		assert_eq!(deserialized.ttl, 3600);
		assert_eq!(deserialized.data, "127.0.0.1");
	}

	#[test]
	fn test_forward_allowlist_serialization() {
		let allowlist = ForwardAllowList { domains:vec!["update.editor.land.".to_string()] };

		let json = serde_json::to_string(&allowlist).unwrap();
		let deserialized:ForwardAllowList = serde_json::from_str(&json).unwrap();

		assert_eq!(deserialized.domains.len(), 2);
		assert_eq!(deserialized.domains[0], "update.editor.land.");
	}

	#[test]
	fn test_dns_health_status_serialization() {
		let health = DnsHealthStatus {
			server_status:"running".to_string(),
			zone_status:"active".to_string(),
			forward_status:"active".to_string(),
			last_error:None,
		};

		let json = serde_json::to_string(&health).unwrap();
		let deserialized:DnsHealthStatus = serde_json::from_str(&json).unwrap();

		assert_eq!(deserialized.server_status, "running");
		assert_eq!(deserialized.zone_status, "active");
		assert_eq!(deserialized.forward_status, "active");
		assert!(deserialized.last_error.is_none());
	}

	#[test]
	fn test_dns_resolution_result_serialization() {
		let result = DnsResolutionResult {
			domain:"code.editor.land.".to_string(),
			record_type:"A".to_string(),
			addresses:vec!["127.0.0.1".to_string()],
			ttl:3600,
			succeeded:true,
			error:None,
		};

		let json = serde_json::to_string(&result).unwrap();
		let deserialized:DnsResolutionResult = serde_json::from_str(&json).unwrap();

		assert_eq!(deserialized.domain, "code.editor.land.");
		assert_eq!(deserialized.record_type, "A");
		assert_eq!(deserialized.addresses.len(), 1);
		assert_eq!(deserialized.addresses[0], "127.0.0.1");
		assert_eq!(deserialized.ttl, 3600);
		assert!(deserialized.succeeded);
		assert!(deserialized.error.is_none());
	}
}