public void Apply_Create_CanCreate()
        {
            // Set up services.
            var addressablesEditorService = new FakeAddressablesEditorAdapter();
            var assetDatabaseService      = new FakeAssetDatabaseAdapter();
            var service = new EntryOperationInfoApplyDomainService(addressablesEditorService, assetDatabaseService);

            // Set up test assets.
            const string address           = "dummyAddress";
            const string createdAssetPath  = "Assets/Prefabs/prefab_test.prefab";
            const string groupName         = "TestPrefabs";
            var          labels            = new[] { "DummyLabel1", "DummyLabel2" };
            var          groupTemplate     = ScriptableObject.CreateInstance <AddressableAssetGroupTemplate>();
            var          groupTemplateGuid =
                assetDatabaseService.CreateTestAsset("Assets/TestGroupTemplate.asset", groupTemplate);
            var assetGuid = assetDatabaseService.CreateTestAsset(createdAssetPath, new GameObject());

            // Test.
            var createOrMoveOperationInfo = new EntryCreateOrMoveOperationInfo(createdAssetPath, address,
                                                                               groupName, groupTemplateGuid, labels);
            var operationInfo = new EntryOperationInfo(createOrMoveOperationInfo, null);

            service.Apply(operationInfo);
            var group = addressablesEditorService.Groups.Values.First();
            var entry = group.Entries.First();

            Assert.That(group.Name, Is.EqualTo(groupName));
            Assert.That(entry.Guid, Is.EqualTo(assetGuid));
            Assert.That(entry.Address, Is.EqualTo(address));
            Assert.That(entry.Labels.Length, Is.EqualTo(2));
            Assert.That(entry.Labels, Contains.Item(labels[0]));
            Assert.That(entry.Labels, Contains.Item(labels[1]));
        }
        public void Apply_Remove_CanRemove()
        {
            // Set up services.
            var addressablesEditorService = new FakeAddressablesEditorAdapter();
            var assetDatabaseService      = new FakeAssetDatabaseAdapter();
            var service = new EntryOperationInfoApplyDomainService(addressablesEditorService, assetDatabaseService);

            // Set up test assets.
            const string groupName       = "BeforeGroup";
            var          beforeGroupInfo = addressablesEditorService.CreateGroup(groupName, false, false, false,
                                                                                 null, null);
            const string createdAssetPath = "Assets/Prefabs/prefab_test.prefab";
            var          groupTemplate    = ScriptableObject.CreateInstance <AddressableAssetGroupTemplate>();

            assetDatabaseService.CreateTestAsset("Assets/TestGroupTemplate.asset", groupTemplate);
            var assetGuid = assetDatabaseService.CreateTestAsset(createdAssetPath, new GameObject());

            addressablesEditorService.CreateOrMoveEntry(assetGuid, beforeGroupInfo.Guid);
            var beforeGroup = addressablesEditorService.Groups.Values.First(x => x.Name.Equals(groupName));

            Assert.That(beforeGroup.Entries.Count, Is.EqualTo(1));

            // Test.
            var removeOperationInfo = new EntryRemoveOperationInfo(createdAssetPath);
            var operationInfo       = new EntryOperationInfo(null, removeOperationInfo);

            service.Apply(operationInfo);
            Assert.That(beforeGroup.Entries.Count, Is.Zero);
            Assert.That(addressablesEditorService.Groups.Count, Is.Zero);
        }
        public void BuildEntryCreateOrMoveInfoByRules_ExistsMatchedRule_BuildInfoCorrectly()
        {
            // Set up.
            var          dummyFolderPath    = $"Assets/{Paths.GetAddressablesFolderName()}";
            var          dummyAssetPath     = $"{dummyFolderPath}/Prefabs/prefab_dummy_0001.prefab";
            const string dummyAssetFileName = "prefab_dummy_0001.prefab";
            var          rule = new EntryRule();

            rule.SetAddressablePathRule(@"Prefabs/prefab_dummy_(?<id>[0-9]{4})\.prefab");
            rule.SetAddressingMode(AddressingMode.AssetName);
            rule.SetGroupNameRule("Group_${id}");
            var rules = new EntryRuleSet();

            rules.Add(rule);
            var assetDatabaseAdapter  = new FakeAssetDatabaseAdapter();
            var addressableFolderGuid = assetDatabaseAdapter.CreateTestAsset(dummyFolderPath, new Object());
            var service = CreateBuildService(assetDatabaseAdapter);

            // Test.
            var entryOperationInfo = service.BuildEntryCreateOrMoveInfoByRules(dummyAssetPath, rules,
                                                                               addressableFolderGuid);

            Assert.That(entryOperationInfo.AssetPath, Is.EqualTo(dummyAssetPath));
            Assert.That(entryOperationInfo.Address, Is.EqualTo(dummyAssetFileName));
        }
        public void BuildEntryCreateOrMoveInfo_NoRulesMatched_UseDefault()
        {
            // Set up.
            var          dummyFolderPath       = $"Assets/{Paths.GetAddressablesFolderName()}";
            var          dummyAssetPath        = $"{dummyFolderPath}/Prefabs/prefab_dummy_0001.prefab";
            const string address               = "prefab_dummy_0001.prefab";
            var          assetDatabaseAdapter  = new FakeAssetDatabaseAdapter();
            var          addressableFolderGuid = assetDatabaseAdapter.CreateTestAsset(dummyFolderPath, new Object());
            var          service               = CreateBuildService(assetDatabaseAdapter);
            var          addressingMode        = AddressingMode.AssetName;
            var          packingMode           = PackingMode.PackTogether;
            var          rule = new EntryRule();

            rule.SetAddressablePathRule(@"__Prefabs/prefab_dummy_(?<id>[0-9]{4})\.prefab");
            rule.SetAddressingMode(AddressingMode.AssetName);
            rule.SetGroupNameRule("Group_${id}");
            var rules = new EntryRuleSet();

            rules.Add(rule);

            // Test.
            var entryOperationInfo = service.BuildEntryCreateOrMoveInfo(dummyAssetPath, addressingMode, packingMode,
                                                                        addressableFolderGuid, rules);

            Assert.That(entryOperationInfo.AssetPath, Is.EqualTo(dummyAssetPath));
            Assert.That(entryOperationInfo.Address, Is.EqualTo(address));
        }
