public void TestValidateError()
{
var rule = new AssetExtentionBlacklistRule("拡張子テスト", new string[] { "TXT", ".prefab", ".Fbx" });
var path = "Assets/VitDeck/Validator/Tests/Data/A04_AssetExtentionBlacklistRule/TestData.txt";
var folderPath = "Assets/VitDeck/Validator/Tests/Data/A04_AssetExtentionBlacklistRule/test.txt";
var targetPaths = new string[] {
path,
folderPath,
"Assets/VitDeck/Validator/Tests/test dummy data.prefab",
"Assets/VitDeck/Validator/Tests/test dummy data.fake.FBX",
"Assets/VitDeck/Validator/Tests/test_dummy_OK.fbx2"
};
var target = new ValidationTarget("Assets/VitDeck/Validator/Tests", assetPaths: targetPaths);
var result = rule.Validate(target);
Assert.That(result.Issues.Count, Is.EqualTo(3));
var issue = result.Issues[0];
Assert.That(issue.level, Is.EqualTo(IssueLevel.Error));
Assert.That(issue.target, Is.EqualTo(AssetDatabase.LoadMainAssetAtPath(path)));
var expectedMessage = string.Format("拡張子が`{0}`のアセットが検出されました。", Path.GetExtension(path)) + Environment.NewLine + path;
Assert.That(issue.message, Is.EqualTo(expectedMessage));
Assert.That(issue.solution, Is.Empty);
Assert.That(issue.solutionURL, Is.Empty);
}
public void AddError_CreatesAndAddsCorrectError()
{
var target = new EmployeeVM();
var validator = Mock <IValidator>();
var message = "Test error message";
var details = new Object();
var args = CreateArgs(target, target, validator);
args.AddError(message, details);
var expectedError = new ValidationError(
validator,
ValidationTarget.ForError(
ValidationStep.ViewModel,
target,
null,
null
),
message,
details
);
ValidationAssert.HasErrors(args.Result, ValidationAssert.FullErrorComparer, expectedError);
}
public void AddError_ArgsWithProperty_CreatesAndAddsCorrectError()
{
var item = new EmployeeVM();
var owner = new EmployeeListVM(item);
var validator = Mock <IValidator>();
var step = ValidationStep.Value;
var message = "Test error message";
var details = new Object();
var args = CreateArgsWithProperty(owner, step, validator);
args.AddError(item, message, details);
var expectedError = new ValidationError(
validator,
ValidationTarget.ForError(
step,
item,
owner.GetValue(x => x.Employees),
EmployeeVM.ClassDescriptor.Name
),
message,
details
);
ValidationAssert.HasErrors(args.Result, ValidationAssert.FullErrorComparer, expectedError);
}
public async Task Validate_TwoAccounts(bool valid, string email1, string email2)
{
using (var provider = await CreateProvider())
{
var access = provider.GetRequiredService <IContextLock>();
var context = provider.GetRequiredService <IContext>();
var accounts = provider.GetRequiredService <IAccountRepository>();
IValidator <Account> validator = new AccountValidator(accounts);
using (var handle = await access.Write())
{
var one = new Account {
Email = new EmailAddress(email1)
};
context.Add(one);
await handle.Finish();
}
using (await access.Read())
{
var two = new Account {
Email = new EmailAddress(email2)
};
var target = new ValidationTarget <Account>(two);
validator.Validate(target);
Assert.Equal(valid, !target.GetResult().HasErrors);
}
}
}
public void TestValidationtarget()
{
var baseFolderPath = "Assets/VitDeck/Validator/Tests";
var assetGuids = new string[] { "testguid" };
var assetPaths = new string[] { "testPath", "testPath2" };
var assetObjects = new Object[] { };
var scenes = new Scene[] { new Scene() };
var rootObjects = new GameObject[] { };
var allObjects = new GameObject[] { };
var target = new ValidationTarget(baseFolderPath,
assetGuids,
assetPaths,
assetObjects,
scenes,
rootObjects,
allObjects);
Assert.That(target.GetBaseFolderPath(), Is.EqualTo(baseFolderPath));
Assert.That(target.GetAllAssetGuids(), Is.EqualTo(assetGuids));
Assert.That(target.GetAllAssetPaths(), Is.EqualTo(assetPaths));
Assert.That(target.GetAllAssets(), Is.EqualTo(assetObjects));
Assert.That(target.GetScenes(), Is.EqualTo(scenes));
Assert.That(target.GetRootObjects(), Is.EqualTo(rootObjects));
Assert.That(target.GetAllObjects(), Is.EqualTo(allObjects));
}
public void TearDown()
{
foreach (var gameObject in targetContainer.GetAllObjects())
{
Object.DestroyImmediate(gameObject);
}
targetContainer = null;
}
public IValidationErrorTarget GetValidationTarget()
{
return(ValidationTarget.ForError(
Step,
TargetVM,
TargetCollection,
TargetProperty
));
}
public void TestValidateNoAsset()
{
var rule = new AssetNamingRule("アセット名使用禁止文字検出", "^[\x21-\x7e]+$");
var target = new ValidationTarget("Assets/VitDeck/Validator/Tests", assetPaths: new string[] { });
var result = rule.Validate(target);
Assert.That(result.RuleName, Is.EqualTo("アセット名使用禁止文字検出"));
Assert.That(result.Issues.Count, Is.EqualTo(0));
}
public void TestValidate()
{
var rule = new AssetExtentionBlacklistRule("拡張子テスト", new string[] { "TXT", ".prefab", ".FBX" });
var target = new ValidationTarget("Assets/VitDeck/Validator/Tests", assetPaths: new string[] { });
var result = rule.Validate(target);
Assert.That(result.RuleName, Is.EqualTo("拡張子テスト"));
Assert.That(result.Issues.Count, Is.EqualTo(0));
}
public void Invalid(string value)
{
IValidator <Name> validator = new NameValidator();
var target = new ValidationTarget <Name>(new Name(value));
validator.Validate(target);
Assert.True(target.GetResult().HasErrors);
}
public void Invalid(string value)
{
IValidator <EmailAddress> validator = new EmailAddressValidator();
var target = new ValidationTarget <EmailAddress>(new EmailAddress(value));
validator.Validate(target);
Assert.True(target.GetResult().HasErrors);
}
public void TestValidate()
{
var rule = new SampleRule("サンプルルール");
var target = new ValidationTarget("Assets/VitDeck/Validator/Tests/SampleRule");
var result = rule.Validate(target);
Assert.That(result.RuleName, Is.EqualTo("サンプルルール"));
Assert.That(result.Issues.Count, Is.AtLeast(1));
}
public void Invalid(string value)
{
IValidator <Identifier> validator = new IdentifierValidator();
var target = new ValidationTarget <Identifier>(new Identifier(value));
validator.Validate(target);
Assert.True(target.GetResult().HasErrors);
}
public void TestValidateNoTargets()
{
var version = UnityEngine.Application.unityVersion;
var rule = new AssetPathLengthRule("アセットパス長制限テスト");
var target = new ValidationTarget("Assets/VitDeck/Validator/Tests", assetPaths: new string[] { });
var result = rule.Validate(target);
Assert.That(result.RuleName, Is.EqualTo("アセットパス長制限テスト"));
Assert.That(result.Issues.Count, Is.EqualTo(0));
}
public void TestValidate()
{
var version = UnityEngine.Application.unityVersion;
var rule = new UnityVersionRule("Unityバージョンテスト", version);
var target = new ValidationTarget("Assets/VitDeck/Validator/Tests");
var result = rule.Validate(target);
Assert.That(result.RuleName, Is.EqualTo("Unityバージョンテスト"));
Assert.That(result.Issues.Count, Is.EqualTo(0));
}
public ValidationError For(IViewModel targetVM)
{
var target = ValidationTarget.ForError(
ValidationStep.ViewModel,
targetVM,
null,
null
);
return(new ValidationError(NullValidator.Instance, target, _errorMessage));
}
public void ParentObjectControlTest()
{
var targetClip = AssetDatabase.LoadAssetAtPath <AnimationClip>(BaseFolder + "/TestParentItemAnimation.anim");
var validationTarget = new ValidationTarget(BaseFolder, assetObjects: new Object[] { targetClip });
var issues = new AnimationClipRule("").Validate(validationTarget).Issues;
Assert.That(issues.Count, Is.EqualTo(1));
Assert.That(issues[0].level, Is.EqualTo(IssueLevel.Error));
Assert.That(issues[0].target, Is.EqualTo(targetClip));
}
private void Validate <T>(bool success, T value)
{
IValidator <T> validator = new RequiredValidator <T>();
var target = new ValidationTarget <T>(value);
validator.Validate(target);
var result = target.GetResult();
Assert.Equal(success, !result.HasErrors);
}
public void TestValidate()
{
long limit = 5000;
var rule = new FolderSizeRule("入稿サイズテスト", limit);
var target = new ValidationTarget("Assets/VitDeck/Validator/Tests/Data/FolderSizeRule");
var result = rule.Validate(target);
Assert.That(result.RuleName, Is.EqualTo("入稿サイズテスト"));
Assert.That(result.Issues.Count, Is.EqualTo(0));
}
public void TestValidateMatches(string matchPattern, string assetPath, string matchChars)
{
var targetAssetPath = assetPath;
var targetAssetPaths = new string[] { targetAssetPath };
var pattern = matchPattern;
var rule = new AssetNamingRule("マッチ文字列テスト", pattern);
var target = new ValidationTarget("Assets/VitDeck/Validator/Tests", assetPaths: targetAssetPaths);
var result = rule.Validate(target);
Assert.That(result.Issues.Count, Is.EqualTo(1));
Assert.That(result.Issues[0].message, Is.EqualTo(string.Format("アセット名({0})に使用禁止文字({1})が含まれています。", assetPath, matchChars)));
}
public void TestValidateError()
{
long limit = 1000;
var rule = new FolderSizeRule("入稿サイズテスト", limit);
var target = new ValidationTarget("Assets/VitDeck/Validator/Tests/Data/FolderSizeRule");
var result = rule.Validate(target);
Assert.That(result.RuleName, Is.EqualTo("入稿サイズテスト"));
Assert.That(result.Issues.Count, Is.EqualTo(1));
Assert.That(result.Issues[0].level, Is.EqualTo(IssueLevel.Error));
Assert.That(result.Issues[0].target.name, Is.EqualTo("FolderSizeRule"));
}
public void TestValidateCorrectAssetName(string matchPattern, string assetPath)
{
var targetAssetPath = assetPath;
var targetAssetPaths = new string[] { targetAssetPath };
var pattern = matchPattern;
var rule = new AssetNamingRule("アセット名使用禁止文字検出", pattern);
var target = new ValidationTarget("Assets/VitDeck/Validator/Tests", assetPaths: targetAssetPaths);
var result = rule.Validate(target);
Assert.That(result.RuleName, Is.EqualTo("アセット名使用禁止文字検出"));
Assert.That(result.Issues.Count, Is.EqualTo(0));
}
public void OnSetValueModeTest()
{
using (var session = Domain.OpenSession()) {
using (var t = session.OpenTransaction()) {
var target = new ValidationTarget();
target.Name = "name";
target.Description = "blah";
AssertEx.Throws <ArgumentException>(() => target.Name = null);
AssertEx.Throws <ArgumentException>(() => target.Name = string.Empty);
AssertEx.Throws <ArgumentException>(() => target.Description = null);
AssertEx.Throws <ArgumentException>(() => target.Description = string.Empty);
}
}
}
public async Task Validate(bool shouldContinue, EntityState state)
{
using (var provider = await CreateProvider())
{
var validator = provider.GetRequiredService <IValidator <BaseEntity> >();
var entries = provider.GetRequiredService <FakeEntryRepository>();
var entity = new FakeEntity();
entries.State = state;
var target = new ValidationTarget <BaseEntity>(entity);
validator.Validate(target);
Assert.Equal(shouldContinue, target.Continue);
}
}
public void TestValidateError()
{
var version = UnityEngine.Application.unityVersion;
var rule = new UnityVersionRule("Unityバージョンテスト", "invalidVersion");
var target = new ValidationTarget("Assets/VitDeck/Validator/Tests");
var result = rule.Validate(target);
Assert.That(result.RuleName, Is.EqualTo("Unityバージョンテスト"));
Assert.That(result.Issues.Count, Is.EqualTo(1));
Assert.That(result.Issues[0].target, Is.EqualTo(null));
Assert.That(result.Issues[0].level, Is.EqualTo(IssueLevel.Error));
//Assert.That(result.Issues[0].message, Is.EqualTo(string.Format("実行中のUnityのバージョン({0})が指定されたバージョンと異なっています。", version)));
//Assert.That(result.Issues[0].solution, Is.EqualTo(string.Format("バージョン({0})を使用してください。", "invalidVersion")));
Assert.That(result.Issues[0].solutionURL, Is.EqualTo(""));
}
public void SetUp()
{
var targetObjects = new GameObject[]
{
CreateSimpleGameObject("TestTargetObject0", true, Vector3.zero),
CreateSimpleGameObject("TestTargetObject1", true, new Vector3(1, 0, 0)),
CreateSimpleGameObject("TestTargetObject2", false, new Vector3(1000, 0, 0)),
CreateRendererGameObject("TestTargetObject3", true, new Vector3(0, 1, 0), new Vector3(2, 2, 2)),
CreateRendererGameObject("TestTargetObject4", false, new Vector3(0, 100, 0), new Vector3(200, 200, 200)),
CreateRectGameObject("TestTargetObject5", true, new Vector3(0, 1, 0), new Vector2(2, 2)),
CreateRectGameObject("TestTargetObject6", false, new Vector3(1000, 1, 0), new Vector2(2, 2)),
};
targetContainer = new ValidationTarget("Assets/VitDeck/Validator/Tests", allObjects: targetObjects);
}
public void Validate_Recipients(bool valid, EmailRecipient[] recipients)
{
IValidator <Email> validator = new EmailValidator();
var email = new Email {
IsSent = false,
Sent = null,
Recipients = new HashSet <EmailRecipient>(recipients)
};
var target = new ValidationTarget <Email>(email);
validator.Validate(target);
Assert.Equal(valid, !target.GetResult().HasErrors);
}
public bool Validate(ValidationTarget targetName, object targetValue)
{
List <ValidationRule> targetValidationRules = validationRulesMap[targetName];
bool valid = true;
foreach (var rule in targetValidationRules)
{
valid = rule.InvokeValidation(targetValue);
if (!valid)
{
return(!valid);
}
}
return(valid);
}
private void OnRequestToValidate(ValidationTarget target)
{
if (target == ValidationTarget.Cache)
{
_ValidateCache();
}
else if (target == ValidationTarget.Remote)
{
_ValidateRemote();
}
else
{
_ValidateCache();
_ValidateRemote();
}
}
public ValidationError For <T>(
IViewModel <T> targetVM,
Func <T, IVMPropertyDescriptor> targetPropertySelector
) where T : IVMDescriptor
{
var targetProperty = targetPropertySelector((T)targetVM.Descriptor);
var target = ValidationTarget.ForError(
ValidationStep.ViewModel,
targetVM,
null,
targetProperty
);
return(new ValidationError(NullValidator.Instance, target, _errorMessage));
}
