com.amanotes.gdk 0.1.3

package/Tests/Runtime/AmaGDKCoreTest.cs

@@ -0,0 +1,229 @@
+using System;
+using System.Collections;
+using System.Text.RegularExpressions;
+using Amanotes.Core;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using UnityEngine.TestTools;
+
+using static Amanotes.Core.Internal.Messsage;
+using Amanotes.Core.Internal;
+
+public class AmaGDKCoreTest
+{  
+    const float AMAGDK_INIT_DURATION = 0.1f;
+    const string SCENE_WITH_AUTOINIT_ON = "TestScene01";
+    const string SCENE_WITH_AUTOINIT_OFF = "TestScene02";
+    const string SCENE_WITH_MULTI_AUTOINIT_ON = "TestScene03";
+    
+
+    [UnityTest] public IEnumerator AmaGDK_Init_MultipleTimes()
+    {
+        ClearAndResetAmaGDK();
+        yield return null;
+        yield return null;
+
+        AmaGDK.Init();
+        AmaGDK.Init();
+        LogAssert.Expect(LogType.Warning, new Regex(SDK_INIT_CALLED));
+
+        yield return new WaitForSeconds(AMAGDK_INIT_DURATION);
+        Assert.IsTrue(AmaGDK.isReady);
+    }
+
+    [UnityTest] public IEnumerator AmaGDK_Init_Then_AutoInit()
+    {
+        ClearAndResetAmaGDK();
+        yield return null;
+        yield return null;
+
+        AmaGDK.Init();
+        SceneManager.LoadScene(SCENE_WITH_AUTOINIT_ON, LoadSceneMode.Single);
+        LogAssert.Expect(LogType.Warning, new Regex(MULTIPLE_INSTANCE));
+
+        yield return new WaitForSeconds(AMAGDK_INIT_DURATION);
+        Assert.IsTrue(AmaGDK.isReady);
+    }
+
+    [UnityTest] public IEnumerator AmaGDK_AutoInit_Then_Init()
+    {
+        ClearAndResetAmaGDK();
+        yield return null;
+        yield return null;
+
+        SceneManager.LoadScene(SCENE_WITH_AUTOINIT_ON, LoadSceneMode.Single);
+        yield return null; // Took 1 frame for scene ready (call Awake)
+
+        AmaGDK.Init();
+        LogAssert.Expect(LogType.Warning, new Regex(SDK_INIT_CALLED));
+        
+        yield return new WaitForSeconds(AMAGDK_INIT_DURATION);
+        Assert.IsTrue(AmaGDK.isReady);
+    }
+    
+    [UnityTest] public IEnumerator AmaGDK_Init_Then_DisabledAutoInit()
+    {
+        ClearAndResetAmaGDK();
+        yield return null;
+        yield return null;
+        
+        AmaGDK.Init();
+        SceneManager.LoadScene(SCENE_WITH_AUTOINIT_OFF, LoadSceneMode.Single);
+        LogAssert.NoUnexpectedReceived();
+
+        yield return new WaitForSeconds(AMAGDK_INIT_DURATION);
+        Assert.IsTrue(AmaGDK.isReady);
+    }
+
+    [UnityTest] public IEnumerator AmaGDK_DisabledAutoInit_Then_Init()
+    {
+        ClearAndResetAmaGDK();
+        yield return null;
+        yield return null;
+        
+        SceneManager.LoadScene(SCENE_WITH_AUTOINIT_OFF, LoadSceneMode.Single);
+        yield return null; // Took 1 frame for scene ready (call Awake)
+        AmaGDK.Init();
+        LogAssert.NoUnexpectedReceived();
+
+        yield return new WaitForSeconds(AMAGDK_INIT_DURATION);
+        Assert.IsTrue(AmaGDK.isReady);
+    }
+    
+    [UnityTest] public IEnumerator AmaGDK_ShouldBeReadyWithin10Secs()
+    {
+        ClearAndResetAmaGDK();
+        yield return null;
+        yield return null;
+
+        AmaGDK.Init();
+
+        var frameCount = 0;
+        var stTime = Time.realtimeSinceStartup;
+        const float TIMEOUT = 10f;
+        
+        while (!AmaGDK.isReady){
+            yield return null;
+            frameCount++;
+
+            if (Time.realtimeSinceStartup - stTime > TIMEOUT)
+            {
+                Debug.LogWarning($"AmaGDK took too long to init: Not ready after {TIMEOUT} secs ({frameCount} frames)");
+                yield break;
+            }
+        }
+        
+        var initTime = Time.realtimeSinceStartup - stTime;
+        Debug.Log($"AmaGDK ready in {initTime} secs ({frameCount} frames)!");
+    }
+    
+    [UnityTest] public IEnumerator AmaGDK_IsSingleton()
+    {
+        ClearAndResetAmaGDK();
+        yield return null;
+        yield return null;
+
+        AmaGDK.Init();
+        yield return null;
+        yield return null;
+
+        SceneManager.LoadScene(SCENE_WITH_AUTOINIT_ON, LoadSceneMode.Additive);
+        SceneManager.LoadScene(SCENE_WITH_AUTOINIT_ON, LoadSceneMode.Additive);
+        SceneManager.LoadScene(SCENE_WITH_AUTOINIT_ON, LoadSceneMode.Additive);
+        SceneManager.LoadScene(SCENE_WITH_AUTOINIT_OFF, LoadSceneMode.Additive);
+        SceneManager.LoadScene(SCENE_WITH_AUTOINIT_OFF, LoadSceneMode.Additive);
+        SceneManager.LoadScene(SCENE_WITH_AUTOINIT_OFF, LoadSceneMode.Additive);
+        SceneManager.LoadScene(SCENE_WITH_AUTOINIT_OFF, LoadSceneMode.Additive);
+        yield return null;
+        yield return null;
+
+        UnloadAndGC();
+        yield return null;
+        
+        Assert.AreEqual(1, CountUnityObject<AmaGDK>());
+        LogAssert.Expect(LogType.Warning, new Regex(MULTIPLE_INSTANCE));
+
+        yield return new WaitForSeconds(AMAGDK_INIT_DURATION);
+        Assert.IsTrue(AmaGDK.isReady);
+    }
+
+    [UnityTest] public IEnumerator AmaGDK_SceneWithMultipleAmaGDKPrefabs()
+    {
+        ClearAndResetAmaGDK();
+        yield return null;
+        yield return null;
+        
+        SceneManager.LoadScene(SCENE_WITH_MULTI_AUTOINIT_ON);
+        yield return null;
+        yield return null;
+
+        UnloadAndGC();
+        yield return null;
+
+        Assert.AreEqual(1, CountUnityObject<AmaGDK>());
+        LogAssert.Expect(LogType.Warning, new Regex(MULTIPLE_INSTANCE));
+
+        yield return new WaitForSeconds(AMAGDK_INIT_DURATION);
+        Assert.IsTrue(AmaGDK.isReady);
+    }
+
+    [UnityTest] public IEnumerator AmaGDK_PersistentThroughSceneLoad()
+    {
+        ClearAndResetAmaGDK();
+        yield return null;
+        yield return null;
+        
+        AmaGDK.Init();
+        yield return null;
+        yield return null;
+        
+        SceneManager.LoadScene(1);
+        yield return null;
+
+        SceneManager.LoadScene(2);
+        yield return null;
+
+        // Clean up
+        UnloadAndGC();
+        yield return null;
+
+        Assert.AreEqual(1, CountUnityObject<AmaGDK>());
+
+        yield return new WaitForSeconds(AMAGDK_INIT_DURATION);
+        Assert.IsTrue(AmaGDK.isReady);
+    }
+
+
+    // UTILS
+    private static int CountUnityObject<T>() where T : UnityEngine.Object
+    {
+        var result = Resources.FindObjectsOfTypeAll<T>();
+        var count = 0;
+
+        for (var i = 0; i < result.Length; i++)
+        {
+#if UNITY_EDITOR // Ignore loaded prefabs assets
+            {
+                var path = UnityEditor.AssetDatabase.GetAssetPath(result[i]);
+                if (!string.IsNullOrEmpty(path)) continue;
+            }
+#endif
+            count++;
+            Debug.Log($"{i + 1} - {result[i]} - {result[i].GetInstanceID()}");
+        }
+
+        return count;
+    }
+
+    private static void ClearAndResetAmaGDK()
+    {
+        Forbidden.DestroyAndReset();
+        UnloadAndGC();
+    }
+
+    private static void UnloadAndGC(){
+        Resources.UnloadUnusedAssets();
+        GC.Collect(2, GCCollectionMode.Forced, true);
+    }
+}