Example #5
0
        public void GenerateFromAssetPath_PackByAddressablesFolder_NestedFolder_Generated()
        {
            var folderPath               = "Assets/Dummy/Addressables/Dummy/Addressables";
            var assetPath                = $"{folderPath}/Dummy/Test.prefab";
            var assetDatabaseService     = new FakeAssetDatabaseAdapter();
            var folderGuid               = assetDatabaseService.CreateTestAsset(folderPath, new Object());
            var groupNameGenerateService = CreateGroupNameGenerateDomainService(assetDatabaseService);
            var groupName                = groupNameGenerateService.GenerateFromAssetPath(assetPath, PackingMode.PackByAddressablesFolder);

            Assert.That(groupName, Is.EqualTo($"{Paths.GetDefaultGroupName()}_{folderGuid.Substring(0, 7)}"));
        }
Example #6
0
        public void GenerateFromAssetPath_PackByAddressablesFolder_NotAssetsFolder_ReturnEmpty()
        {
            var folderPath           = "NotAssets/Dummy/Addressables";
            var assetPath            = $"{folderPath}/Dummy/Test.prefab";
            var assetDatabaseService = new FakeAssetDatabaseAdapter();

            assetDatabaseService.CreateTestAsset(folderPath, new Object());
            var groupNameGenerateService = CreateGroupNameGenerateDomainService(assetDatabaseService);
            var groupName = groupNameGenerateService.GenerateFromAssetPath(assetPath, PackingMode.PackByAddressablesFolder);

            Assert.That(groupName, Is.EqualTo(string.Empty));
        }
        public void BuildEntryCreateOrMoveInfo_PackingModeIsPackTogether_SetCorrectly()
        {
            // Set up.
            var dummyFolderPath       = $"Assets/{Paths.GetAddressablesFolderName()}";
            var dummyAssetPath        = $"{dummyFolderPath}/Prefabs/prefab_dummy_0001.prefab";
            var assetDatabaseAdapter  = new FakeAssetDatabaseAdapter();
            var addressableFolderGuid = assetDatabaseAdapter.CreateTestAsset(dummyFolderPath, new Object());
            var service        = CreateBuildService(assetDatabaseAdapter);
            var addressingMode = AddressingMode.AssetName;
            var packingMode    = PackingMode.PackTogether;

            // Test.
            var entryOperationInfo = service.BuildEntryCreateOrMoveInfo(dummyAssetPath, addressingMode, packingMode,
                                                                        addressableFolderGuid, null);

            Assert.That(entryOperationInfo.AssetPath, Is.EqualTo(dummyAssetPath));
            Assert.That(entryOperationInfo.GroupName, Is.EqualTo(Paths.GetDefaultGroupName()));
        }
        public void BuildEntryCreateOrMoveInfoByRule_RuleIsNotMatched_ReturnNull()
        {
            // Set up.
            var dummyFolderPath = $"Assets/{Paths.GetAddressablesFolderName()}";
            var dummyAssetPath  = $"{dummyFolderPath}/Prefabs/prefab_dummy_0001.prefab";
            var rule            = new EntryRule();

            rule.SetAddressablePathRule(@"___prefab_dummy_(?<id>[0-9]{4})\.prefab");
            rule.SetAddressingMode(AddressingMode.AssetName);
            rule.SetGroupNameRule("Group_${id}");
            var assetDatabaseAdapter  = new FakeAssetDatabaseAdapter();
            var addressableFolderGuid = assetDatabaseAdapter.CreateTestAsset(dummyFolderPath, new Object());
            var service = CreateBuildService(assetDatabaseAdapter);

            // Test.
            var entryOperationInfo = service.BuildEntryCreateOrMoveInfoByRule(dummyAssetPath, rule,
                                                                              addressableFolderGuid);

            Assert.That(entryOperationInfo, Is.Null);
        }
        public void BuildEntryCreateOrMoveInfoByRule_SetGroupTemplateGuid_ReflectedCorrectly()
        {
            // Set up.
            var dummyFolderPath = $"Assets/{Paths.GetAddressablesFolderName()}";
            var dummyAssetPath  = $"{dummyFolderPath}/Prefabs/prefab_dummy_0001.prefab";
            var rule            = new EntryRule();

            rule.SetAddressablePathRule(@"Prefabs/prefab_dummy_(?<id>[0-9]{4})\.prefab");
            rule.SetAddressingMode(AddressingMode.AddressablePath);
            rule.SetGroupNameRule("Group_${id}");
            var assetDatabaseAdapter  = new FakeAssetDatabaseAdapter();
            var addressableFolderGuid = assetDatabaseAdapter.CreateTestAsset(dummyFolderPath, new Object());
            var service = CreateBuildService(assetDatabaseAdapter);

            // Test.
            var entryOperationInfo = service.BuildEntryCreateOrMoveInfoByRule(dummyAssetPath, rule,
                                                                              addressableFolderGuid);

            Assert.That(entryOperationInfo.AssetPath, Is.EqualTo(dummyAssetPath));
            Assert.That(entryOperationInfo.GroupTemplateGuid, Is.EqualTo(addressableFolderGuid));
        }