WuhuIslandTesting/Library/PackageCache/com.unity.addressables@1.21.12/Tests/Editor/Build/BuildScriptTests.cs

633 lines
29 KiB
C#
Raw Normal View History

2025-01-07 02:06:59 +01:00
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using NUnit.Framework;
using UnityEditor.AddressableAssets.Build;
using UnityEditor.AddressableAssets.Build.DataBuilders;
using UnityEditor.AddressableAssets.Settings;
using UnityEditor.AddressableAssets.Settings.GroupSchemas;
using UnityEditor.Build.Pipeline.Utilities;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.TestTools;
namespace UnityEditor.AddressableAssets.Tests
{
public class BuildScriptTests : AddressableAssetTestBase
{
[TestFixture]
class StreamingAssetTests : AddressableAssetTestBase
{
[SetUp]
public void Setup()
{
DirectoryUtility.DeleteDirectory(Application.streamingAssetsPath, recursiveDelete: true);
}
[TearDown]
public void TearDown()
{
DirectoryUtility.DeleteDirectory(Application.streamingAssetsPath, recursiveDelete: true);
}
[Test]
public void ClearCachedData_CleansStreamingAssetFolder()
{
var context = new AddressablesDataBuilderInput(Settings);
int builderCount = 0;
for (int i = 0; i < Settings.DataBuilders.Count; i++)
{
var builder = Settings.DataBuilders[i] as IDataBuilder;
if (builder.CanBuildData<AddressablesPlayerBuildResult>())
{
builderCount++;
var existingFiles = new HashSet<string>();
if (System.IO.Directory.Exists("Assets/StreamingAssets"))
{
foreach (var f in System.IO.Directory.GetFiles("Assets/StreamingAssets"))
existingFiles.Add(f);
}
builder.BuildData<AddressablesPlayerBuildResult>(context);
builder.ClearCachedData();
if (System.IO.Directory.Exists("Assets/StreamingAssets"))
{
foreach (var f in System.IO.Directory.GetFiles("Assets/StreamingAssets"))
Assert.IsTrue(existingFiles.Contains(f), string.Format("Data Builder {0} did not clean up file {1}", builder.Name, f));
}
}
}
Assert.IsTrue(builderCount > 0);
}
[Test]
public void Folder_WithSubAssets_GetsBundleFileIdAssigned_DuringBuild()
{
var context = new AddressablesDataBuilderInput(Settings);
string folderGuid = AssetDatabase.CreateFolder(TestFolder, "FolderAsset");
string folderPath = $"{TestFolder}/FolderAsset";
PrefabUtility.SaveAsPrefabAsset(new GameObject(), $"{folderPath}/subfolderprefab.prefab");
AddressableAssetEntry folderEntry = Settings.CreateOrMoveEntry(folderGuid, Settings.DefaultGroup);
Assert.IsTrue(string.IsNullOrEmpty(folderEntry.BundleFileId));
Settings.ActivePlayerDataBuilder.BuildData<AddressablesPlayerBuildResult>(context);
Assert.IsTrue(folderEntry.IsFolder);
Assert.IsFalse(string.IsNullOrEmpty(folderEntry.BundleFileId));
//Cleanup
AssetDatabase.DeleteAsset(folderPath);
Settings.RemoveAssetEntry(folderEntry);
}
[Test]
public void Folder_WithNoSubAssets_DoesNotThrowErrorDuringBuild()
{
var context = new AddressablesDataBuilderInput(Settings);
string folderGuid = AssetDatabase.CreateFolder(TestFolder, "FolderAsset");
string folderPath = $"{TestFolder}/FolderAsset";
AddressableAssetEntry folderEntry = Settings.CreateOrMoveEntry(folderGuid, Settings.DefaultGroup);
Assert.IsTrue(string.IsNullOrEmpty(folderEntry.BundleFileId));
Settings.ActivePlayerDataBuilder.BuildData<AddressablesPlayerBuildResult>(context);
Assert.IsTrue(folderEntry.IsFolder);
Assert.IsTrue(string.IsNullOrEmpty(folderEntry.BundleFileId));
//Cleanup
AssetDatabase.DeleteAsset(folderPath);
Settings.RemoveAssetEntry(folderEntry);
}
[Test]
public void Folder_DoesNotAssignBundleFileId_ForDynamicallyCreatedSubEntries()
{
var context = new AddressablesDataBuilderInput(Settings);
string folderGuid = AssetDatabase.CreateFolder(TestFolder, "FolderAsset");
string folderPath = $"{TestFolder}/FolderAsset";
PrefabUtility.SaveAsPrefabAsset(new GameObject(), $"{folderPath}/subfolderprefab.prefab");
AddressableAssetEntry folderEntry = Settings.CreateOrMoveEntry(folderGuid, Settings.DefaultGroup);
Settings.ActivePlayerDataBuilder.BuildData<AddressablesPlayerBuildResult>(context);
Assert.True(string.IsNullOrEmpty(folderEntry.SubAssets[0].BundleFileId));
//Cleanup
AssetDatabase.DeleteAsset(folderPath);
Settings.RemoveAssetEntry(folderEntry);
}
#if !UNITY_2021_2_OR_NEWER
[Test]
public void CopiedStreamingAssetAreCorrectlyDeleted_DirectoriesWithoutImport()
{
var context = new AddressablesDataBuilderInput(Settings);
int builderCount = 0;
for (int i = 0; i < Settings.DataBuilders.Count; i++)
{
var builder = Settings.DataBuilders[i] as IDataBuilder;
if (builder.CanBuildData<AddressablesPlayerBuildResult>())
{
builderCount++;
// confirm that StreamingAssets does not exists before the test
Assert.IsFalse(Directory.Exists("Assets/StreamingAssets"));
builder.BuildData<AddressablesPlayerBuildResult>(context);
Assert.IsTrue(Directory.Exists(Addressables.BuildPath));
AddressablesPlayerBuildProcessor.CopyTemporaryPlayerBuildData();
builder.ClearCachedData();
Assert.IsTrue(Directory.Exists(Addressables.PlayerBuildDataPath));
AddressablesPlayerBuildProcessor.CleanTemporaryPlayerBuildData();
Assert.IsFalse(Directory.Exists(Addressables.PlayerBuildDataPath));
Assert.IsFalse(Directory.Exists("Assets/StreamingAssets"));
}
}
Assert.IsTrue(builderCount > 0);
}
[Test]
public void CopiedStreamingAssetAreCorrectlyDeleted_MetaFilesWithImport()
{
var context = new AddressablesDataBuilderInput(Settings);
int builderCount = 0;
for (int i = 0; i < Settings.DataBuilders.Count; i++)
{
var builder = Settings.DataBuilders[i] as IDataBuilder;
if (builder.CanBuildData<AddressablesPlayerBuildResult>())
{
builderCount++;
// confirm that StreamingAssets does not exists before the test
DirectoryUtility.DeleteDirectory(Application.streamingAssetsPath, recursiveDelete: true);
Assert.IsFalse(Directory.Exists("Assets/StreamingAssets"));
builder.BuildData<AddressablesPlayerBuildResult>(context);
Assert.IsTrue(Directory.Exists(Addressables.BuildPath));
AddressablesPlayerBuildProcessor.CopyTemporaryPlayerBuildData();
builder.ClearCachedData();
// confirm that PlayerBuildDataPath is imported to AssetDatabase
AssetDatabase.Refresh();
Assert.IsTrue(Directory.Exists(Addressables.PlayerBuildDataPath));
Assert.IsTrue(File.Exists(Addressables.PlayerBuildDataPath + ".meta"));
string relativePath = Addressables.PlayerBuildDataPath.Replace(Application.dataPath, "Assets");
Assert.IsTrue(AssetDatabase.IsValidFolder(relativePath), "Copied StreamingAssets folder was not importer as expected");
AddressablesPlayerBuildProcessor.CleanTemporaryPlayerBuildData();
Assert.IsFalse(Directory.Exists(Addressables.PlayerBuildDataPath));
Assert.IsFalse(Directory.Exists("Assets/StreamingAssets"));
}
}
Assert.IsTrue(builderCount > 0);
}
[Test]
public void CopiedStreamingAssetAreCorrectlyDeleted_WithExistingFiles()
{
var context = new AddressablesDataBuilderInput(Settings);
int builderCount = 0;
for (int i = 0; i < Settings.DataBuilders.Count; i++)
{
var builder = Settings.DataBuilders[i] as IDataBuilder;
if (builder.CanBuildData<AddressablesPlayerBuildResult>())
{
builderCount++;
// confirm that StreamingAssets does not exists before the test
DirectoryUtility.DeleteDirectory(Application.streamingAssetsPath, recursiveDelete: true);
Assert.IsFalse(Directory.Exists("Assets/StreamingAssets"));
// create StreamingAssets and an extra folder as existing content
AssetDatabase.CreateFolder("Assets", "StreamingAssets");
AssetDatabase.CreateFolder("Assets/StreamingAssets", "extraFolder");
builder.BuildData<AddressablesPlayerBuildResult>(context);
Assert.IsTrue(Directory.Exists(Addressables.BuildPath));
AddressablesPlayerBuildProcessor.CopyTemporaryPlayerBuildData();
builder.ClearCachedData();
Assert.IsTrue(Directory.Exists(Addressables.PlayerBuildDataPath));
AddressablesPlayerBuildProcessor.CleanTemporaryPlayerBuildData();
Assert.IsFalse(Directory.Exists(Addressables.PlayerBuildDataPath));
Assert.IsTrue(Directory.Exists("Assets/StreamingAssets"));
Assert.IsTrue(Directory.Exists("Assets/StreamingAssets/extraFolder"));
AssetDatabase.DeleteAsset("Assets/StreamingAssets");
}
}
Assert.IsTrue(builderCount > 0);
}
#else
[Test]
public void AddressablesBuildPlayerProcessor_IncludeAdditionalStreamingAssetsWhenExist()
{
string path = Addressables.BuildPath;
Directory.CreateDirectory(path);
var paths = AddressablesPlayerBuildProcessor.GetStreamingAssetPaths();
Assert.AreEqual(1, paths.Count, "StreamingAssets paths expected to include Addressables.BuildPath");
// cleanup
Directory.Delete(path);
}
[Test]
public void AddressablesBuildPlayerProcessor_DoesntIncludeAdditionalStreamingAssetsWhenDontExist()
{
if (Directory.Exists(Addressables.BuildPath))
DirectoryUtility.DeleteDirectory(Addressables.BuildPath, false);
var paths = AddressablesPlayerBuildProcessor.GetStreamingAssetPaths();
Assert.AreEqual(0, paths.Count, "StreamingAssets paths are expected to be empty");
// cleanup
}
#endif
}
[Test]
public void BuildScriptBase_FailsCanBuildData()
{
var buildScript = ScriptableObject.CreateInstance<BuildScriptBase>();
Assert.IsFalse(buildScript.CanBuildData<IDataBuilderResult>());
Assert.IsFalse(buildScript.CanBuildData<AddressableAssetBuildResult>());
Assert.IsFalse(buildScript.CanBuildData<AddressablesPlayModeBuildResult>());
Assert.IsFalse(buildScript.CanBuildData<AddressablesPlayerBuildResult>());
}
internal class BuildScriptTestClass : BuildScriptBase
{
public override string Name
{
get { return "Test Script"; }
}
public override bool CanBuildData<T>()
{
return typeof(T).IsAssignableFrom(typeof(AddressablesPlayModeBuildResult));
}
protected override TResult BuildDataImplementation<TResult>(AddressablesDataBuilderInput builderInput)
{
Debug.LogError("Inside BuildDataInternal for test script!");
return base.BuildDataImplementation<TResult>(builderInput);
}
}
[Test]
public void BuildScript_DoesNotBuildWrongDataType()
{
var context = new AddressablesDataBuilderInput(Settings);
var baseScript = ScriptableObject.CreateInstance<BuildScriptTestClass>();
baseScript.BuildData<AddressablesPlayerBuildResult>(context);
LogAssert.Expect(LogType.Error, new Regex("Data builder Test Script cannot build requested type.*"));
baseScript.BuildData<AddressablesPlayModeBuildResult>(context);
LogAssert.Expect(LogType.Error, "Inside BuildDataInternal for test script!");
}
[Test]
public void GetNameWithHashNaming_ReturnsNoChangeIfNoHash()
{
string source = "x/y.bundle";
string hash = "123abc";
string expected = "x/y.bundle";
var actual = BuildUtility.GetNameWithHashNaming(BundledAssetGroupSchema.BundleNamingStyle.NoHash, hash, source);
Assert.AreEqual(expected, actual);
}
[Test]
public void GetNameWithHashNaming_CanAppendHash()
{
string source = "x/y.bundle";
string hash = "123abc";
string expected = "x/y_123abc.bundle";
var actual = BuildUtility.GetNameWithHashNaming(BundledAssetGroupSchema.BundleNamingStyle.AppendHash, hash, source);
Assert.AreEqual(expected, actual);
}
[Test]
public void GetNameWithHashNaming_CanReplaceFileNameWithHash()
{
string source = "x/y.bundle";
string hash = "123abc";
string expected = "123abc.bundle";
var actual = BuildUtility.GetNameWithHashNaming(BundledAssetGroupSchema.BundleNamingStyle.OnlyHash, hash, source);
Assert.AreEqual(expected, actual);
}
[Test]
public void GetNameWithHashNaming_CanReplaceFileNameWithFileNameHash()
{
string source = "x/y.bundle";
string hash = HashingMethods.Calculate(source).ToString();
string expected = hash + ".bundle";
var actual = BuildUtility.GetNameWithHashNaming(BundledAssetGroupSchema.BundleNamingStyle.FileNameHash, hash, source);
Assert.AreEqual(expected, actual);
}
// regression test for https://jira.unity3d.com/browse/ADDR-1292
[Test]
public void BuildScriptBaseWriteBuildLog_WhenDirectoryDoesNotExist_DirectoryCreated()
{
string dirName = "SomeTestDir";
string logFile = Path.Combine(dirName, "AddressablesBuildTEP.json");
try
{
BuildLog log = new BuildLog();
BuildScriptBase.WriteBuildLog(log, dirName);
FileAssert.Exists(logFile);
}
finally
{
Directory.Delete(dirName, true);
}
}
[Test]
public void Building_CreatesPerformanceReportWithMetaData()
{
Settings.BuildPlayerContentImpl();
string path = Addressables.LibraryPath + "AddressablesBuildTEP.json";
FileAssert.Exists(path);
string text = File.ReadAllText(path);
StringAssert.Contains("com.unity.addressables", text);
}
[Test]
public void Build_WithInvalidAssetInResourcesFolder_Succeeds()
{
var path = GetAssetPath("Resources/unknownAsset.plist");
if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(path)))
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(path));
System.IO.File.WriteAllText(path, "nothing");
AssetDatabase.ImportAsset(path);
var context = new AddressablesDataBuilderInput(Settings);
foreach (IDataBuilder db in Settings.DataBuilders)
if (db.CanBuildData<AddressablesPlayerBuildResult>())
db.BuildData<AddressablesPlayerBuildResult>(context);
}
[Test]
public void Build_GroupWithPlayerDataGroupSchemaAndBundledAssetGroupSchema_LogsError()
{
const string groupName = "NewGroup";
var schemas = new List<AddressableAssetGroupSchema> {ScriptableObject.CreateInstance<PlayerDataGroupSchema>(), ScriptableObject.CreateInstance<BundledAssetGroupSchema>()};
AddressableAssetGroup group = Settings.CreateGroup(groupName, false, false, false, schemas);
var context = new AddressablesDataBuilderInput(Settings);
foreach (IDataBuilder db in Settings.DataBuilders)
{
if (db.CanBuildData<AddressablesPlayerBuildResult>())
{
AddressablesPlayerBuildResult result = db.BuildData<AddressablesPlayerBuildResult>(context);
Assert.AreEqual(result.Error, $"Addressable group {groupName} cannot have both a {typeof(PlayerDataGroupSchema).Name} and a {typeof(BundledAssetGroupSchema).Name}");
}
}
Settings.RemoveGroup(group);
}
// ADDR-1755
[Test]
public void WhenBundleLocalCatalogEnabled_BuildScriptPacked_DoesNotCreatePerformanceLogReport()
{
string logPath = $"Library/com.unity.addressables/aa/{PlatformMappingService.GetPlatformPathSubFolder()}/buildlogtep.json";
if (File.Exists(logPath))
File.Delete(logPath);
Settings.BundleLocalCatalog = true;
var context = new AddressablesDataBuilderInput(Settings);
BuildScriptBase db = (BuildScriptBase)Settings.DataBuilders.Find(x => x.GetType() == typeof(BuildScriptPackedMode));
Assert.IsFalse(File.Exists(logPath)); // make sure file does not exist before build
var res = db.BuildData<AddressablesPlayerBuildResult>(context);
Assert.IsFalse(File.Exists(logPath));
}
[Test]
public void Build_WithDeletedAsset_Succeeds()
{
var context = new AddressablesDataBuilderInput(Settings);
//make an entry with no actual AssetPath
Settings.CreateOrMoveEntry("abcde", Settings.DefaultGroup);
Settings.CreateOrMoveEntry(m_AssetGUID, Settings.DefaultGroup);
foreach (BuildScriptBase db in Settings.DataBuilders.OfType<BuildScriptBase>())
{
if (db is BuildScriptPackedPlayMode)
continue;
if (db.CanBuildData<AddressablesPlayerBuildResult>())
{
var res = db.BuildData<AddressablesPlayerBuildResult>(context);
Assert.IsTrue(db.IsDataBuilt());
Assert.IsTrue(string.IsNullOrEmpty(res.Error));
}
else if (db.CanBuildData<AddressablesPlayModeBuildResult>())
{
var res = db.BuildData<AddressablesPlayModeBuildResult>(context);
Assert.IsTrue(db.IsDataBuilt());
Assert.IsTrue(string.IsNullOrEmpty(res.Error));
}
}
Settings.RemoveAssetEntry("abcde", false);
Settings.RemoveAssetEntry(m_AssetGUID, false);
}
[Test]
public void WhenAddressHasSquareBrackets_AndContentCatalogsAreCreated_BuildFails()
{
var context = new AddressablesDataBuilderInput(Settings);
AddressableAssetEntry entry = Settings.CreateOrMoveEntry(m_AssetGUID, Settings.DefaultGroup);
entry.address = "[test]";
LogAssert.Expect(LogType.Error, $"Address '{entry.address}' cannot contain '[ ]'.");
foreach (IDataBuilder db in Settings.DataBuilders)
{
if (db.GetType() == typeof(BuildScriptFastMode) || db.GetType() == typeof(BuildScriptPackedPlayMode))
continue;
if (db.CanBuildData<AddressablesPlayerBuildResult>())
db.BuildData<AddressablesPlayerBuildResult>(context);
else if (db.CanBuildData<AddressablesPlayModeBuildResult>())
db.BuildData<AddressablesPlayModeBuildResult>(context);
LogAssert.Expect(LogType.Error, "Address '[test]' cannot contain '[ ]'.");
}
Settings.RemoveAssetEntry(m_AssetGUID, false);
}
[Test]
public void WhenFileTypeIsInvalid_AndContentCatalogsAreCreated_BuildFails()
{
var context = new AddressablesDataBuilderInput(Settings);
string path = GetAssetPath("fake.file");
FileStream fs = File.Create(path);
fs.Close();
AssetDatabase.ImportAsset(path);
string guid = AssetDatabase.AssetPathToGUID(path);
AddressableAssetEntry entry = Settings.CreateOrMoveEntry(guid, Settings.DefaultGroup);
foreach (IDataBuilder db in Settings.DataBuilders)
{
if (db.GetType() == typeof(BuildScriptFastMode) ||
db.GetType() == typeof(BuildScriptPackedPlayMode))
continue;
if (db.CanBuildData<AddressablesPlayerBuildResult>())
db.BuildData<AddressablesPlayerBuildResult>(context);
else if (db.CanBuildData<AddressablesPlayModeBuildResult>())
db.BuildData<AddressablesPlayModeBuildResult>(context);
LogAssert.Expect(LogType.Error,
"Cannot recognize file type for entry located at 'Assets/UnityEditor.AddressableAssets.Tests.BuildScriptTests_Tests/fake.file'. Asset import failed for using an unsupported file type.");
}
Settings.RemoveAssetEntry(guid, false);
AssetDatabase.DeleteAsset(path);
}
[Test]
public void WhenFileTypeIsInvalid_AndContentCatalogsAreCreated_IgnoreUnsupportedFilesInBuildIsSet_BuildSucceedWithWarning()
{
bool oldValue = Settings.IgnoreUnsupportedFilesInBuild;
Settings.IgnoreUnsupportedFilesInBuild = true;
var context = new AddressablesDataBuilderInput(Settings);
string path = GetAssetPath("fake.file");
FileStream fs = File.Create(path);
fs.Close();
AssetDatabase.ImportAsset(path);
string guid = AssetDatabase.AssetPathToGUID(path);
AddressableAssetEntry entry = Settings.CreateOrMoveEntry(guid, Settings.DefaultGroup);
foreach (BuildScriptBase db in Settings.DataBuilders.OfType<BuildScriptBase>())
{
if (db.GetType() == typeof(BuildScriptFastMode) || db.GetType() == typeof(BuildScriptPackedPlayMode))
continue;
if (db.CanBuildData<AddressablesPlayerBuildResult>())
{
var res = db.BuildData<AddressablesPlayerBuildResult>(context);
Assert.IsTrue(db.IsDataBuilt());
Assert.IsTrue(string.IsNullOrEmpty(res.Error));
}
else if (db.CanBuildData<AddressablesPlayModeBuildResult>())
{
var res = db.BuildData<AddressablesPlayModeBuildResult>(context);
Assert.IsTrue(db.IsDataBuilt());
Assert.IsTrue(string.IsNullOrEmpty(res.Error));
}
LogAssert.Expect(LogType.Warning, new Regex($".*{path}.*ignored"));
LogAssert.Expect(LogType.Warning, new Regex($".*{path}.*stripped"));
}
Settings.RemoveAssetEntry(guid, false);
AssetDatabase.DeleteAsset(path);
Settings.IgnoreUnsupportedFilesInBuild = oldValue;
}
[Test]
public void WhenLoadPathUsesHttp_AndInsecureHttpNotAllowed_BuildLogsWarning()
{
#if UNITY_2022_1_OR_NEWER
InsecureHttpOption oldHttpOption = PlayerSettings.insecureHttpOption;
PlayerSettings.insecureHttpOption = InsecureHttpOption.NotAllowed;
string remoteLoadPathId = Settings.profileSettings.GetProfileDataByName(AddressableAssetSettings.kRemoteLoadPath).Id;
string oldRemoteLoadPath = Settings.profileSettings.GetValueById(Settings.activeProfileId, remoteLoadPathId);
Settings.profileSettings.SetValue(Settings.activeProfileId, AddressableAssetSettings.kRemoteLoadPath, "http://insecureconnection/");
AddressableAssetGroup assetGroup = Settings.CreateGroup("InsecureConnections", false, false, false, null, typeof(BundledAssetGroupSchema));
assetGroup.GetSchema<BundledAssetGroupSchema>().BuildPath.SetVariableById(Settings, Settings.profileSettings.GetProfileDataByName(AddressableAssetSettings.kRemoteBuildPath).Id);
assetGroup.GetSchema<BundledAssetGroupSchema>().LoadPath.SetVariableById(Settings, Settings.profileSettings.GetProfileDataByName(AddressableAssetSettings.kRemoteLoadPath).Id);
string assetPath = Path.Combine(TestFolder, "insecureConnectionsTest.prefab");
PrefabUtility.SaveAsPrefabAsset(new GameObject(), assetPath);
Settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(assetPath), assetGroup, false, false);
var context = new AddressablesDataBuilderInput(Settings);
BuildScriptBase db = (BuildScriptBase)Settings.DataBuilders.Find(x => x.GetType() == typeof(BuildScriptPackedMode));
db.BuildData<AddressablesPlayerBuildResult>(context);
LogAssert.Expect(LogType.Warning, $"Addressable group {assetGroup.Name} uses insecure http for its load path. To allow http connections for UnityWebRequests, change your settings in Edit > Project Settings > Player > Other Settings > Configuration > Allow downloads over HTTP.");
Settings.RemoveGroup(assetGroup);
Settings.profileSettings.SetValue(Settings.activeProfileId, AddressableAssetSettings.kRemoteLoadPath, oldRemoteLoadPath);
AssetDatabase.DeleteAsset(assetPath);
PlayerSettings.insecureHttpOption = oldHttpOption;
#else
Assert.Ignore($"Skipping test {nameof(WhenLoadPathUsesHttp_AndInsecureHttpNotAllowed_BuildLogsWarning)}.");
#endif
}
[Test]
public void WhenLoadPathUsesHttp_AndInsecureHttpAllowed_BuildSucceeds()
{
#if UNITY_2022_1_OR_NEWER
InsecureHttpOption oldHttpOption = PlayerSettings.insecureHttpOption;
PlayerSettings.insecureHttpOption = InsecureHttpOption.AlwaysAllowed;
string remoteLoadPathId = Settings.profileSettings.GetProfileDataByName(AddressableAssetSettings.kRemoteLoadPath).Id;
string oldRemoteLoadPath = Settings.profileSettings.GetValueById(Settings.activeProfileId, remoteLoadPathId);
Settings.profileSettings.SetValue(Settings.activeProfileId, AddressableAssetSettings.kRemoteLoadPath, "http://insecureconnection/");
AddressableAssetGroup assetGroup = Settings.CreateGroup("InsecureConnections", false, false, false, null, typeof(BundledAssetGroupSchema));
assetGroup.GetSchema<BundledAssetGroupSchema>().BuildPath.SetVariableById(Settings, Settings.profileSettings.GetProfileDataByName(AddressableAssetSettings.kRemoteBuildPath).Id);
assetGroup.GetSchema<BundledAssetGroupSchema>().LoadPath.SetVariableById(Settings, Settings.profileSettings.GetProfileDataByName(AddressableAssetSettings.kRemoteLoadPath).Id);
string assetPath = Path.Combine(TestFolder, "insecureConnectionsTest.prefab");
PrefabUtility.SaveAsPrefabAsset(new GameObject(), assetPath);
Settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(assetPath), assetGroup, false, false);
var context = new AddressablesDataBuilderInput(Settings);
BuildScriptBase db = (BuildScriptBase)Settings.DataBuilders.Find(x => x.GetType() == typeof(BuildScriptPackedMode));
db.BuildData<AddressablesPlayerBuildResult>(context);
LogAssert.NoUnexpectedReceived();
Settings.RemoveGroup(assetGroup);
Settings.profileSettings.SetValue(Settings.activeProfileId, AddressableAssetSettings.kRemoteLoadPath, oldRemoteLoadPath);
AssetDatabase.DeleteAsset(assetPath);
PlayerSettings.insecureHttpOption = oldHttpOption;
#else
Assert.Ignore($"Skipping test {nameof(WhenLoadPathUsesHttp_AndInsecureHttpAllowed_BuildSucceeds)}.");
#endif
}
}
}