Unity IAP Android No Pop up

In my android game my BuyNoAds(); Function does not being up a pop up to buy the no ads product . I've done this before in a previous project like a few months ago and this worked fine. Pretty much same code but for this project its not working. Must be missing something.. Here are the things I have done or have tried already;

1. The game is being tested In alpha in google play console and I already have a Active product ID with the same name as the string i pass in unity.

2. I have added builder.Configure().SetPublicKey("mypublickey"); Cause I've read that was the issue for others . I never did this before on past projects and they still worked but I tried it anyway and still nothing. and My public key isn't actually "mypublickey"...but i have that LONG string under Development tools/Services and API in the google dev console .

3. I have IAP imported and up to date in Unity and have my key added in analytics as well.

4. When BuyNoAds(); is executed it passes initializing it returns this from the BuyProductID() function : Debug.Log(string.Format("Purchasing product asychronously: '{0}'", product.definition.id));. So its finding the ID and its available to purchase but something must be going wrong at m_StoreController.InitiatePurchase(product);..

5. I am Testing this on a separate account that is not the email I'm using to develop the game. The separate account is added to the alpha test and is added under License Testing in the google play console.

Is there something I'm missing or not thinking about? I'm not the best debugger. Is there a way I can generate a log file when I run it on my android device and see if m_StoreController.InitiatePurchase(product) Is failing somewhere?