package/Tests/Runtime/AmaGDKCoreTest.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a7a54dab56a6044049a2528526fe895b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/MigrationTest.cs

@@ -0,0 +1,165 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using UnityEngine;
+using NUnit.Framework;
+using UnityEngine.TestTools;
+using Amanotes.Core;
+using Amanotes.Core.Internal;
+using static Amanotes.Core.AmaGDK.Analytics;
+
+public class MigrationTest
+{
+    static List<string> lsFunnelEvents = new List<string>() { "fn_1", "fn_2", "fn_3" };
+    static List<string> lsFunnelEvents2 = new List<string>() { "fn_1", "fn_2", "fn_3", "fn_4" };
+    static Dictionary<string, int> dicEventCount = new Dictionary<string, int>() {
+            {"event_1", 1 },
+            {"event_2", 2 },
+            {"event_3", 3 },
+        };
+    static string fileName = typeof(AmaGDK.Analytics.AnalyticsData).Name;
+    static string path = FileUtils.GetPath(fileName);
+    static AnalyticsData analyticsData = AmaGDK.Analytics.localData;
+
+    [SetUp]
+    public void Setup()
+    {
+        ClearAnalyticsData();
+        AmaGDK.Init();
+        AmaGDK.Config.common.checkMigrationIntegrity = true;
+    }
+
+    [Test]
+    public void Migrate_First_Time()
+    {
+        ClearAnalyticsData();
+        AmaGDK.Analytics.Migrate(lsFunnelEvents, dicEventCount);
+        Assert.IsTrue(File.Exists(path));
+        Debug.Log($"Migration count: {analyticsData.migrationLog.count}");
+        Assert.IsTrue(analyticsData.migrationLog.count == 1);
+        Assert.IsTrue(analyticsData.funnelSignatures.Count == lsFunnelEvents.Count);
+        Assert.IsTrue(analyticsData.eventDetails.Count == dicEventCount.Count);
+    }
+
+    [UnityTest]
+    public IEnumerator Migrate_Second_Time()
+    {
+        FakeAnalyticsDataFile(1);
+        Debug.Log($"Count before migration: {analyticsData.migrationLog.count}");
+        AmaGDK.Analytics.Migrate(lsFunnelEvents2, dicEventCount);
+        Assert.IsTrue(File.Exists(path));
+        Debug.Log($"Count after migration: {analyticsData.migrationLog.count}");
+        Assert.IsTrue(analyticsData.migrationLog.count == 2);
+        Assert.IsTrue(analyticsData.funnelSignatures.Count == lsFunnelEvents2.Count);
+        Assert.IsTrue(analyticsData.eventDetails.Count == (dicEventCount.Count + 1)); // 1 more event is migration_error
+
+        yield return AssertErrorEvent();
+    }
+
+    [UnityTest]
+    public IEnumerator Migrate_Third_Time()
+    {
+        FakeAnalyticsDataFile(2, 1);
+        Debug.Log($"Count before migration: {analyticsData.migrationLog.count}");
+        AmaGDK.Analytics.Migrate(lsFunnelEvents2, dicEventCount);
+        Assert.IsTrue(File.Exists(path));
+        Debug.Log($"Count after migration: {analyticsData.migrationLog.count}");
+        Assert.IsTrue(analyticsData.migrationLog.count == 3);
+        Assert.IsTrue(analyticsData.funnelSignatures.Count == lsFunnelEvents2.Count);
+        Assert.IsTrue(analyticsData.eventDetails.Count == (dicEventCount.Count + 1)); // 1 more event is migration_error
+
+        yield return AssertErrorEvent();
+    }
+
+    [UnityTest]
+    public IEnumerator Call_Migration_MultipleTimes()
+    {
+        for (int i = 0; i < 3; i++)
+        {
+            AmaGDK.Analytics.Migrate(lsFunnelEvents, dicEventCount);
+            Assert.IsTrue(File.Exists(path));
+            Debug.Log($"Migration count: {analyticsData.migrationLog.count}");
+            Assert.IsTrue(analyticsData.migrationLog.count == 1);
+            Assert.IsTrue(analyticsData.funnelSignatures.Count == lsFunnelEvents.Count);
+            Assert.IsTrue(analyticsData.eventDetails.Count == dicEventCount.Count);
+            yield return null;
+        }        
+    }
+
+    [Test]
+    public void Call_Migration_Without_IntegrityCheck()
+    {        
+        FakeAnalyticsDataFile(1);        
+        AmaGDK.Config.common.checkMigrationIntegrity = false;
+        AmaGDK.Analytics.Migrate(lsFunnelEvents2, dicEventCount);
+        Assert.IsTrue(File.Exists(path));
+        Debug.Log($"Migration count: {analyticsData.migrationLog.count}");
+        Assert.IsTrue(analyticsData.migrationLog.count == 1);
+        Assert.IsTrue(analyticsData.funnelSignatures.Count == lsFunnelEvents.Count);
+    }
+
+    //Utils
+    private static void ClearAnalyticsData()
+    {
+        string fileName = typeof(AmaGDK.Analytics.AnalyticsData).Name;
+        string path = FileUtils.GetPath(fileName);
+        FileUtils.Delete(fileName);        
+        Assert.IsFalse(File.Exists(path));
+
+        analyticsData.funnelSignatures.Clear();
+        analyticsData.eventDetails.Clear();
+        analyticsData.migrationLog = new AmaGDK.Analytics.MigrationLog();
+    }
+
+    private static void FakeAnalyticsDataFile(int migrationCount, int migrationError = 0)
+    {
+        foreach (var e in lsFunnelEvents)
+        {
+            analyticsData.AddFunnelSignature(e);
+        }
+
+        foreach (var e in dicEventCount)
+        {
+            analyticsData.eventDetails.Add(new EventDetail
+            {
+                eventName = e.Key,
+                count = e.Value
+            });
+        }
+
+        if (migrationCount > 0)
+        {
+            analyticsData.eventDetails.Add(new EventDetail
+            {
+                eventName = "migration_error",
+                count = migrationError
+            });
+        }
+
+        analyticsData.migrationLog = new MigrationLog()
+        {
+            deviceId = SystemInfo.deviceUniqueIdentifier,
+            appVersion = Application.version,
+            amaGDKVersion = AmaGDK.VERSION,
+            count = migrationCount
+        };
+
+        analyticsData.SaveIfDirty();
+    }
+
+    IEnumerator AssertErrorEvent()
+    {
+        yield return null;
+        string errEventName = "migration_error";
+        var eventDetail = analyticsData.GetEventDetail(errEventName);
+        if (eventDetail != null)
+        {
+            Assert.IsTrue(eventDetail.count == 1);
+        }
+        else
+        {
+            var eventParams = eventQueue.Peek();
+            Assert.IsTrue(eventParams.eventName == errEventName);
+        }
+    }
+}

package/Tests/Runtime/MigrationTest.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fc10783be36334c7f813237a7a9f5a6f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a949338a88ed4413298638bee3ca021c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/TestScene00.unity

@@ -0,0 +1,125 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0.7431153, g: 0.7385969, b: 0.73850554, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 12
+  m_GIWorkflowMode: 1
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 0
+  m_LightmapEditorSettings:
+    serializedVersion: 12
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 1
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 512
+    m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 256
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 1
+    m_PVRDenoiserTypeDirect: 1
+    m_PVRDenoiserTypeIndirect: 1
+    m_PVRDenoiserTypeAO: 1
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVREnvironmentMIS: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ExportTrainingData: 0
+    m_TrainingDataDestination: TrainingData
+    m_LightProbeSampleCountMultiplier: 4
+  m_LightingDataAsset: {fileID: 0}
+  m_LightingSettings: {fileID: 0}
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    maxJobWorkers: 0
+    preserveTilesOutsideBounds: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}

package/Tests/TestScene00.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d0b6ac2d48f974ba48ae61cbae556c4b
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: