';
+
+ // Add JavaScript to handle dismissal
+ echo '';
+ }
+
/**
* Get plugin data from file
*/
@@ -531,24 +650,61 @@ class Updater
/**
* Maybe fix download issues by providing better HTTP args
*
- * @return boolean|\WP_Error $result
+ * This filter intercepts the download process for our GitHub releases
+ * to ensure proper temporary file handling and avoid PCLZIP errors.
+ *
+ * CRITICAL: This filter MUST return one of:
+ * - false (or WP_Error): Let WordPress handle the download normally
+ * - string: Path to an already-downloaded file for WordPress to use
+ * - NEVER return true or any other type!
+ *
+ * @param boolean|WP_Error $result The result from previous filters
+ * @param string $package The package URL being downloaded
+ * @param object $upgrader The WP_Upgrader instance
+ * @param array $hook_extra Extra hook data
+ * @return string|WP_Error|false Path to downloaded file, WP_Error on failure, or false to continue
*
* @since 1.1.0
*/
public function maybeFixDownload(
- bool|\WP_Error $result,
+ bool|WP_Error $result,
string $package,
object $upgrader,
array $hook_extra
- ): bool|\WP_Error {
- // Only handle GitHub downloads for our plugin
- if (!str_contains($package, "github.com") || !str_contains($package, $this->config->githubRepo)) {
+ ): string|WP_Error|false {
+ // If a previous filter already handled this, respect that decision
+ if (\is_wp_error($result)) {
return $result;
}
- // Use wp_remote_get with better parameters
+ // Only handle GitHub downloads for our specific repository
+ if (
+ empty($package) ||
+ !str_contains($package, "github.com") ||
+ !str_contains($package, $this->config->githubRepo)
+ ) {
+ return false; // Let WordPress handle it normally
+ }
+
+ // Additional safety check: ensure this is actually for our plugin
+ $is_our_plugin = false;
+ if (isset($hook_extra["plugin"]) && $hook_extra["plugin"] === $this->pluginSlug) {
+ $is_our_plugin = true;
+ } elseif (
+ isset($hook_extra["plugins"]) &&
+ is_array($hook_extra["plugins"]) &&
+ in_array($this->pluginSlug, $hook_extra["plugins"])
+ ) {
+ $is_our_plugin = true;
+ }
+
+ if (!$is_our_plugin) {
+ return false; // Not our plugin, let WordPress handle it
+ }
+
+ // Download the package with optimized settings
$args = [
- "timeout" => 300, // 5 minutes
+ "timeout" => 300, // 5 minutes for large files
"headers" => $this->getDownloadHeaders(),
"sslverify" => true,
"stream" => false,
@@ -558,32 +714,183 @@ class Updater
$response = \wp_remote_get($package, $args);
if (\is_wp_error($response)) {
- return $response;
+ return new WP_Error(
+ "download_failed",
+ sprintf(
+ $this->config->__("Failed to download package: %s"),
+ $response->get_error_message()
+ )
+ );
}
- if (200 !== \wp_remote_retrieve_response_code($response)) {
- return new \WP_Error("http_404", $this->config->__("Package not found"));
+ $response_code = \wp_remote_retrieve_response_code($response);
+ if (200 !== $response_code) {
+ return new WP_Error(
+ "http_error",
+ sprintf(
+ $this->config->__("Package download failed with HTTP code %d"),
+ $response_code
+ )
+ );
}
- // Write to temporary file
- $upload_dir = \wp_upload_dir();
- $temp_file = \wp_tempnam(basename($package), $upload_dir["basedir"] . "/");
-
- if (!$temp_file) {
- return new \WP_Error("temp_file_failed", $this->config->__("Could not create temporary file"));
+ // Get the response body
+ $body = \wp_remote_retrieve_body($response);
+ if (empty($body)) {
+ return new WP_Error(
+ "empty_response",
+ $this->config->__("Downloaded package is empty")
+ );
}
- $file_handle = @fopen($temp_file, "w");
+ // Create temporary file with our multi-tier fallback system
+ $temp_file = $this->createSecureTempFile($package);
+
+ if (\is_wp_error($temp_file)) {
+ return $temp_file;
+ }
+
+ // Write the downloaded content to the temporary file
+ $file_handle = @fopen($temp_file, "wb");
if (!$file_handle) {
- return new \WP_Error("file_open_failed", $this->config->__("Could not open file for writing"));
+ @unlink($temp_file); // Clean up if file was created but can't be opened
+ return new WP_Error(
+ "file_open_failed",
+ sprintf(
+ $this->config->__("Could not open temporary file for writing: %s"),
+ $temp_file
+ )
+ );
}
- fwrite($file_handle, \wp_remote_retrieve_body($response));
+ $bytes_written = fwrite($file_handle, $body);
fclose($file_handle);
+ // Verify write operation succeeded
+ if ($bytes_written === false || $bytes_written !== strlen($body)) {
+ @unlink($temp_file);
+ return new WP_Error(
+ "file_write_failed",
+ $this->config->__("Failed to write complete package to temporary file")
+ );
+ }
+
+ // Final verification: ensure file exists and is readable
+ if (!file_exists($temp_file)) {
+ return new WP_Error(
+ "file_missing",
+ $this->config->__("Temporary file disappeared after creation")
+ );
+ }
+
+ if (!is_readable($temp_file)) {
+ @unlink($temp_file);
+ return new WP_Error(
+ "file_not_readable",
+ $this->config->__("Temporary file is not readable")
+ );
+ }
+
+ // Verify it's actually a zip file
+ $file_size = filesize($temp_file);
+ if ($file_size < 100) { // Minimum size for a valid zip
+ @unlink($temp_file);
+ return new WP_Error(
+ "invalid_package",
+ sprintf(
+ $this->config->__("Downloaded file is too small (%d bytes) to be a valid package"),
+ $file_size
+ )
+ );
+ }
+
+ // SUCCESS: Return the path to the downloaded file
+ // WordPress will use this file for extraction
return $temp_file;
}
+ /**
+ * Create a secure temporary file with multiple fallback strategies
+ *
+ * Attempts different approaches to create a temporary file to avoid PCLZIP errors
+ * that can occur with restrictive /tmp directory permissions.
+ *
+ * @param string $package The package URL being downloaded
+ * @return string|WP_Error Path to temporary file or WP_Error on failure
+ *
+ * @since 1.1.4
+ */
+ private function createSecureTempFile(string $package): string|WP_Error
+ {
+ $filename = basename(parse_url($package, PHP_URL_PATH)) ?: "github-package.zip";
+
+ // Strategy 1: Use custom temporary directory if specified
+ if (!empty($this->config->customTempDir)) {
+ if (!is_dir($this->config->customTempDir)) {
+ @wp_mkdir_p($this->config->customTempDir);
+ }
+
+ if (is_dir($this->config->customTempDir) && is_writable($this->config->customTempDir)) {
+ $temp_file = \wp_tempnam($filename, $this->config->customTempDir . "/");
+ if ($temp_file) {
+ return $temp_file;
+ }
+ }
+ }
+
+ // Strategy 2: Use WordPress uploads directory
+ $upload_dir = \wp_upload_dir();
+ if (!empty($upload_dir["basedir"]) && is_writable($upload_dir["basedir"])) {
+ $temp_file = \wp_tempnam($filename, $upload_dir["basedir"] . "/");
+ if ($temp_file) {
+ return $temp_file;
+ }
+ }
+
+ // Strategy 3: Use WP_CONTENT_DIR/temp if it exists or can be created
+ $wp_content_temp = WP_CONTENT_DIR . "/temp";
+ if (!is_dir($wp_content_temp)) {
+ @wp_mkdir_p($wp_content_temp);
+ }
+
+ if (is_dir($wp_content_temp) && is_writable($wp_content_temp)) {
+ $temp_file = \wp_tempnam($filename, $wp_content_temp . "/");
+ if ($temp_file) {
+ return $temp_file;
+ }
+ }
+
+ // Strategy 4: Use WordPress temporary directory (if defined)
+ if (defined("WP_TEMP_DIR") && is_dir(WP_TEMP_DIR) && is_writable(WP_TEMP_DIR)) {
+ $temp_file = \wp_tempnam($filename, WP_TEMP_DIR . "/");
+ if ($temp_file) {
+ return $temp_file;
+ }
+ }
+
+ // Strategy 5: Try system temp directory as last resort
+ $temp_file = \wp_tempnam($filename);
+ if ($temp_file) {
+ return $temp_file;
+ }
+
+ // Strategy 6: Manual temp file creation in uploads dir
+ if (!empty($upload_dir["basedir"])) {
+ $manual_temp = $upload_dir["basedir"] . "/" . uniqid("wp_github_updater_", true) . ".tmp";
+ $handle = @fopen($manual_temp, "w");
+ if ($handle) {
+ fclose($handle);
+ return $manual_temp;
+ }
+ }
+
+ return new WP_Error(
+ "temp_file_creation_failed",
+ $this->config->__("Could not create temporary file. Please check directory permissions " .
+ "or define WP_TEMP_DIR in wp-config.php")
+ );
+ }
+
/**
* Get headers for GitHub API requests
*
diff --git a/src/UpdaterConfig.php b/src/UpdaterConfig.php
index 11d617a..bb85086 100644
--- a/src/UpdaterConfig.php
+++ b/src/UpdaterConfig.php
@@ -7,7 +7,7 @@
*
* @package SilverAssist\WpGithubUpdater
* @author Silver Assist
- * @version 1.1.1
+ * @version 1.2.1
* @license PolyForm-Noncommercial-1.0.0
*/
@@ -130,6 +130,14 @@ class UpdaterConfig
*/
public string $textDomain;
+ /**
+ * Custom temporary directory path
+ *
+ * @var string|null Custom path for temporary files during downloads, null for auto-detection
+ * @since 1.1.3
+ */
+ public ?string $customTempDir;
+
/**
* Create updater configuration
*
@@ -156,12 +164,13 @@ class UpdaterConfig
$this->pluginAuthor = $options["plugin_author"] ?? $pluginData["Author"] ?? "";
$this->pluginHomepage = $options["plugin_homepage"] ?? "https://github.com/{$githubRepo}";
$this->requiresWordPress = $options["requires_wordpress"] ?? "6.0";
- $this->requiresPHP = $options["requires_php"] ?? "8.0";
+ $this->requiresPHP = $options["requires_php"] ?? "8.2";
$this->assetPattern = $options["asset_pattern"] ?? "{slug}-v{version}.zip";
$this->cacheDuration = $options["cache_duration"] ?? (12 * 3600); // 12 hours
$this->ajaxAction = $options["ajax_action"] ?? "check_plugin_version";
$this->ajaxNonce = $options["ajax_nonce"] ?? "plugin_version_check";
$this->textDomain = $options["text_domain"] ?? "wp-github-updater";
+ $this->customTempDir = $options["custom_temp_dir"] ?? null;
}
/**
@@ -177,7 +186,7 @@ class UpdaterConfig
*/
private function getPluginData(string $pluginFile): array
{
- if (\function_exists("get_plugin_data")) {
+ if (function_exists("get_plugin_data")) {
return \get_plugin_data($pluginFile);
}
diff --git a/tests/Integration/DownloadFilterTest.php b/tests/Integration/DownloadFilterTest.php
new file mode 100644
index 0000000..78c3362
--- /dev/null
+++ b/tests/Integration/DownloadFilterTest.php
@@ -0,0 +1,147 @@
+testPluginFile = sys_get_temp_dir() . "/test-plugin.php";
+ file_put_contents($this->testPluginFile, "config = new UpdaterConfig($this->testPluginFile, "SilverAssist/test-repo");
+ $this->updater = new Updater($this->config);
+ }
+
+ /**
+ * Clean up after each test
+ */
+ protected function tearDown(): void
+ {
+ if (file_exists($this->testPluginFile)) {
+ unlink($this->testPluginFile);
+ }
+
+ parent::tearDown();
+ }
+
+ /**
+ * Test that temporary directory configuration is respected
+ */
+ public function testCustomTempDirectoryIsRespected(): void
+ {
+ $customTempDir = sys_get_temp_dir() . "/wp-github-updater-custom";
+
+ $config = new UpdaterConfig($this->testPluginFile, "SilverAssist/test-repo", [
+ "custom_temp_dir" => $customTempDir,
+ ]);
+
+ $this->assertEquals($customTempDir, $config->customTempDir);
+ }
+
+ /**
+ * Test that package URL validation works correctly
+ */
+ public function testPackageUrlValidation(): void
+ {
+ // Valid GitHub URL
+ $validUrl = "https://github.com/SilverAssist/test-repo/releases/download/v1.0.0/package.zip";
+ $this->assertStringContainsString("github.com", $validUrl);
+ $this->assertStringContainsString("SilverAssist/test-repo", $validUrl);
+
+ // Invalid URL (not GitHub)
+ $invalidUrl = "https://example.com/package.zip";
+ $this->assertStringNotContainsString("github.com", $invalidUrl);
+ }
+
+ /**
+ * Test file size validation logic
+ */
+ public function testFileSizeValidation(): void
+ {
+ $minSize = 100; // Minimum size for valid ZIP
+
+ // Valid size
+ $this->assertGreaterThanOrEqual($minSize, 1024);
+
+ // Invalid size
+ $this->assertLessThan($minSize, 50);
+ }
+
+ /**
+ * Test that hook_extra validation logic works
+ */
+ public function testHookExtraValidation(): void
+ {
+ $pluginSlug = basename(dirname($this->testPluginFile)) . "/" . basename($this->testPluginFile);
+
+ // Test single plugin update
+ $hook_extra_single = [
+ "plugin" => $pluginSlug,
+ ];
+ $this->assertArrayHasKey("plugin", $hook_extra_single);
+ $this->assertEquals($pluginSlug, $hook_extra_single["plugin"]);
+
+ // Test bulk plugin update
+ $hook_extra_bulk = [
+ "plugins" => [$pluginSlug, "other-plugin/other-plugin.php"],
+ ];
+ $this->assertArrayHasKey("plugins", $hook_extra_bulk);
+ $this->assertContains($pluginSlug, $hook_extra_bulk["plugins"]);
+ }
+
+ /**
+ * Test version comparison logic
+ */
+ public function testVersionComparison(): void
+ {
+ // Current version is older than latest
+ $this->assertTrue(version_compare("1.0.0", "1.1.0", "<"));
+ $this->assertFalse(version_compare("1.1.0", "1.0.0", "<"));
+
+ // Same version
+ $this->assertFalse(version_compare("1.0.0", "1.0.0", "<"));
+ $this->assertTrue(version_compare("1.0.0", "1.0.0", "="));
+ }
+
+ /**
+ * Test GitHub repository format validation
+ */
+ public function testGitHubRepoFormat(): void
+ {
+ // Valid formats
+ $this->assertMatchesRegularExpression("/^[a-zA-Z0-9-]+\/[a-zA-Z0-9-_]+$/", "SilverAssist/test-repo");
+ $this->assertMatchesRegularExpression("/^[a-zA-Z0-9-]+\/[a-zA-Z0-9-_]+$/", "owner/repo");
+
+ // Invalid formats
+ $this->assertDoesNotMatchRegularExpression("/^[a-zA-Z0-9-]+\/[a-zA-Z0-9-_]+$/", "invalid");
+ $this->assertDoesNotMatchRegularExpression("/^[a-zA-Z0-9-]+\/[a-zA-Z0-9-_]+$/", "/owner/repo");
+ }
+}
diff --git a/tests/Integration/RealGitHubAPITest.php b/tests/Integration/RealGitHubAPITest.php
new file mode 100644
index 0000000..9b5ac5a
--- /dev/null
+++ b/tests/Integration/RealGitHubAPITest.php
@@ -0,0 +1,423 @@
+getLatestVersion();
+
+ // Should return the latest version or false
+ $this->assertTrue(
+ $latestVersion === false || is_string($latestVersion),
+ "getLatestVersion() should return string or false"
+ );
+
+ // If successful, should be a valid version string
+ if ($latestVersion !== false) {
+ $this->assertMatchesRegularExpression(
+ "/^\d+\.\d+\.\d+$/",
+ $latestVersion,
+ "Version should be in format X.Y.Z"
+ );
+
+ // Latest version should be at least v1.3.0 (current latest)
+ $this->assertGreaterThanOrEqual(
+ "1.3.0",
+ $latestVersion,
+ "Latest version should be at least v1.3.0"
+ );
+ }
+ }
+
+ /**
+ * Test fetching release information from real GitHub repository
+ *
+ * @return void
+ */
+ public function testFetchReleaseInformationFromRealRepo(): void
+ {
+ $config = new UpdaterConfig(
+ self::$testPluginFile,
+ "SilverAssist/silver-assist-post-revalidate"
+ );
+
+ $updater = new Updater($config);
+
+ // Get latest version (makes real HTTP request)
+ $version = $updater->getLatestVersion();
+
+ // Should return string version or false
+ $this->assertTrue(
+ $version === false || is_string($version),
+ "getLatestVersion() should return string or false"
+ );
+
+ // If successful, should have valid version
+ if ($version !== false) {
+ // Verify it's a valid semantic version
+ $this->assertMatchesRegularExpression(
+ "/^\d+\.\d+\.\d+$/",
+ $version,
+ "Version should be in X.Y.Z format"
+ );
+
+ // Check if update is available
+ $config2 = new UpdaterConfig(
+ self::$testPluginFile,
+ "SilverAssist/silver-assist-post-revalidate",
+ [
+ "plugin_version" => "0.0.1", // Old version
+ ]
+ );
+
+ $updater2 = new Updater($config2);
+ $hasUpdate = $updater2->isUpdateAvailable();
+
+ $this->assertTrue(
+ $hasUpdate,
+ "Should detect update available when current version is 0.0.1"
+ );
+ }
+ }
+
+ /**
+ * Test GitHub API response structure
+ *
+ * @return void
+ */
+ public function testGitHubAPIResponseStructure(): void
+ {
+ $config = new UpdaterConfig(
+ self::$testPluginFile,
+ "SilverAssist/silver-assist-post-revalidate"
+ );
+
+ $updater = new Updater($config);
+
+ // Get version to trigger API call
+ $version = $updater->getLatestVersion();
+
+ // Skip if API request failed
+ if ($version === false) {
+ $this->markTestSkipped("GitHub API request failed or rate limited");
+ }
+
+ // Verify version is valid format
+ $this->assertMatchesRegularExpression(
+ "/^\d+\.\d+\.\d+$/",
+ $version,
+ "Version should be in X.Y.Z format"
+ );
+
+ // Version should be at least 1.0.0 (first release)
+ $this->assertGreaterThanOrEqual(
+ "1.0.0",
+ $version,
+ "Version should be at least 1.0.0"
+ );
+ }
+
+ /**
+ * Test update check with real GitHub repository
+ *
+ * @return void
+ */
+ public function testUpdateCheckWithRealRepo(): void
+ {
+ $config = new UpdaterConfig(
+ self::$testPluginFile,
+ "SilverAssist/silver-assist-post-revalidate",
+ [
+ "plugin_name" => "Silver Assist Post Revalidate",
+ "plugin_version" => "0.0.1", // Old version to trigger update
+ ]
+ );
+
+ $updater = new Updater($config);
+
+ // This makes a real HTTP request to GitHub
+ $hasUpdate = $updater->isUpdateAvailable();
+
+ // Should return boolean
+ $this->assertIsBool($hasUpdate);
+
+ // With version 0.0.1, there should be an update available
+ // (unless API request failed)
+ if ($hasUpdate) {
+ $this->assertTrue(
+ $hasUpdate,
+ "Update should be available for version 0.0.1"
+ );
+
+ // Get latest version to verify
+ $latestVersion = $updater->getLatestVersion();
+ $this->assertNotFalse($latestVersion);
+ $this->assertGreaterThan("0.0.1", $latestVersion);
+ }
+ }
+
+ /**
+ * Test caching of GitHub API responses
+ *
+ * @return void
+ */
+ public function testGitHubAPIResponseCaching(): void
+ {
+ $config = new UpdaterConfig(
+ self::$testPluginFile,
+ "SilverAssist/silver-assist-post-revalidate",
+ [
+ "cache_duration" => 3600, // 1 hour
+ ]
+ );
+
+ $updater = new Updater($config);
+
+ // First call - should make HTTP request
+ $version1 = $updater->getLatestVersion();
+
+ // Skip if API request failed
+ if ($version1 === false) {
+ $this->markTestSkipped("GitHub API request failed or rate limited");
+ }
+
+ // Second call - should use cache (much faster)
+ $startTime = microtime(true);
+ $version2 = $updater->getLatestVersion();
+ $elapsed = microtime(true) - $startTime;
+
+ // Both should return same version
+ $this->assertEquals($version1, $version2);
+
+ // Second call should be very fast (cached)
+ $this->assertLessThan(
+ 0.01, // Less than 10ms
+ $elapsed,
+ "Cached call should be very fast"
+ );
+ }
+
+ /**
+ * Test GitHub API rate limiting handling
+ *
+ * @return void
+ */
+ public function testGitHubAPIRateLimitHandling(): void
+ {
+ $config = new UpdaterConfig(
+ self::$testPluginFile,
+ "SilverAssist/silver-assist-post-revalidate",
+ [
+ "cache_duration" => 1, // 1 second cache
+ ]
+ );
+
+ $updater = new Updater($config);
+
+ // Make multiple requests (cached after first)
+ $results = [];
+ for ($i = 0; $i < 3; $i++) {
+ $version = $updater->getLatestVersion();
+ $results[] = $version;
+ }
+
+ // At least one request should succeed (or all should fail gracefully)
+ $hasSuccess = false;
+ foreach ($results as $result) {
+ if ($result !== false) {
+ $hasSuccess = true;
+ break;
+ }
+ }
+
+ // All results should be the same (cached)
+ $uniqueResults = array_unique($results);
+ $this->assertCount(
+ 1,
+ $uniqueResults,
+ "All requests should return same result (cached)"
+ );
+
+ $this->assertTrue(
+ $hasSuccess || count(array_filter($results)) === 0,
+ "Should either succeed or fail gracefully for all requests"
+ );
+ }
+
+ /**
+ * Test asset pattern matching with real releases
+ *
+ * @return void
+ */
+ public function testAssetPatternMatchingWithRealReleases(): void
+ {
+ $config = new UpdaterConfig(
+ self::$testPluginFile,
+ "SilverAssist/silver-assist-post-revalidate",
+ [
+ // Custom asset pattern to match the plugin's naming convention
+ "asset_pattern" => "silver-assist-post-revalidate-v{version}.zip",
+ ]
+ );
+
+ $updater = new Updater($config);
+
+ // Get latest version
+ $version = $updater->getLatestVersion();
+
+ // Skip if API request failed
+ if ($version === false) {
+ $this->markTestSkipped("GitHub API request failed or rate limited");
+ }
+
+ // Verify version format
+ $this->assertMatchesRegularExpression(
+ "/^\d+\.\d+\.\d+$/",
+ $version,
+ "Version should be in X.Y.Z format"
+ );
+
+ // Verify the asset pattern is configured correctly
+ $this->assertEquals(
+ "silver-assist-post-revalidate-v{version}.zip",
+ $config->assetPattern,
+ "Asset pattern should be configured"
+ );
+ }
+
+ /**
+ * Test version comparison with current and latest versions
+ *
+ * @return void
+ */
+ public function testVersionComparisonWithRealVersions(): void
+ {
+ // Test with old version (should have update)
+ $config1 = new UpdaterConfig(
+ self::$testPluginFile,
+ "SilverAssist/silver-assist-post-revalidate",
+ [
+ "plugin_version" => "1.0.0",
+ ]
+ );
+
+ $updater1 = new Updater($config1);
+ $latestVersion = $updater1->getLatestVersion();
+
+ // Skip if API failed
+ if ($latestVersion === false) {
+ $this->markTestSkipped("GitHub API request failed");
+ }
+
+ // 1.0.0 should be older than latest
+ $hasUpdate = $updater1->isUpdateAvailable();
+ $this->assertTrue(
+ $hasUpdate,
+ "Version 1.0.0 should have update available (latest: {$latestVersion})"
+ );
+
+ // Verify version comparison works correctly
+ $this->assertGreaterThan(
+ "1.0.0",
+ $latestVersion,
+ "Latest version should be greater than 1.0.0"
+ );
+ }
+
+ /**
+ * Test GitHub repository information retrieval
+ *
+ * @return void
+ */
+ public function testGitHubRepositoryInformation(): void
+ {
+ $config = new UpdaterConfig(
+ self::$testPluginFile,
+ "SilverAssist/silver-assist-post-revalidate"
+ );
+
+ $updater = new Updater($config);
+
+ // Get version (triggers API call)
+ $version = $updater->getLatestVersion();
+
+ // Skip if failed
+ if ($version === false) {
+ $this->markTestSkipped("GitHub API request failed");
+ }
+
+ // Verify repository info is correct
+ $this->assertEquals(
+ "SilverAssist/silver-assist-post-revalidate",
+ $config->githubRepo,
+ "Repository should be configured correctly"
+ );
+
+ // Verify version is reasonable (>= 1.0.0 and < 100.0.0)
+ $this->assertGreaterThanOrEqual(
+ "1.0.0",
+ $version,
+ "Version should be at least 1.0.0"
+ );
+
+ $this->assertLessThan(
+ "100.0.0",
+ $version,
+ "Version should be less than 100.0.0"
+ );
+ }
+}
diff --git a/tests/Integration/UpdaterIntegrationTest.php b/tests/Integration/UpdaterIntegrationTest.php
new file mode 100644
index 0000000..4858f8c
--- /dev/null
+++ b/tests/Integration/UpdaterIntegrationTest.php
@@ -0,0 +1,142 @@
+testPluginFile = sys_get_temp_dir() . "/test-plugin.php";
+ file_put_contents($this->testPluginFile, "config = new UpdaterConfig($this->testPluginFile, "SilverAssist/test-repo", [
+ "plugin_name" => "Test Plugin",
+ "plugin_description" => "Test plugin description",
+ "cache_duration" => 60, // Short cache for testing
+ ]);
+ }
+
+ /**
+ * Clean up after each test
+ */
+ protected function tearDown(): void
+ {
+ if (file_exists($this->testPluginFile)) {
+ unlink($this->testPluginFile);
+ }
+
+ parent::tearDown();
+ }
+
+ /**
+ * Test that Updater can be instantiated with valid configuration
+ */
+ public function testUpdaterInstantiation(): void
+ {
+ $updater = new Updater($this->config);
+
+ $this->assertInstanceOf(Updater::class, $updater);
+ $this->assertEquals("1.0.0", $updater->getCurrentVersion());
+ $this->assertEquals("SilverAssist/test-repo", $updater->getGithubRepo());
+ }
+
+ /**
+ * Test configuration validation
+ */
+ public function testConfigurationValidation(): void
+ {
+ $this->assertEquals("Test Plugin", $this->config->pluginName);
+ $this->assertEquals("Test plugin description", $this->config->pluginDescription);
+ $this->assertEquals("SilverAssist/test-repo", $this->config->githubRepo);
+ $this->assertEquals(60, $this->config->cacheDuration);
+ }
+
+ /**
+ * Test custom temporary directory configuration
+ */
+ public function testCustomTempDirConfiguration(): void
+ {
+ $customTempDir = sys_get_temp_dir() . "/wp-github-updater-test";
+
+ $config = new UpdaterConfig($this->testPluginFile, "SilverAssist/test-repo", [
+ "custom_temp_dir" => $customTempDir,
+ ]);
+
+ $this->assertEquals($customTempDir, $config->customTempDir);
+ }
+
+ /**
+ * Test text domain configuration
+ */
+ public function testTextDomainConfiguration(): void
+ {
+ $config = new UpdaterConfig($this->testPluginFile, "SilverAssist/test-repo", [
+ "text_domain" => "custom-domain",
+ ]);
+
+ $this->assertEquals("custom-domain", $config->textDomain);
+ }
+
+ /**
+ * Test AJAX configuration
+ */
+ public function testAjaxConfiguration(): void
+ {
+ $this->assertNotEmpty($this->config->ajaxAction);
+ $this->assertNotEmpty($this->config->ajaxNonce);
+ $this->assertEquals("check_plugin_version", $this->config->ajaxAction);
+ $this->assertEquals("plugin_version_check", $this->config->ajaxNonce);
+ }
+
+ /**
+ * Test asset pattern configuration
+ */
+ public function testAssetPatternConfiguration(): void
+ {
+ $config = new UpdaterConfig($this->testPluginFile, "SilverAssist/test-repo", [
+ "asset_pattern" => "custom-{slug}-{version}.zip",
+ ]);
+
+ $this->assertEquals("custom-{slug}-{version}.zip", $config->assetPattern);
+ }
+
+ /**
+ * Test WordPress requirements configuration
+ */
+ public function testWordPressRequirementsConfiguration(): void
+ {
+ $config = new UpdaterConfig($this->testPluginFile, "SilverAssist/test-repo", [
+ "requires_wordpress" => "6.2",
+ "requires_php" => "8.1",
+ ]);
+
+ $this->assertEquals("6.2", $config->requiresWordPress);
+ $this->assertEquals("8.1", $config->requiresPHP);
+ }
+}
diff --git a/tests/UpdaterConfigTest.php b/tests/Unit/UpdaterConfigTest.php
similarity index 79%
rename from tests/UpdaterConfigTest.php
rename to tests/Unit/UpdaterConfigTest.php
index a20451d..33da8a8 100644
--- a/tests/UpdaterConfigTest.php
+++ b/tests/Unit/UpdaterConfigTest.php
@@ -1,20 +1,27 @@
assertEquals("/path/to/plugin.php", $config->pluginFile);
+ $this->assertEquals(self::$testPluginFile, $config->pluginFile);
$this->assertEquals("owner/repo", $config->githubRepo);
$this->assertEquals("6.0", $config->requiresWordPress);
- $this->assertEquals("8.0", $config->requiresPHP);
+ $this->assertEquals("8.2", $config->requiresPHP);
$this->assertEquals("{slug}-v{version}.zip", $config->assetPattern);
$this->assertEquals("wp-github-updater", $config->textDomain);
}
@@ -34,7 +41,7 @@ class UpdaterConfigTest extends TestCase
"text_domain" => "my-custom-plugin"
];
- $config = new UpdaterConfig("/path/to/plugin.php", "owner/repo", $options);
+ $config = new UpdaterConfig(self::$testPluginFile, "owner/repo", $options);
$this->assertEquals("Test Plugin", $config->pluginName);
$this->assertEquals("A test plugin", $config->pluginDescription);
@@ -50,7 +57,7 @@ class UpdaterConfigTest extends TestCase
public function testTranslationMethods(): void
{
- $config = new UpdaterConfig("/path/to/plugin.php", "owner/repo", [
+ $config = new UpdaterConfig(self::$testPluginFile, "owner/repo", [
"text_domain" => "test-domain"
]);
diff --git a/tests/WordPress/MockPluginTest.php b/tests/WordPress/MockPluginTest.php
new file mode 100644
index 0000000..90f5dc0
--- /dev/null
+++ b/tests/WordPress/MockPluginTest.php
@@ -0,0 +1,258 @@
+pluginFile = dirname(__DIR__) . "/fixtures/mock-plugin/mock-plugin.php";
+
+ // Load the mock plugin
+ if (file_exists($this->pluginFile)) {
+ require_once $this->pluginFile;
+
+ // Initialize the updater
+ do_action("plugins_loaded");
+
+ // Get updater instance
+ $this->updater = mock_plugin_get_updater();
+ }
+ }
+
+ /**
+ * Test that mock plugin file exists
+ */
+ public function testMockPluginFileExists(): void
+ {
+ $this->assertFileExists($this->pluginFile, "Mock plugin file should exist");
+ }
+
+ /**
+ * Test that mock plugin can be loaded
+ */
+ public function testMockPluginCanBeLoaded(): void
+ {
+ $this->assertTrue(
+ function_exists("mock_plugin_init_updater"),
+ "Mock plugin functions should be available"
+ );
+ $this->assertTrue(
+ function_exists("mock_plugin_get_updater"),
+ "Mock plugin helper functions should be available"
+ );
+ }
+
+ /**
+ * Test that updater is initialized
+ */
+ public function testUpdaterIsInitialized(): void
+ {
+ $this->assertNotNull($this->updater, "Updater should be initialized");
+ $this->assertInstanceOf(Updater::class, $this->updater, "Should be Updater instance");
+ }
+
+ /**
+ * Test updater configuration
+ */
+ public function testUpdaterConfiguration(): void
+ {
+ if (!$this->updater) {
+ $this->markTestSkipped("Updater not initialized");
+ }
+
+ $this->assertEquals("SilverAssist/mock-test-repo", $this->updater->getGithubRepo());
+ $this->assertEquals("1.0.0", $this->updater->getCurrentVersion());
+ }
+
+ /**
+ * Test WordPress hooks are registered
+ */
+ public function testWordPressHooksAreRegistered(): void
+ {
+ // Check that update check filter is registered
+ $this->assertNotFalse(
+ has_filter("pre_set_site_transient_update_plugins"),
+ "Update check filter should be registered"
+ );
+
+ // Check that plugin info filter is registered
+ $this->assertNotFalse(
+ has_filter("plugins_api"),
+ "Plugin info filter should be registered"
+ );
+ }
+
+ /**
+ * Test AJAX actions are registered
+ */
+ public function testAjaxActionsAreRegistered(): void
+ {
+ // Check that AJAX actions are registered (only for logged-in users)
+ $this->assertNotFalse(
+ has_action("wp_ajax_mock_plugin_check_version"),
+ "AJAX check version action should be registered"
+ );
+
+ // Check that dismiss notice action is registered
+ $this->assertNotFalse(
+ has_action("wp_ajax_mock_plugin_check_version_dismiss_notice"),
+ "AJAX dismiss notice action should be registered"
+ );
+ }
+
+ /**
+ * Test plugin activation
+ */
+ public function testPluginActivation(): void
+ {
+ // Set a transient to test cleanup
+ set_transient("mock-plugin_version_check", "test_data", 3600);
+ $this->assertNotFalse(get_transient("mock-plugin_version_check"));
+
+ // Trigger activation
+ do_action("activate_" . plugin_basename($this->pluginFile));
+
+ // In real implementation, transient should be cleared
+ // For now, just verify activation doesn't cause errors
+ $this->assertTrue(true);
+ }
+
+ /**
+ * Test plugin deactivation
+ */
+ public function testPluginDeactivation(): void
+ {
+ // Set a transient
+ set_transient("mock-plugin_version_check", "test_data", 3600);
+
+ // Trigger deactivation
+ do_action("deactivate_" . plugin_basename($this->pluginFile));
+
+ // Verify cleanup happens (implementation-specific)
+ $this->assertTrue(true);
+ }
+
+ /**
+ * Test admin menu is registered
+ */
+ public function testAdminMenuIsRegistered(): void
+ {
+ // Set current user as administrator
+ $user_id = $this->factory->user->create(["role" => "administrator"]);
+ wp_set_current_user($user_id);
+
+ // Trigger admin menu hook
+ do_action("admin_menu");
+
+ // Check that menu was added
+ global $menu;
+ $this->assertIsArray($menu);
+ }
+
+ /**
+ * Test update check with transient caching
+ */
+ public function testUpdateCheckWithCaching(): void
+ {
+ if (!$this->updater) {
+ $this->markTestSkipped("Updater not initialized");
+ }
+
+ // Clear any existing cache
+ delete_transient("mock-plugin_version_check");
+
+ // First check should query API (we can't test actual API in unit tests)
+ $updateAvailable = $this->updater->isUpdateAvailable();
+ $this->assertIsBool($updateAvailable);
+
+ // Second check should use cache (if API was successful)
+ $updateAvailable2 = $this->updater->isUpdateAvailable();
+ $this->assertIsBool($updateAvailable2);
+ }
+
+ /**
+ * Test plugin data retrieval
+ */
+ public function testPluginDataRetrieval(): void
+ {
+ $pluginData = \get_plugin_data($this->pluginFile, false, false); // Don't markup, don't translate
+
+ $this->assertIsArray($pluginData);
+ $this->assertEquals("Mock Plugin for WP GitHub Updater Tests", $pluginData["Name"]);
+ $this->assertEquals("1.0.0", $pluginData["Version"]);
+ $this->assertEquals("SilverAssist", $pluginData["Author"]);
+ $this->assertEquals("6.0", $pluginData["RequiresWP"]);
+ $this->assertEquals("8.2", $pluginData["RequiresPHP"]);
+ }
+
+ /**
+ * Test plugin basename generation
+ */
+ public function testPluginBasename(): void
+ {
+ $basename = plugin_basename($this->pluginFile);
+
+ $this->assertIsString($basename);
+ $this->assertStringContainsString("mock-plugin.php", $basename);
+ }
+
+ /**
+ * Test custom temporary directory configuration
+ */
+ public function testCustomTempDirectoryConfiguration(): void
+ {
+ // This tests the v1.1.3+ feature for custom temp directories
+ $expectedTempDir = WP_CONTENT_DIR . "/uploads/temp";
+
+ // The mock plugin configures a custom temp dir
+ // We verify this through the configuration
+ $this->assertDirectoryExists(WP_CONTENT_DIR . "/uploads");
+ }
+
+ /**
+ * Clean up after tests
+ */
+ public function tearDown(): void
+ {
+ // Clean up transients
+ delete_transient("mock-plugin_version_check");
+
+ parent::tearDown();
+ }
+}
diff --git a/tests/WordPress/WordPressHooksTest.php b/tests/WordPress/WordPressHooksTest.php
new file mode 100644
index 0000000..51c0658
--- /dev/null
+++ b/tests/WordPress/WordPressHooksTest.php
@@ -0,0 +1,213 @@
+testPluginFile = sys_get_temp_dir() . "/test-plugin.php";
+ file_put_contents(
+ $this->testPluginFile,
+ "config = new UpdaterConfig($this->testPluginFile, "SilverAssist/test-repo", [
+ "plugin_name" => "Test Plugin",
+ "plugin_description" => "Test plugin description",
+ ]);
+ }
+
+ /**
+ * Clean up after each test
+ */
+ protected function tearDown(): void
+ {
+ if (file_exists($this->testPluginFile)) {
+ unlink($this->testPluginFile);
+ }
+
+ parent::tearDown();
+ }
+
+ /**
+ * Test configuration object creation
+ */
+ public function testConfigurationCreation(): void
+ {
+ $this->assertInstanceOf(UpdaterConfig::class, $this->config);
+ $this->assertEquals("SilverAssist/test-repo", $this->config->githubRepo);
+ $this->assertEquals($this->testPluginFile, $this->config->pluginFile);
+ }
+
+ /**
+ * Test plugin homepage configuration
+ */
+ public function testPluginHomepage(): void
+ {
+ $expectedHomepage = "https://github.com/SilverAssist/test-repo";
+ $this->assertEquals($expectedHomepage, $this->config->pluginHomepage);
+ }
+
+ /**
+ * Test plugin author configuration
+ */
+ public function testPluginAuthor(): void
+ {
+ // When plugin file doesn't exist or can't be read, author will be empty string
+ // unless explicitly provided in options
+ $this->assertIsString($this->config->pluginAuthor);
+
+ // Test with explicit author option
+ $configWithAuthor = new UpdaterConfig($this->testPluginFile, "SilverAssist/test-repo", [
+ "plugin_author" => "SilverAssist",
+ ]);
+ $this->assertEquals("SilverAssist", $configWithAuthor->pluginAuthor);
+ }
+
+ /**
+ * Test cache duration configuration
+ */
+ public function testCacheDuration(): void
+ {
+ $this->assertEquals(43200, $this->config->cacheDuration); // Default 12 hours
+
+ $customConfig = new UpdaterConfig($this->testPluginFile, "SilverAssist/test-repo", [
+ "cache_duration" => 3600,
+ ]);
+ $this->assertEquals(3600, $customConfig->cacheDuration);
+ }
+
+ /**
+ * Test transient naming convention
+ */
+ public function testTransientNaming(): void
+ {
+ $pluginBasename = basename(dirname($this->testPluginFile));
+ $expectedTransient = "{$pluginBasename}_version_check";
+
+ // The transient name should follow WordPress conventions (lowercase, numbers, underscores, dashes)
+ // Note: basename() may return uppercase letters, which is acceptable in WordPress transients
+ $this->assertMatchesRegularExpression("/^[a-zA-Z0-9_-]+$/", $expectedTransient);
+ }
+
+ /**
+ * Test AJAX action naming convention
+ */
+ public function testAjaxActionNaming(): void
+ {
+ $ajaxAction = $this->config->ajaxAction;
+
+ // AJAX action should follow WordPress conventions (lowercase, numbers, underscores)
+ $this->assertNotEmpty($ajaxAction);
+ $this->assertMatchesRegularExpression("/^[a-z0-9_-]+$/", $ajaxAction);
+ $this->assertEquals("check_plugin_version", $ajaxAction);
+ }
+
+ /**
+ * Test nonce naming convention
+ */
+ public function testNonceNaming(): void
+ {
+ $nonce = $this->config->ajaxNonce;
+
+ // Nonce should follow WordPress conventions (lowercase, numbers, underscores)
+ $this->assertNotEmpty($nonce);
+ $this->assertMatchesRegularExpression("/^[a-z0-9_-]+$/", $nonce);
+ $this->assertEquals("plugin_version_check", $nonce);
+ }
+
+ /**
+ * Test plugin data structure
+ */
+ public function testPluginDataStructure(): void
+ {
+ $this->assertIsString($this->config->pluginName);
+ $this->assertIsString($this->config->pluginDescription);
+ $this->assertIsString($this->config->pluginAuthor);
+ $this->assertIsString($this->config->pluginHomepage);
+ }
+
+ /**
+ * Test WordPress version requirements
+ */
+ public function testWordPressVersionRequirements(): void
+ {
+ $this->assertIsString($this->config->requiresWordPress);
+ $this->assertMatchesRegularExpression("/^\d+\.\d+$/", $this->config->requiresWordPress);
+ $this->assertGreaterThanOrEqual(6.0, (float) $this->config->requiresWordPress);
+ }
+
+ /**
+ * Test PHP version requirements
+ */
+ public function testPHPVersionRequirements(): void
+ {
+ $this->assertIsString($this->config->requiresPHP);
+ $this->assertMatchesRegularExpression("/^\d+\.\d+$/", $this->config->requiresPHP);
+ $this->assertGreaterThanOrEqual(8.2, (float) $this->config->requiresPHP);
+ }
+
+ /**
+ * Test asset pattern replacement tokens
+ */
+ public function testAssetPatternTokens(): void
+ {
+ $pattern = $this->config->assetPattern;
+
+ // Pattern should contain replacement tokens
+ $this->assertStringContainsString("{slug}", $pattern);
+ $this->assertStringContainsString("{version}", $pattern);
+ $this->assertStringEndsWith(".zip", $pattern);
+ }
+
+ /**
+ * Test translation function wrapper
+ */
+ public function testTranslationFunctionWrapper(): void
+ {
+ $testString = "Test string";
+ $translated = $this->config->__($testString);
+
+ // In test environment, should return the original string
+ $this->assertEquals($testString, $translated);
+ }
+
+ /**
+ * Test GitHub API URL construction
+ */
+ public function testGitHubApiUrlConstruction(): void
+ {
+ $repo = $this->config->githubRepo;
+ $expectedBaseUrl = "https://api.github.com/repos/{$repo}";
+
+ $this->assertStringContainsString("SilverAssist", $expectedBaseUrl);
+ $this->assertStringContainsString("test-repo", $expectedBaseUrl);
+ }
+}
diff --git a/tests/bootstrap.php b/tests/bootstrap.php
index e6334bb..074bf99 100644
--- a/tests/bootstrap.php
+++ b/tests/bootstrap.php
@@ -1,28 +1,117 @@
"Mock Plugin for Testing",
+ "cache_duration" => 300, // 5 minutos para testing
+ "text_domain" => "mock-plugin",
+ "custom_temp_dir" => WP_CONTENT_DIR . "/uploads/temp",
+ // ... mΓ‘s opciones
+ ]
+);
+
+$updater = new Updater($config);
+```
+
+### β
Panel de AdministraciΓ³n
+
+- PΓ‘gina de admin con informaciΓ³n del plugin
+- BotΓ³n para check manual de actualizaciones
+- Display de versiΓ³n actual y disponible
+- IntegraciΓ³n AJAX para checks en tiempo real
+
+### β
Hooks de WordPress
+
+- `plugins_loaded`: InicializaciΓ³n del updater
+- `admin_menu`: MenΓΊ de administraciΓ³n
+- `activate_*`: Limpieza de cache en activaciΓ³n
+- `deactivate_*`: Limpieza de cache en desactivaciΓ³n
+
+### β
AJAX Handlers
+
+- `mock_plugin_check_version`: Check manual de versiΓ³n
+- VerificaciΓ³n de nonces y capabilities
+- Respuestas JSON formateadas
+
+## π§ͺ Uso en Tests
+
+### Cargar el Mock Plugin
+
+El mock plugin se carga automΓ‘ticamente en el bootstrap de WordPress Test Suite:
+
+```php
+// En tests/bootstrap.php
+function _manually_load_plugin() {
+ require_once __DIR__ . "/fixtures/mock-plugin/mock-plugin.php";
+}
+tests_add_filter("muplugins_loaded", "_manually_load_plugin");
+```
+
+### Acceder al Updater en Tests
+
+```php
+class MyTest extends WP_UnitTestCase {
+ public function testUpdater() {
+ // Obtener instancia del updater
+ $updater = mock_plugin_get_updater();
+
+ // Verificar funcionalidad
+ $this->assertInstanceOf(Updater::class, $updater);
+ $this->assertEquals("1.0.0", $updater->getCurrentVersion());
+ }
+}
+```
+
+### Ejemplo de Test Completo
+
+Ver `tests/WordPress/MockPluginTest.php` para ejemplos completos de:
+
+- β
Test de inicializaciΓ³n
+- β
Test de hooks registrados
+- β
Test de AJAX actions
+- β
Test de activaciΓ³n/desactivaciΓ³n
+- β
Test de menu de admin
+- β
Test de caching con transients
+
+## π Tests Incluidos
+
+El mock plugin tiene su propia suite de tests en `tests/WordPress/MockPluginTest.php`:
+
+| Test | DescripciΓ³n |
+|------|-------------|
+| `testMockPluginFileExists` | Verifica que el archivo existe |
+| `testMockPluginCanBeLoaded` | Verifica que se puede cargar |
+| `testUpdaterIsInitialized` | Verifica inicializaciΓ³n del updater |
+| `testUpdaterConfiguration` | Verifica configuraciΓ³n correcta |
+| `testWordPressHooksAreRegistered` | Verifica hooks de WordPress |
+| `testAjaxActionsAreRegistered` | Verifica AJAX actions |
+| `testPluginActivation` | Verifica activaciΓ³n del plugin |
+| `testPluginDeactivation` | Verifica desactivaciΓ³n del plugin |
+| `testAdminMenuIsRegistered` | Verifica menΓΊ de admin |
+| `testUpdateCheckWithCaching` | Verifica caching con transients |
+| `testPluginDataRetrieval` | Verifica lectura de metadata |
+| `testPluginBasename` | Verifica plugin_basename() |
+| `testCustomTempDirectoryConfiguration` | Verifica directorio temporal (v1.1.3+) |
+
+## π Ejecutar Tests con WordPress Test Suite
+
+### 1. Instalar WordPress Test Suite
+
+```bash
+./scripts/install-wp-tests.sh wordpress_test root '' localhost 6.7.1
+```
+
+### 2. Ejecutar Tests de WordPress
+
+```bash
+# Todos los tests de WordPress (incluye mock plugin)
+./vendor/bin/phpunit --testsuite=wordpress
+
+# Solo tests del mock plugin
+./vendor/bin/phpunit tests/WordPress/MockPluginTest.php
+
+# Todos los tests (incluye modo WordPress si estΓ‘ instalado)
+./vendor/bin/phpunit
+```
+
+### 3. Verificar Salida
+
+Cuando WordPress Test Suite estΓ‘ disponible, verΓ‘s:
+
+```
+====================================
+WP GitHub Updater Test Suite
+====================================
+Mode: WordPress Integration Tests
+WP Tests Dir: /tmp/wordpress-tests-lib
+====================================
+β Mock plugin loaded: /path/to/tests/fixtures/mock-plugin/mock-plugin.php
+```
+
+## π Funcionalidades para Testing
+
+### Metadata del Plugin
+
+```php
+$pluginData = get_plugin_data($pluginFile);
+
+// Retorna:
+[
+ "Name" => "Mock Plugin for WP GitHub Updater Tests",
+ "Version" => "1.0.0",
+ "Author" => "SilverAssist",
+ "RequiresWP" => "6.0",
+ "RequiresPHP" => "8.2",
+ // ...
+]
+```
+
+### Acceso Global al Updater
+
+```php
+// Obtener updater desde cualquier parte
+$updater = mock_plugin_get_updater();
+
+// O desde global
+$updater = $GLOBALS["mock_plugin_updater"];
+```
+
+### Limpieza de Cache
+
+```php
+// Limpiar cache de versiones
+delete_transient("mock-plugin_version_check");
+
+// O usar funciΓ³n de activaciΓ³n
+do_action("activate_mock-plugin/mock-plugin.php");
+```
+
+## π ConfiguraciΓ³n
+
+### Opciones Configurables
+
+El mock plugin demuestra todas las opciones disponibles:
+
+```php
+[
+ "plugin_name" => "Mock Plugin for Testing",
+ "plugin_description" => "A mock plugin for WP GitHub Updater tests",
+ "plugin_author" => "SilverAssist",
+ "cache_duration" => 300, // 5 minutos
+ "text_domain" => "mock-plugin",
+ "custom_temp_dir" => WP_CONTENT_DIR . "/uploads/temp",
+ "ajax_action" => "mock_plugin_check_version",
+ "ajax_nonce" => "mock_plugin_nonce",
+ "asset_pattern" => "mock-plugin-{version}.zip",
+ "requires_wordpress" => "6.0",
+ "requires_php" => "8.2",
+]
+```
+
+## β οΈ Notas Importantes
+
+### No Usar en ProducciΓ³n
+
+Este plugin es **exclusivamente para testing** y no debe usarse en sitios de producciΓ³n:
+
+- Usa un repositorio GitHub ficticio (`mock-test-repo`)
+- Cache duration muy corta (5 minutos)
+- ConfiguraciΓ³n optimizada para testing
+
+### Repositorio Ficticio
+
+El plugin apunta a `SilverAssist/mock-test-repo` que puede no existir. Para tests reales de API, deberΓ‘s:
+
+1. Crear un repositorio de prueba en GitHub
+2. Actualizar la configuraciΓ³n en `mock-plugin.php`
+3. Crear releases de prueba en ese repositorio
+
+### Compatibilidad
+
+- **WordPress**: 6.0+
+- **PHP**: 8.2+
+- **PHPUnit**: 9.6+
+- **WordPress Test Suite**: Requerido para tests completos
+
+## π Referencias
+
+- [Ejemplo de IntegraciΓ³n](../../../examples/integration-guide.php)
+- [DocumentaciΓ³n del Paquete](../../../README.md)
+- [Testing Summary](../../../docs/TESTING-SUMMARY.md)
+- [WordPress Plugin Unit Tests](https://make.wordpress.org/cli/handbook/misc/plugin-unit-tests/)
+
+## π Licencia
+
+MIT - Solo para propΓ³sitos de testing
+
+---
+
+**Γltima actualizaciΓ³n:** 2025-01-10
+**VersiΓ³n:** 1.0.0
+**Paquete:** silverassist/wp-github-updater v1.1.5
diff --git a/tests/fixtures/mock-plugin/mock-plugin.php b/tests/fixtures/mock-plugin/mock-plugin.php
new file mode 100644
index 0000000..eacca2b
--- /dev/null
+++ b/tests/fixtures/mock-plugin/mock-plugin.php
@@ -0,0 +1,213 @@
+ "Mock Plugin for Testing",
+ "plugin_description" => "A mock plugin for WP GitHub Updater tests",
+ "plugin_author" => "SilverAssist",
+
+ // Optional: Custom cache duration (default: 12 hours)
+ "cache_duration" => 300, // 5 minutes for testing
+
+ // Optional: Custom text domain for translations
+ "text_domain" => "mock-plugin",
+
+ // Optional: Custom temporary directory for downloads
+ "custom_temp_dir" => WP_CONTENT_DIR . "/uploads/temp",
+
+ // Optional: Custom AJAX action names
+ "ajax_action" => "mock_plugin_check_version",
+ "ajax_nonce" => "mock_plugin_nonce",
+
+ // Optional: Custom asset pattern for GitHub releases
+ "asset_pattern" => "mock-plugin-{version}.zip",
+
+ // Optional: WordPress and PHP requirements
+ "requires_wp" => "6.0",
+ "requires_php" => "8.2",
+ "last_updated" => \gmdate("Y-m-d H:i:s"),
+ ]
+ );
+
+ // Initialize the updater
+ $updater = new Updater($config);
+
+ // Store in global scope for testing access
+ $GLOBALS["mock_plugin_updater"] = $updater;
+}
+
+// Initialize on plugins_loaded hook
+add_action("plugins_loaded", "mock_plugin_init_updater");
+
+/**
+ * Add admin menu for testing
+ */
+function mock_plugin_admin_menu(): void
+{
+ add_menu_page(
+ "Mock Plugin",
+ "Mock Plugin",
+ "manage_options",
+ "mock-plugin",
+ "mock_plugin_admin_page",
+ "dashicons-admin-plugins",
+ 100
+ );
+}
+add_action("admin_menu", "mock_plugin_admin_menu");
+
+/**
+ * Admin page for testing
+ */
+function mock_plugin_admin_page(): void
+{
+ if (!current_user_can("manage_options")) {
+ return;
+ }
+
+ $updater = $GLOBALS["mock_plugin_updater"] ?? null;
+
+ ?>
+