Add WPUnit tests for taxonomy field display fix (#392)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: polevaultweb

tests/wpunit/Fields/TaxonomyFieldDisplayTest.php

@@ -0,0 +1,292 @@
+<?php
+/**
+ * Tests for the taxonomy field display fix (PR #392).
+ *
+ * When a WPUM field has type 'taxonomy' and its user_meta_key starts with
+ * 'wpum_', the set_user_meta() method should retrieve the value via
+ * get_user_meta() instead of carbon_get_user_meta(), because Carbon Fields
+ * returns empty for taxonomy-type fields.
+ *
+ * The fix adds `&& $this->get_type() !== 'taxonomy'` to the elseif branch
+ * in set_user_meta() so taxonomy fields fall through to the get_user_meta()
+ * path.
+ *
+ * @see https://github.com/WPUserManager/wp-user-manager/pull/392
+ */
+
+require_once __DIR__ . '/FieldsTestCase.php';
+
+class TaxonomyFieldDisplayTest extends FieldsTestCase {
+
+	/**
+	 * @var int
+	 */
+	protected $test_group_id;
+
+	/**
+	 * @var int
+	 */
+	protected $user_id;
+
+	public function _setUp() {
+		parent::_setUp();
+
+		// Get or create a field group.
+		$groups = $this->groups_db->get_groups( array(
+			'primary' => true,
+		) );
+
+		if ( ! empty( $groups ) ) {
+			$this->test_group_id = $groups[0]->get_ID();
+		} else {
+			$this->test_group_id = $this->groups_db->insert( array(
+				'name'       => 'Test Group',
+				'is_primary' => 1,
+			) );
+		}
+
+		// Create a test user.
+		$this->user_id = $this->factory()->user->create( array(
+			'user_login' => 'taxonomy_test_user',
+			'user_email' => 'taxonomy_test@example.com',
+			'role'       => 'subscriber',
+		) );
+
+		// Register a custom taxonomy for testing.
+		if ( ! taxonomy_exists( 'wpum_test_skill' ) ) {
+			register_taxonomy( 'wpum_test_skill', 'user', array(
+				'label'        => 'Skills',
+				'public'       => true,
+				'hierarchical' => false,
+			) );
+		}
+	}
+
+	public function _tearDown() {
+		if ( $this->user_id ) {
+			wp_delete_user( $this->user_id );
+		}
+
+		parent::_tearDown();
+	}
+
+	/**
+	 * Helper: create a WPUM field in the database and return the WPUM_Field object.
+	 *
+	 * @param string $type     The field type (e.g. 'taxonomy', 'text').
+	 * @param string $name     The field name.
+	 * @param string $meta_key The user_meta_key value.
+	 *
+	 * @return \WPUM_Field
+	 */
+	private function create_field( $type, $name, $meta_key ) {
+		$field_id = $this->fields_db->insert( array(
+			'group_id'    => $this->test_group_id,
+			'type'        => $type,
+			'name'        => $name,
+			'field_order' => 99,
+		) );
+
+		$this->assertGreaterThan( 0, $field_id, "Field '{$name}' should be inserted." );
+
+		// Set the user_meta_key meta.
+		$this->field_meta_db->add_meta( $field_id, 'user_meta_key', $meta_key );
+
+		$field = new \WPUM_Field( $field_id );
+
+		$this->assertNotEmpty( $field->get_ID(), 'WPUM_Field should be instantiated from DB.' );
+
+		return $field;
+	}
+
+	/**
+	 * Test that a taxonomy field with a 'wpum_' prefixed meta key retrieves
+	 * its value from get_user_meta() (not carbon_get_user_meta).
+	 *
+	 * This is the core scenario that PR #392 fixes: taxonomy field data was
+	 * not displayed because carbon_get_user_meta() returned empty.
+	 */
+	public function test_taxonomy_field_with_wpum_prefix_uses_get_user_meta() {
+		$meta_key = 'wpum_test_skill';
+		$field    = $this->create_field( 'taxonomy', 'Test Taxonomy Field', $meta_key );
+
+		// Confirm the field is of type 'taxonomy'.
+		$this->assertSame( 'taxonomy', $field->get_type(), 'Field type should be taxonomy.' );
+
+		// Confirm the meta key starts with 'wpum_'.
+		$this->assertStringStartsWith( 'wpum_', $field->get_meta( 'user_meta_key' ), 'Meta key should start with wpum_.' );
+
+		// Store taxonomy term IDs in regular user meta (this is how WP stores it).
+		$term_ids = array( 1, 2, 3 );
+		update_user_meta( $this->user_id, $meta_key, $term_ids );
+
+		// Call set_user_meta — with the fix, this should go through
+		// get_user_meta() and find our stored value.
+		$field->set_user_meta( $this->user_id );
+
+		$value = $field->get_value();
+
+		$this->assertNotNull( $value, 'Taxonomy field value should not be null after set_user_meta().' );
+		$this->assertNotEmpty( $value, 'Taxonomy field value should not be empty — it should be retrieved via get_user_meta().' );
+	}
+
+	/**
+	 * Test that a taxonomy field correctly retrieves a single term ID stored
+	 * as a scalar value in user meta.
+	 */
+	public function test_taxonomy_field_retrieves_single_term_id() {
+		$meta_key = 'wpum_single_taxonomy';
+		$field    = $this->create_field( 'taxonomy', 'Single Taxonomy Field', $meta_key );
+
+		// Store a single term ID.
+		$term_id = 42;
+		update_user_meta( $this->user_id, $meta_key, $term_id );
+
+		$field->set_user_meta( $this->user_id );
+
+		$value = $field->get_value();
+
+		$this->assertNotNull( $value, 'Single term ID should be retrieved.' );
+		$this->assertNotEmpty( $value, 'Taxonomy field should retrieve a single term ID from user meta.' );
+	}
+
+	/**
+	 * Test that a taxonomy field with a non-wpum prefix also retrieves
+	 * its value via get_user_meta() (the else branch).
+	 */
+	public function test_taxonomy_field_with_non_wpum_prefix_uses_get_user_meta() {
+		$meta_key = 'custom_taxonomy_field';
+		$field    = $this->create_field( 'taxonomy', 'Custom Prefix Taxonomy', $meta_key );
+
+		$this->assertSame( 'taxonomy', $field->get_type() );
+
+		$term_ids = array( 10, 20 );
+		update_user_meta( $this->user_id, $meta_key, $term_ids );
+
+		$field->set_user_meta( $this->user_id );
+
+		$value = $field->get_value();
+
+		$this->assertNotNull( $value, 'Non-wpum-prefix taxonomy field should retrieve value from user meta.' );
+		$this->assertNotEmpty( $value, 'Non-wpum-prefix taxonomy field should not be empty.' );
+	}
+
+	/**
+	 * Test that a non-taxonomy field with a 'wpum_' prefix does NOT retrieve
+	 * its value from get_user_meta() — it should go through the Carbon Fields
+	 * path (carbon_get_user_meta).
+	 *
+	 * We store a value in regular user meta and verify that the text field
+	 * does NOT see it (because it takes the carbon_get_user_meta branch,
+	 * which stores/retrieves data differently).
+	 */
+	public function test_non_taxonomy_field_with_wpum_prefix_uses_carbon_path() {
+		$meta_key = 'wpum_custom_text';
+		$field    = $this->create_field( 'text', 'Custom Text Field', $meta_key );
+
+		$this->assertSame( 'text', $field->get_type(), 'Field type should be text.' );
+		$this->assertStringStartsWith( 'wpum_', $field->get_meta( 'user_meta_key' ) );
+
+		// Store a value in regular user meta.
+		update_user_meta( $this->user_id, $meta_key, 'plain_meta_value' );
+
+		$field->set_user_meta( $this->user_id );
+
+		$value = $field->get_value();
+
+		// A text field with wpum_ prefix should NOT get the plain user meta
+		// value, because it goes through carbon_get_user_meta which uses a
+		// different storage format (prefixed with _wpum_custom_text).
+		// The value should be null/empty because Carbon Fields has no data
+		// stored for this field.
+		$this->assertTrue(
+			empty( $value ) || $value !== 'plain_meta_value',
+			'Non-taxonomy field with wpum_ prefix should use carbon_get_user_meta, not get_user_meta.'
+		);
+	}
+
+	/**
+	 * Test that a non-taxonomy field without a 'wpum_' prefix uses regular
+	 * get_user_meta() and retrieves the value correctly.
+	 */
+	public function test_non_taxonomy_field_without_wpum_prefix_uses_get_user_meta() {
+		$meta_key = 'custom_text_field';
+		$field    = $this->create_field( 'text', 'Plain Meta Text Field', $meta_key );
+
+		$this->assertSame( 'text', $field->get_type() );
+
+		update_user_meta( $this->user_id, $meta_key, 'hello world' );
+
+		$field->set_user_meta( $this->user_id );
+
+		$value = $field->get_value();
+
+		$this->assertNotEmpty( $value, 'Text field without wpum_ prefix should retrieve value from get_user_meta.' );
+	}
+
+	/**
+	 * Test that set_user_meta() handles an invalid user ID gracefully.
+	 */
+	public function test_set_user_meta_with_invalid_user_id() {
+		$field = $this->create_field( 'taxonomy', 'Invalid User Taxonomy', 'wpum_invalid_tax' );
+
+		// Passing 0 should return early.
+		$field->set_user_meta( 0 );
+
+		$this->assertNull( $field->get_value(), 'Value should remain null for invalid user ID.' );
+	}
+
+	/**
+	 * Test that a taxonomy field with empty user meta returns null/empty.
+	 */
+	public function test_taxonomy_field_with_no_user_meta_returns_empty() {
+		$field = $this->create_field( 'taxonomy', 'Empty Taxonomy', 'wpum_empty_tax' );
+
+		// Do NOT store any user meta for this key.
+		$field->set_user_meta( $this->user_id );
+
+		$value = $field->get_value();
+
+		$this->assertEmpty( $value, 'Taxonomy field with no stored meta should return empty.' );
+	}
+
+	/**
+	 * Test that the branching condition in set_user_meta() correctly
+	 * distinguishes taxonomy from non-taxonomy when both have 'wpum_' prefix.
+	 *
+	 * This is a combined test to validate the exact condition:
+	 *   strpos(meta_key, 'wpum_') === 0 && get_type() !== 'taxonomy'
+	 */
+	public function test_branching_condition_taxonomy_vs_non_taxonomy() {
+		$meta_key = 'wpum_shared_key';
+
+		// Create taxonomy field.
+		$tax_field = $this->create_field( 'taxonomy', 'Tax Branching Field', $meta_key );
+
+		// Create text field with the same meta key pattern.
+		$text_field = $this->create_field( 'text', 'Text Branching Field', $meta_key );
+
+		// Store data in regular user meta.
+		update_user_meta( $this->user_id, $meta_key, 'stored_value' );
+
+		// Taxonomy field should retrieve the value (goes through get_user_meta).
+		$tax_field->set_user_meta( $this->user_id );
+		$tax_value = $tax_field->get_value();
+
+		// Text field should NOT retrieve the plain meta value (goes through carbon_get_user_meta).
+		$text_field->set_user_meta( $this->user_id );
+		$text_value = $text_field->get_value();
+
+		$this->assertNotEmpty(
+			$tax_value,
+			'Taxonomy field should retrieve value from get_user_meta (PR #392 fix).'
+		);
+
+		// The text field either gets nothing (Carbon returns empty) or gets
+		// a different value. Either way, the paths are different.
+		$this->assertTrue(
+			empty( $text_value ) || $text_value !== $tax_value,
+			'Text field with same wpum_ prefix key should take the Carbon Fields path, not get_user_meta.'
+		);
+	}
+}