Code is Below:

 using System;
     using System.Collections.Generic;
     using UnityEngine;
     using UnityEngine.Purchasing;
     using TMPro;
 
 public class IAPManager : MonoBehaviour, IStoreListener
 {
 
     // Use this for initialization
 
     private static IStoreController m_StoreController;          // The Unity Purchasing system.
     private static IExtensionProvider m_StoreExtensionProvider; // The store-specific Purchasing subsystems.
 
     // Product identifiers for all products capable of being purchased: 
     // "convenience" general identifiers for use with Purchasing, and their store-specific identifier 
     // counterparts for use with and outside of Unity Purchasing. Define store-specific identifiers 
     // also on each platform's publisher dashboard (iTunes Connect, Google Play Developer Console, etc.)
 
     // General product identifiers for the consumable, non-consumable, and subscription products.
     // Use these handles in the code to reference which product to purchase. Also use these values 
     // when defining the Product Identifiers on the store. Except, for illustration purposes, the 
     // kProductIDSubscription - it has custom Apple and Google identifiers. We declare their store-
     // specific mapping to Unity Purchasing's AddProduct, below.
 
     public static string ProductNoAds = "noads";
     public TextMeshPro Test;
 
 
     private static IAPManager instance;
 
 
     public static IAPManager Instance
     {
         get
         {
             if (instance == null)
             {
                 instance = GameObject.FindObjectOfType<IAPManager>();
             }
             return instance;
         }
     }
 
 
     void Start()
         {
             // If we haven't set up the Unity Purchasing reference
             if (m_StoreController == null)
             {
                 // Begin to configure our connection to Purchasing
                 InitializePurchasing();
             }
         }
 
         public void InitializePurchasing()
         {
             // If we have already connected to Purchasing ...
             if (IsInitialized())
             {
                 // ... we are done here.
                 return;
             }
 
             // Create a builder, first passing in a suite of Unity provided stores.
             var builder = ConfigurationBuilder.Instance(StandardPurchasingModule.Instance());
 
             // Add a product to sell / restore by way of its identifier, associating the general identifier
             // with its store-specific identifiers.
           
             // Continue adding the non-consumable product.
             builder.AddProduct(ProductNoAds, ProductType.NonConsumable);
          builder.Configure<IGooglePlayConfiguration>().SetPublicKey("mypublickey");
         // And finish adding the subscription product. Notice this uses store-specific IDs, illustrating
         // if the Product ID was configured differently between Apple and Google stores. Also note that
         // one uses the general kProductIDSubscription handle inside the game - the store-specific IDs 
         // must only be referenced here. 
 
 
         // Kick off the remainder of the set-up with an asynchrounous call, passing the configuration 
         // and this class' instance. Expect a response either in OnInitialized or OnInitializeFailed.
         UnityPurchasing.Initialize(this, builder);
         }
 
 
         private bool IsInitialized()
         {
             // Only say we are initialized if both the Purchasing references are set.
             return m_StoreController != null && m_StoreExtensionProvider != null;
         }
 
 
      
 
 
         public void BuyNoAds()
         {
             // Buy the non-consumable product using its general identifier. Expect a response either 
             // through ProcessPurchase or OnPurchaseFailed asynchronously.
             BuyProductID(ProductNoAds);
         }
 
 
 
 
 
         void BuyProductID(string productId)
         {
             // If Purchasing has been initialized ...
             if (IsInitialized())
             {
                 // ... look up the Product reference with the general product identifier and the Purchasing 
                 // system's products collection.
                 Product product = m_StoreController.products.WithID(productId);
 
                 // If the look up found a product for this device's store and that product is ready to be sold ... 
                 if (product != null && product.availableToPurchase)
                 {
                     Debug.Log(string.Format("Purchasing product asychronously: '{0}'", product.definition.id));
                     // ... buy the product. Expect a response either through ProcessPurchase or OnPurchaseFailed 
                     // asynchronously.
                     m_StoreController.InitiatePurchase(product);
                 }
                 // Otherwise ...
                 else
                 {
                     // ... report the product look-up failure situation  
                     Debug.Log("BuyProductID: FAIL. Not purchasing product, either is not found or is not available for purchase");
                 }
             }
             // Otherwise ...
             else
             {
                 // ... report the fact Purchasing has not succeeded initializing yet. Consider waiting longer or 
                 // retrying initiailization.
                 Debug.Log("BuyProductID FAIL. Not initialized.");
             }
         }
 
 
 
         //  
         // --- IStoreListener
         //
 
         public void OnInitialized(IStoreController controller, IExtensionProvider extensions)
         {
             // Purchasing has succeeded initializing. Collect our Purchasing references.
             Debug.Log("OnInitialized: PASS");
 
             // Overall Purchasing system, configured with products for this application.
             m_StoreController = controller;
             // Store specific subsystem, for accessing device-specific store features.
             m_StoreExtensionProvider = extensions;
         }
 
 
         public void OnInitializeFailed(InitializationFailureReason error)
         {
             // Purchasing set-up has not succeeded. Check error for reason. Consider sharing this reason with the user.
             Debug.Log("OnInitializeFailed InitializationFailureReason:" + error);
         }
 
 
         public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs args)
         {
            
             // Or ... a non-consumable product has been purchased by this user.
              if (String.Equals(args.purchasedProduct.definition.id, ProductNoAds, StringComparison.Ordinal))
             {
                 Debug.Log(string.Format("ProcessPurchase: PASS. Product: '{0}'", args.purchasedProduct.definition.id));
                 // TODO: The non-consumable item has been successfully purchased, grant this item to the player.
             }
            
             // Or ... an unknown product has been purchased by this user. Fill in additional products here....
             else
             {
                 Debug.Log(string.Format("ProcessPurchase: FAIL. Unrecognized product: '{0}'", args.purchasedProduct.definition.id));
             }
 
             // Return a flag indicating whether this product has completely been received, or if the application needs 
             // to be reminded of this purchase at next app launch. Use PurchaseProcessingResult.Pending when still 
             // saving purchased products to the cloud, and when that save is delayed. 
             return PurchaseProcessingResult.Complete;
         }
 
 
         public void OnPurchaseFailed(Product product, PurchaseFailureReason failureReason)
         {
             // A product purchase attempt did not succeed. Check failureReason for more detail. Consider sharing 
             // this reason with the user to guide their troubleshooting actions.
             Debug.Log(string.Format("OnPurchaseFailed: FAIL. Product: '{0}', PurchaseFailureReason: {1}", product.definition.storeSpecificId, failureReason));
         }
 

 }