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));
}
public void SetLabelRules_CanSet()
{
const string dummyLabelRules = "DummyLabel1,DummyLabel2";
var rule = new EntryRule();
rule.SetLabelRules(dummyLabelRules);
Assert.That(rule.LabelRules.Value, Is.EqualTo(dummyLabelRules));
}
/**
* @param index the bar index
* @param tradingRecord the potentially needed trading history
* @return true to recommend to enter, false otherwise
*/
public bool ShouldEnter(int index, ITradingRecord tradingRecord)
{
if (IsUnstableAt(index))
{
return(false);
}
return(EntryRule.IsSatisfied(index, tradingRecord));
}
public void SetAddressingMode_CanSet()
{
const AddressingMode dummyAddressingMode = AddressingMode.AddressablePath;
var rule = new EntryRule();
rule.SetAddressingMode(dummyAddressingMode);
Assert.That(rule.AddressingMode.Value, Is.EqualTo(dummyAddressingMode));
}
public void SetAssetRelativePathRule_SetInvalidRule_CanSetAndIsInvalid()
{
const string dummyAssetPathRule = @"Dummy/(?<id>[0-9]{4}\.prefab";
var rule = new EntryRule();
rule.SetAddressablePathRule(dummyAssetPathRule);
Assert.That(rule.AddressablePathRule.Value, Is.EqualTo(dummyAssetPathRule));
Assert.That(rule.ValidateAddressablePathRule(out _), Is.False);
}
public void SetGroupNameRule_SetInvalidRule_CanSetAndIsInvalid()
{
const string dummyGroupNameRule = "";
var rule = new EntryRule();
rule.SetGroupNameRule(dummyGroupNameRule);
Assert.That(rule.GroupNameRule.Value, Is.EqualTo(dummyGroupNameRule));
Assert.That(rule.ValidateGroupNameRule(out _), Is.False);
}
public void ValidateLabelRules_ContainsEmpty_ReturnFalse()
{
// Set up.
var rule = new EntryRule();
rule.SetLabelRules("DummyLabel1,");
// Test.
var result = rule.ValidateLabelRules(out _);
Assert.That(result, Is.False);
}
public void ValidateLabelRules_Empty_ReturnTrue()
{
// Set up.
var rule = new EntryRule();
rule.SetLabelRules("");
// Test.
var result = rule.ValidateLabelRules(out _);
Assert.That(result, Is.True);
}
public void ValidateGroupNameRule_Empty_ReturnFalse()
{
// Set up.
var rule = new EntryRule();
rule.SetGroupNameRule("");
// Test.
var result = rule.ValidateGroupNameRule(out _);
Assert.That(result, Is.False);
}
public void ValidateAssetPathRule_Empty_ReturnFalse()
{
// Set up.
var rule = new EntryRule();
rule.SetAddressablePathRule(string.Empty);
// Test.
var result = rule.ValidateAddressablePathRule(out _);
Assert.That(result, Is.False);
}
public void ValidateLabelRules_TwoLabels_ReturnTrue()
{
// Set up.
var rule = new EntryRule();
rule.SetLabelRules("DummyLabel1,DummyLabel2");
// Test.
var result = rule.ValidateLabelRules(out _);
Assert.That(result, Is.True);
}
public void ValidateGroupNameRule_ValidGroupNameRule_ReturnTrue()
{
// Set up.
const string dummyGroupNameRule = "Dummy{id}";
var rule = new EntryRule();
rule.SetGroupNameRule(dummyGroupNameRule);
// Test.
var result = rule.ValidateGroupNameRule(out _);
Assert.That(result, Is.True);
}
public ReadOnlyEntryRule AddRule(EntryRuleUpdateCommand?command = null)
{
var entryRule = new EntryRule();
if (command.HasValue)
{
UpdateRuleInternal(entryRule, command.Value);
}
_entryRulesStore.State.Add(entryRule);
_entryRulesStore.MarkAsDirty();
return(entryRule.ToReadOnly());
}
public void ValidateAssetRelativePathRule_ValidAssetPathRule_ReturnTrue()
{
// Set up.
const string dummyAssetPathRule = @"Dummy/(?<id>[0-9]{4})\.prefab";
var rule = new EntryRule();
rule.SetAddressablePathRule(dummyAssetPathRule);
// Test.
var result = rule.ValidateAddressablePathRule(out _);
Assert.That(result, Is.True);
}
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));
}
private void UpdateRuleInternal(EntryRule entryRule, EntryRuleUpdateCommand command)
{
if (command.AddressablePathRule != null)
{
entryRule.SetAddressablePathRule(command.AddressablePathRule);
}
if (command.AddressingMode.HasValue)
{
entryRule.SetAddressingMode(command.AddressingMode.Value);
}
if (command.GroupNameRule != null)
{
entryRule.SetGroupNameRule(command.GroupNameRule);
}
if (command.LabelRules != null)
{
entryRule.SetLabelRules(command.LabelRules);
}
}
public void AddEntryRule(EntryRule rule)
{
_entryRule += rule;
}
/// <summary>
/// Build <see cref="EntryCreateOrMoveOperationInfo" /> using <see cref="EntryRule" />.
/// </summary>
/// <param name="assetPath"></param>
/// <param name="rule"></param>
/// <param name="groupTemplateGuid"></param>
/// <returns></returns>
public EntryCreateOrMoveOperationInfo BuildEntryCreateOrMoveInfoByRule(string assetPath, EntryRule rule,
string groupTemplateGuid)
{
Assert.IsNotNull(rule);
Assert.IsFalse(string.IsNullOrEmpty(assetPath));
Assert.IsFalse(string.IsNullOrEmpty(_assetDatabaseAdapter.GUIDToAssetPath(groupTemplateGuid)));
// Do not process the folder.
if (Directory.Exists(assetPath))
{
return(null);
}
// Do not process the invalid rule.
if (!rule.Validate(out _))
{
return(null);
}
var addressablePath = _addressablePathGenerateService.GenerateFromAssetPath(assetPath);
var regex = new Regex(rule.AddressablePathRule.Value);
var match = regex.Match(addressablePath);
if (!match.Success)
{
return(null);
}
var address = _addressGenerateDomainService.GenerateFromAddressablePath(addressablePath,
rule.AddressingMode.Value);
var groupName = regex.Replace(addressablePath, rule.GroupNameRule.Value);
// Replace '/' to '-'
groupName = groupName.Replace("/", "-");
var labels = new List <string>();
if (rule.LabelRules.Value != null && rule.LabelRules.Value.Length >= 1)
{
var labelRules = rule.LabelRules.Value.Split(',');
foreach (var labelRule in labelRules)
{
if (string.IsNullOrEmpty(labelRule))
{
continue;
}
var label = regex.Replace(addressablePath, labelRule);
labels.Add(label);
}
}
var createOrMoveOperationInfo =
new EntryCreateOrMoveOperationInfo(assetPath, address, groupName, groupTemplateGuid, labels.ToArray());
return(createOrMoveOperationInfo);
}
public Coordinate GetNextEntryPosition <T>(T entryItem)
{
return(EntryRule.GetNextEntryPosition(entryItem));
}
