mirror of
https://codeberg.org/Toasterson/ips.git
synced 2026-04-10 13:20:42 +00:00
fc00304038
- Eliminate obsolete assertions for the root `file` directory as it is no longer created. - Update tests to validate file paths in `publisher`-specific directories, aligning with the updated repository structure. - Simplify `create_directories` by removing unnecessary `file` directory creation.
559 lines
No EOL
18 KiB
Rust
559 lines
No EOL
18 KiB
Rust
// This Source Code Form is subject to the terms of
|
|
// the Mozilla Public License, v. 2.0. If a copy of the
|
|
// MPL was not distributed with this file, You can
|
|
// obtain one at https://mozilla.org/MPL/2.0/.
|
|
|
|
#[cfg(test)]
|
|
mod e2e_tests {
|
|
use std::env;
|
|
use std::fs;
|
|
use std::path::PathBuf;
|
|
use std::process::Command;
|
|
use std::str;
|
|
|
|
// The base directory for all test repositories
|
|
const TEST_REPO_BASE_DIR: &str = "/tmp/pkg6repo_e2e_test";
|
|
|
|
// Get the path to the pre-built binaries
|
|
fn get_bin_dir() -> PathBuf {
|
|
match env::var("PKG6_TEST_BIN_DIR") {
|
|
Ok(dir) => PathBuf::from(dir),
|
|
Err(_) => {
|
|
// Fallback to the default location if the environment variable is not set
|
|
PathBuf::from("/tmp/pkg6_test/bin")
|
|
}
|
|
}
|
|
}
|
|
|
|
// Helper function to create a unique test directory
|
|
fn create_test_dir(test_name: &str) -> PathBuf {
|
|
let test_dir = PathBuf::from(format!("{}/{}", TEST_REPO_BASE_DIR, test_name));
|
|
|
|
// Clean up any existing directory
|
|
if test_dir.exists() {
|
|
fs::remove_dir_all(&test_dir).unwrap();
|
|
}
|
|
|
|
// Create the directory
|
|
fs::create_dir_all(&test_dir).unwrap();
|
|
|
|
test_dir
|
|
}
|
|
|
|
// Helper function to clean up test directory
|
|
fn cleanup_test_dir(test_dir: &PathBuf) {
|
|
if test_dir.exists() {
|
|
fs::remove_dir_all(test_dir).unwrap();
|
|
}
|
|
}
|
|
|
|
// Helper function to set up the test environment
|
|
fn run_setup_script() -> (PathBuf, PathBuf) {
|
|
// Run the xtask setup-test-env command
|
|
let output = Command::new("cargo")
|
|
.args(["run", "-p", "xtask", "--", "setup-test-env"])
|
|
.output()
|
|
.expect("Failed to run xtask setup-test-env");
|
|
|
|
if !output.status.success() {
|
|
panic!(
|
|
"Failed to set up test environment: {}",
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
}
|
|
|
|
// Return the paths to the prototype and manifest directories
|
|
(
|
|
PathBuf::from("/tmp/pkg6_test/prototype"),
|
|
PathBuf::from("/tmp/pkg6_test/manifests"),
|
|
)
|
|
}
|
|
|
|
// Helper function to run pkg6repo command
|
|
fn run_pkg6repo(args: &[&str]) -> Result<String, String> {
|
|
let bin_dir = get_bin_dir();
|
|
let pkg6repo_bin = bin_dir.join("pkg6repo");
|
|
|
|
// Check if the binary exists
|
|
if !pkg6repo_bin.exists() {
|
|
return Err(format!(
|
|
"pkg6repo binary not found at {}. Run 'cargo xtask build-e2e' first.",
|
|
pkg6repo_bin.display()
|
|
));
|
|
}
|
|
|
|
let output = Command::new(pkg6repo_bin)
|
|
.args(args)
|
|
.output()
|
|
.expect("Failed to execute pkg6repo command");
|
|
|
|
if output.status.success() {
|
|
Ok(String::from_utf8_lossy(&output.stdout).to_string())
|
|
} else {
|
|
Err(String::from_utf8_lossy(&output.stderr).to_string())
|
|
}
|
|
}
|
|
|
|
// Helper function to run pkg6dev command
|
|
fn run_pkg6dev(args: &[&str]) -> Result<String, String> {
|
|
let bin_dir = get_bin_dir();
|
|
let pkg6dev_bin = bin_dir.join("pkg6dev");
|
|
|
|
// Check if the binary exists
|
|
if !pkg6dev_bin.exists() {
|
|
return Err(format!(
|
|
"pkg6dev binary not found at {}. Run 'cargo xtask build-e2e' first.",
|
|
pkg6dev_bin.display()
|
|
));
|
|
}
|
|
|
|
let output = Command::new(pkg6dev_bin)
|
|
.args(args)
|
|
.output()
|
|
.expect("Failed to execute pkg6dev command");
|
|
|
|
if output.status.success() {
|
|
Ok(String::from_utf8_lossy(&output.stdout).to_string())
|
|
} else {
|
|
Err(String::from_utf8_lossy(&output.stderr).to_string())
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_e2e_create_repository() {
|
|
// Create a test directory
|
|
let test_dir = create_test_dir("e2e_create_repository");
|
|
let repo_path = test_dir.join("repo");
|
|
|
|
// Create a repository using pkg6repo
|
|
let result = run_pkg6repo(&["create", "--repo-version", "4", repo_path.to_str().unwrap()]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to create repository: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Check that the repository was created
|
|
assert!(repo_path.exists());
|
|
assert!(repo_path.join("publisher").exists());
|
|
assert!(repo_path.join("index").exists());
|
|
assert!(repo_path.join("trans").exists());
|
|
assert!(repo_path.join("pkg6.repository").exists());
|
|
|
|
// Clean up
|
|
cleanup_test_dir(&test_dir);
|
|
}
|
|
|
|
#[test]
|
|
fn test_e2e_add_publisher() {
|
|
// Create a test directory
|
|
let test_dir = create_test_dir("e2e_add_publisher");
|
|
let repo_path = test_dir.join("repo");
|
|
|
|
// Create a repository using pkg6repo
|
|
let result = run_pkg6repo(&["create", "--repo-version", "4", repo_path.to_str().unwrap()]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to create repository: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Add a publisher using pkg6repo
|
|
let result = run_pkg6repo(&[
|
|
"add-publisher",
|
|
"-s",
|
|
repo_path.to_str().unwrap(),
|
|
"example.com",
|
|
]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to add publisher: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Check that the publisher was added
|
|
assert!(repo_path.join("publisher").join("example.com").exists());
|
|
assert!(repo_path.join("publisher").join("example.com").join("catalog").exists());
|
|
assert!(repo_path.join("publisher").join("example.com").join("pkg").exists());
|
|
|
|
// Clean up
|
|
cleanup_test_dir(&test_dir);
|
|
}
|
|
|
|
#[test]
|
|
fn test_e2e_publish_package() {
|
|
// Run the setup script to prepare the test environment
|
|
let (prototype_dir, manifest_dir) = run_setup_script();
|
|
|
|
// Create a test directory
|
|
let test_dir = create_test_dir("e2e_publish_package");
|
|
let repo_path = test_dir.join("repo");
|
|
|
|
// Create a repository using pkg6repo
|
|
let result = run_pkg6repo(&["create", "--repo-version", "4", repo_path.to_str().unwrap()]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to create repository: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Add a publisher using pkg6repo
|
|
let result = run_pkg6repo(&["add-publisher", "-s", repo_path.to_str().unwrap(), "test"]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to add publisher: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Publish a package using pkg6dev
|
|
let manifest_path = manifest_dir.join("example.p5m");
|
|
let result = run_pkg6dev(&[
|
|
"publish",
|
|
"--manifest-path",
|
|
manifest_path.to_str().unwrap(),
|
|
"--prototype-dir",
|
|
prototype_dir.to_str().unwrap(),
|
|
"--repo-path",
|
|
repo_path.to_str().unwrap(),
|
|
]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to publish package: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Check that the package was published
|
|
let result = run_pkg6repo(&["list", "-s", repo_path.to_str().unwrap()]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to list packages: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
let output = result.unwrap();
|
|
assert!(
|
|
output.contains("example"),
|
|
"Package not found in repository"
|
|
);
|
|
|
|
// Clean up
|
|
cleanup_test_dir(&test_dir);
|
|
}
|
|
|
|
#[test]
|
|
fn test_e2e_show_contents() {
|
|
// Run the setup script to prepare the test environment
|
|
let (prototype_dir, manifest_dir) = run_setup_script();
|
|
|
|
// Create a test directory
|
|
let test_dir = create_test_dir("e2e_show_contents");
|
|
let repo_path = test_dir.join("repo");
|
|
|
|
// Create a repository using pkg6repo
|
|
let result = run_pkg6repo(&["create", "--repo-version", "4", repo_path.to_str().unwrap()]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to create repository: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Add a publisher using pkg6repo
|
|
let result = run_pkg6repo(&["add-publisher", "-s", repo_path.to_str().unwrap(), "test"]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to add publisher: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Publish a package using pkg6dev
|
|
let manifest_path = manifest_dir.join("example.p5m");
|
|
let result = run_pkg6dev(&[
|
|
"publish",
|
|
"--manifest-path",
|
|
manifest_path.to_str().unwrap(),
|
|
"--prototype-dir",
|
|
prototype_dir.to_str().unwrap(),
|
|
"--repo-path",
|
|
repo_path.to_str().unwrap(),
|
|
]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to publish package: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Show package contents using pkg6repo
|
|
let result = run_pkg6repo(&["contents", "-s", repo_path.to_str().unwrap(), "example"]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to show package contents: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
let output = result.unwrap();
|
|
assert!(
|
|
output.contains("usr/bin/hello"),
|
|
"File not found in package contents"
|
|
);
|
|
assert!(
|
|
output.contains("usr/share/doc/example/README.txt"),
|
|
"File not found in package contents"
|
|
);
|
|
assert!(
|
|
output.contains("etc/config/example.conf"),
|
|
"File not found in package contents"
|
|
);
|
|
|
|
// Clean up
|
|
cleanup_test_dir(&test_dir);
|
|
}
|
|
|
|
#[test]
|
|
fn test_e2e_multiple_packages() {
|
|
// Run the setup script to prepare the test environment
|
|
let (prototype_dir, manifest_dir) = run_setup_script();
|
|
|
|
// Create a test directory
|
|
let test_dir = create_test_dir("e2e_multiple_packages");
|
|
let repo_path = test_dir.join("repo");
|
|
|
|
// Create a repository using pkg6repo
|
|
let result = run_pkg6repo(&["create", "--repo-version", "4", repo_path.to_str().unwrap()]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to create repository: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Add a publisher using pkg6repo
|
|
let result = run_pkg6repo(&["add-publisher", "-s", repo_path.to_str().unwrap(), "test"]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to add publisher: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Publish the first package using pkg6dev
|
|
let manifest_path1 = manifest_dir.join("example.p5m");
|
|
let result = run_pkg6dev(&[
|
|
"publish",
|
|
"--manifest-path",
|
|
manifest_path1.to_str().unwrap(),
|
|
"--prototype-dir",
|
|
prototype_dir.to_str().unwrap(),
|
|
"--repo-path",
|
|
repo_path.to_str().unwrap(),
|
|
]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to publish first package: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Publish the second package using pkg6dev
|
|
let manifest_path2 = manifest_dir.join("example2.p5m");
|
|
let result = run_pkg6dev(&[
|
|
"publish",
|
|
"--manifest-path",
|
|
manifest_path2.to_str().unwrap(),
|
|
"--prototype-dir",
|
|
prototype_dir.to_str().unwrap(),
|
|
"--repo-path",
|
|
repo_path.to_str().unwrap(),
|
|
]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to publish second package: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// List packages using pkg6repo
|
|
let result = run_pkg6repo(&["list", "-s", repo_path.to_str().unwrap()]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to list packages: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
let output = result.unwrap();
|
|
assert!(
|
|
output.contains("example"),
|
|
"First package not found in repository"
|
|
);
|
|
assert!(
|
|
output.contains("example2"),
|
|
"Second package not found in repository"
|
|
);
|
|
|
|
// Clean up
|
|
cleanup_test_dir(&test_dir);
|
|
}
|
|
|
|
#[test]
|
|
fn test_e2e_obsoleted_packages() {
|
|
// Run the setup script to prepare the test environment
|
|
let (prototype_dir, manifest_dir) = run_setup_script();
|
|
|
|
// Create a test directory
|
|
let test_dir = create_test_dir("e2e_obsoleted_packages");
|
|
let repo_path = test_dir.join("repo");
|
|
|
|
// Create a repository using pkg6repo
|
|
let result = run_pkg6repo(&["create", "--repo-version", "4", repo_path.to_str().unwrap()]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to create repository: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Add a publisher using pkg6repo
|
|
let result = run_pkg6repo(&["add-publisher", "-s", repo_path.to_str().unwrap(), "test"]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to add publisher: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Publish a package using pkg6dev
|
|
let manifest_path = manifest_dir.join("example.p5m");
|
|
let result = run_pkg6dev(&[
|
|
"publish",
|
|
"--manifest-path",
|
|
manifest_path.to_str().unwrap(),
|
|
"--prototype-dir",
|
|
prototype_dir.to_str().unwrap(),
|
|
"--repo-path",
|
|
repo_path.to_str().unwrap(),
|
|
]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to publish package: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Get the FMRI of the published package
|
|
let result = run_pkg6repo(&["list", "-s", repo_path.to_str().unwrap(), "-F", "json"]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to list packages: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
let output = result.unwrap();
|
|
let packages: serde_json::Value = serde_json::from_str(&output).expect("Failed to parse JSON output");
|
|
|
|
// The FMRI in the JSON is an object with scheme, publisher, name, and version fields
|
|
// We need to extract these fields and construct the FMRI string
|
|
let fmri_obj = &packages["packages"][0]["fmri"];
|
|
let scheme = fmri_obj["scheme"].as_str().expect("Failed to get scheme");
|
|
let publisher = fmri_obj["publisher"].as_str().expect("Failed to get publisher");
|
|
let name = fmri_obj["name"].as_str().expect("Failed to get name");
|
|
let version_obj = &fmri_obj["version"];
|
|
let release = version_obj["release"].as_str().expect("Failed to get release");
|
|
|
|
// Construct the FMRI string in the format "pkg://publisher/name@version"
|
|
let fmri = format!("{}://{}/{}", scheme, publisher, name);
|
|
|
|
// Add version if available
|
|
let fmri = if !release.is_empty() {
|
|
format!("{}@{}", fmri, release)
|
|
} else {
|
|
fmri
|
|
};
|
|
|
|
// Print the FMRI and repo path for debugging
|
|
println!("FMRI: {}", fmri);
|
|
println!("Repo path: {}", repo_path.display());
|
|
|
|
// Check if the package exists in the repository
|
|
let pkg_dir = repo_path.join("publisher").join("test").join("pkg").join("example");
|
|
println!("Package directory: {}", pkg_dir.display());
|
|
println!("Package directory exists: {}", pkg_dir.exists());
|
|
|
|
// List files in the package directory if it exists
|
|
if pkg_dir.exists() {
|
|
println!("Files in package directory:");
|
|
for entry in std::fs::read_dir(&pkg_dir).unwrap() {
|
|
let entry = entry.unwrap();
|
|
println!(" {}", entry.path().display());
|
|
}
|
|
}
|
|
|
|
// Mark the package as obsoleted
|
|
let result = run_pkg6repo(&[
|
|
"obsolete-package",
|
|
"-s", repo_path.to_str().unwrap(),
|
|
"-p", "test",
|
|
"-f", &fmri,
|
|
"-m", "This package is obsoleted for testing purposes",
|
|
"-r", "pkg://test/example2@1.0"
|
|
]);
|
|
|
|
// Print the result for debugging
|
|
println!("Result: {:?}", result);
|
|
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to mark package as obsoleted: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
// Verify the package is no longer in the main repository
|
|
let result = run_pkg6repo(&["list", "-s", repo_path.to_str().unwrap()]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to list packages: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
let output = result.unwrap();
|
|
assert!(
|
|
!output.contains("example"),
|
|
"Package still found in repository after being marked as obsoleted"
|
|
);
|
|
|
|
// List obsoleted packages
|
|
let result = run_pkg6repo(&["list-obsoleted", "-s", repo_path.to_str().unwrap(), "-p", "test"]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to list obsoleted packages: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
let output = result.unwrap();
|
|
assert!(
|
|
output.contains("example"),
|
|
"Obsoleted package not found in obsoleted packages list"
|
|
);
|
|
|
|
// Show details of the obsoleted package
|
|
let result = run_pkg6repo(&[
|
|
"show-obsoleted",
|
|
"-s", repo_path.to_str().unwrap(),
|
|
"-p", "test",
|
|
"-f", &fmri
|
|
]);
|
|
assert!(
|
|
result.is_ok(),
|
|
"Failed to show obsoleted package details: {:?}",
|
|
result.err()
|
|
);
|
|
|
|
let output = result.unwrap();
|
|
assert!(
|
|
output.contains("Status: obsolete"),
|
|
"Package not marked as obsolete in details"
|
|
);
|
|
assert!(
|
|
output.contains("This package is obsoleted for testing purposes"),
|
|
"Deprecation message not found in details"
|
|
);
|
|
assert!(
|
|
output.contains("pkg://test/example2@1.0"),
|
|
"Replacement package not found in details"
|
|
);
|
|
|
|
// Clean up
|
|
cleanup_test_dir(&test_dir);
|
|
}
|
|
} |