protected IUndoableEdit RemoveInvalidCombinations(IEnumerable <IList <EquivalenceClass> > patterns) { CompoundEdit ce = new CompoundEdit(); IPolicyFactory fact = new PolicyFactory(); //patterns.Equals() List <Combination> combinations = new List <Combination>(parentDependency.Combinations); foreach (IList <EquivalenceClass> list in patterns) { HashedSet <EquivalenceClass> eqSet = new HashedSet <EquivalenceClass>(list); foreach (Combination combination in parentDependency.Combinations) { HashedSet <EquivalenceClass> combiEqSet = new HashedSet <EquivalenceClass>(combination.EquivalenceClasses); if (eqSet.Equals(combiEqSet)) { combinations.Remove(combination); } } } foreach (Combination combination in combinations) { ce.AddEdit(fact.DeleteCombinationPolicy(combination, parentDependency.ParentStructure)); parentDependency.RemoveCombination(combination); } return(ce); }
public void Test1() { PolicyFactory factory = new PolicyFactory(); Assert.Null(factory.PolicyConfigsFun); Assert.Null(factory.SortIndexsFun); }
public PasswordPolicyVerifierTests() { var factory = new PolicyFactory(); var provider = new PasswordPolicyProvider(factory); _verifier = new PasswordPolicyVerifier(provider); }
public virtual IUndoableEdit Generate() { ValidateModel(); CompoundEdit ce = new CompoundEdit(); IPolicyFactory pfact = new PolicyFactory(); IList <TestCase> generatedTestCases = new List <TestCase>(); //generate the test cases ce.AddEdit(FillTestCases(generatedTestCases)); //delete the common test cases from the structure ce.AddEdit(pfact.DeleteCommonTestCasesPolicy(structure, genState, dependencies)); if (generatedTestCases.Count + structure.GetTestCases(genState).Count > maxTestCases) { ce.EndAllEdits(); ce.Undo(); throw new Exception("Maximal number of " + EntityWithEvents.GetDescription(genState) + " Test Cases reached"); } //add the new generated test cases foreach (TestCase tc in generatedTestCases) { //check if the structure has the same test cases before insert if (!structure.ContainsSameTestCaseByRelations(tc)) { ce.AddEdit(EditFactory.instance.CreateChangePropertyEdit(tc, "Position", structure.GetNewTestCasePosition())); tc.Position = structure.GetNewTestCasePosition(); ce.AddEdit(EditFactory.instance.CreateAddTestCaseEdit(structure, tc)); structure.AddTestCase(tc); } } return(ce); }
public void GetSyncPolicyConfigsTest() { var type = typeof(PolicyFactory); PolicyFactory factory = new PolicyFactory(); string methodName = "GetSyncPolicyConfigs"; List <IPolicyConfig> policies = new List <IPolicyConfig>(); var configs = (ISyncPolicy)Helper.RunInstanceMethod(type, methodName, factory, new object[1] { null }); Assert.Null(configs); policies.Add(new RetryPolicy()); var configs2 = (ISyncPolicy)Helper.RunInstanceMethod(type, methodName, factory, new object[1] { policies }); Assert.Null(configs2); policies.Add(new RetryPolicy(5)); var configs3 = (ISyncPolicy)Helper.RunInstanceMethod(type, methodName, factory, new object[1] { policies }); Assert.NotNull(configs3); }
public void CannotTerminateTerminatedPolicy() { var policy = PolicyFactory.AlreadyTerminatedPolicy(); Exception ex = Throws <ApplicationException>(() => policy.Terminate(DateTime.Now)); Equal($"Policy {policy.Number} is already terminated", ex.Message); }
public void IsValidRenderer() { var renderer = RendererFactory.DefaultRenderer(PolicyFactory.DefaultSelectionPolicy()); var childLinks = renderer.FindChildLinks(new UrlQueueItem { Url = "https://www.monzo.com" }); Assert.NotNull(childLinks); }
public void GetPolicyTest_ShouldSucceed() { var factory = new PolicyFactory(); var provider = new PasswordPolicyProvider(factory); var result = provider.GetPolicies(); Assert.NotNull(result); Assert.True(result.Any()); }
public ResilientHttpClient( PolicyFactory policyFactory, IHttpContextAccessor accessor ) { _policyFactory = policyFactory; _standardHttpClient = new StandardHttpClient(accessor); }
public Task <TOut> Handle(TIn request, CancellationToken cancellationToken) { var fallbackPolicy = Policy <TOut> .Handle <Exception>() .FallbackAsync(GetFromCache); var fallbackAfterCircuitbreaker = fallbackPolicy.WrapAsync(PolicyFactory.CircuitbreakerPolicy()); return(fallbackAfterCircuitbreaker.ExecuteAsync(() => decoratee.Handle(request, cancellationToken))); }
public EncryptionViewModel() { _encryptorCache = new MemoryCache(); _policyCache = new MemoryCache(); var policyFactory = new PolicyFactory(_policyCache, new PolicyStore(new FileStore(@"c:\\Documents\Testing\EncryptionSample\Policies")), new EncryptionPolicy(), new TimeSpan(0, 5, 0)); var keyFactory = new KeyFactory(new BlobKeyStore(new FileStore(@"c:\\Documents\Testing\EncryptionSample\Keys"))); this.Encryptor = new MultiPolicyEncryptor(new SymmetricEncryptorFactory(_encryptorCache, policyFactory, keyFactory)); }
public async Task <HtmlDocument> GetWebsiteOrNullWithPolicyAsync(Uri url, CancellationToken cancellationToken) { if (url == null) { throw new ArgumentNullException(nameof(url)); } var policy = PolicyFactory.CreateDownloadWebsitePolicy(); return(await policy.ExecuteAsync(token => GetWebsiteOrNullAsync(url, token), cancellationToken)); }
public void GetPolicyConfigsTest() { var type = typeof(PolicyFactory); PolicyFactory factory = new PolicyFactory(); string methodName = "GetPolicyConfigs"; List <IPolicyConfig> policies = new List <IPolicyConfig>(); var configs = (List <IPolicyConfig>)Helper.RunInstanceMethod(type, methodName, factory, new object[1] { null }); Assert.Empty(configs); MethodInfo method = GetMethod(typeof(TestPolicy), "Test1"); var configs2 = (List <IPolicyConfig>)Helper.RunInstanceMethod(type, methodName, factory, new object[1] { method }); Assert.NotEmpty(configs2); Assert.Equal(2, configs2.Count); MethodInfo method2 = GetMethod(typeof(TestPolicy), "Test2"); var configs3 = (List <IPolicyConfig>)Helper.RunInstanceMethod(type, methodName, factory, new object[1] { method2 }); Assert.NotEmpty(configs3); Assert.Single(configs3); factory.PolicyConfigsFun = (method) => { return(new List <IPolicyConfig>() { new RetryPolicy(5, 200) }); }; var configs4 = (List <IPolicyConfig>)Helper.RunInstanceMethod(type, methodName, factory, new object[1] { method }); Assert.Equal(2, configs4.Count); Assert.True(configs4[0] is RetryPolicy); factory.SortIndexsFun = (method) => { return(new List <int>() { 5, 4, 3, 2, 1 }); }; var configs5 = (List <IPolicyConfig>)Helper.RunInstanceMethod(type, methodName, factory, new object[1] { method }); Assert.True(configs5[0] is TimeoutPolicy); }
public void PolitenessPolicy() { var politenessPolicy = PolicyFactory.DefaultPolitenessPolicy(); var shouldBeTrue = politenessPolicy.CanIGoThere(new UrlItem { Url = "http://www.google.com" }, out long _); var shouldBeFalse = politenessPolicy.CanIGoThere(new UrlItem { Url = "http://www.google.com/local/place/reviews/sasas" }, out long _); Assert.True(shouldBeTrue); Assert.False(shouldBeFalse); }
protected IUndoableEdit CreateCombinationsFromPatterns(IList <IList <EquivalenceClass> > patterns, CombinationOrigin origin) { //order the patterns based on equivalenceclasses ((List <IList <EquivalenceClass> >)patterns).Sort(new PatternComparer()); ////create a combination for each pattern in the patterns CompoundEdit ce = new CompoundEdit(); IPolicyFactory pfact = new PolicyFactory(); ////delete all combinations from the dependency if (generationOption == CombinationsGenerationOption.OVERWRITE) { ce.AddEdit(pfact.DeleteAllCombinationsPolicy(parentDependency)); } else { ce.AddEdit(RemoveInvalidCombinations(patterns)); RemoveRepeatedPatterns(patterns); } ////create the combinations from the pattern and remove the invalid ones foreach (IList <EquivalenceClass> list in patterns) { Combination comb = new Combination(); ce.AddEdit(EditFactory.instance.CreateAddCombinationEdit(parentDependency, comb)); parentDependency.AddCombination(comb); ce.AddEdit(EditFactory.instance.CreateChangePropertyEdit(comb, "Origin", origin)); comb.Origin = origin; foreach (EquivalenceClass equivalenceClass in list) { ce.AddEdit(EditFactory.instance.CreateAddEquivalenceClassEdit(comb, equivalenceClass)); comb.AddEquivalenceClass(equivalenceClass); } } ////put the positions int i = 1; foreach (Combination combination in parentDependency.Combinations) { if (combination.Position != i) { ce.AddEdit(EditFactory.instance.CreateChangePropertyEdit(combination, "Position", i)); combination.Position = i; } i++; } return(ce); }
public void Then_A_PolicyRequestedByNumberNotFound() { var requestedPolicyNumber = Guid.NewGuid().ToString(); var policy = PolicyFactory.BuildPolicyWithSpecificPolicyNumber(requestedPolicyNumber); var policies = PolicyFactory.BuildDefaultPolicyCollection(2); _policiesRepositoryMocked .Expects .One .Method(x => x.GetAllPolicies()) .Will(Return.Value(Task.FromResult(policies))); var policyResult = _sut.GetPolicyByNumber(requestedPolicyNumber).Result; Assert.IsNull(policyResult); }
public void SelectionPolicy() { var shouldBeTrue = PolicyFactory.DefaultSelectionPolicy().CanIGoThere(new UrlItem { Url = "http://www.google.com" }, "www.google.com/mylink"); var shouldBeFalse = PolicyFactory.DefaultSelectionPolicy().CanIGoThere(new UrlItem { Url = "http://www.google.com" }, "www.facebook.com/mylink"); Assert.True(shouldBeTrue); Assert.False(shouldBeFalse); shouldBeTrue = PolicyFactory.GetSelectionPolicy(true).CanIGoThere(new UrlItem { Url = "http://www.google.com" }, "www.facebook.com/mylink"); Assert.True(shouldBeTrue); }
public void CreateSyncPolicyTest() { var type = typeof(PolicyFactory); PolicyFactory factory = new PolicyFactory(); string methodName = "CreateSyncPolicy"; var policy = (ISyncPolicy)Helper.RunInstanceMethod(type, methodName, factory, new object[1] { null }); Assert.Null(policy); MethodInfo method = GetMethod(typeof(TestPolicy), "Test1"); var policy2 = (ISyncPolicy)Helper.RunInstanceMethod(type, methodName, factory, new object[1] { method }); Assert.NotNull(policy2); }
public bool TryConnect(PolicyFactory persisterConnectionPolicyFactory) { lock (_lockObject) { if (IsConnected) { return(true); } persisterConnectionPolicyFactory(_logger) .Execute(() => { _connection = _factory.CreateConnection(); }); if (!IsConnected) { return(false); } return(true); } }
public void WrapSyncTest() { var type = typeof(PolicyFactory); PolicyFactory factory = new PolicyFactory(); string methodName = "WrapSync"; var retryPolicy = Policy.Handle <Exception>().Retry(2); var timeoutPolicy = Policy.Timeout(200); var policy = (ISyncPolicy)Helper.RunInstanceMethod(type, methodName, factory, new object[2] { null, null }); Assert.Null(policy); var policy2 = (ISyncPolicy)Helper.RunInstanceMethod(type, methodName, factory, new object[2] { retryPolicy, null }); Assert.Equal(retryPolicy, policy2); var policy3 = (ISyncPolicy)Helper.RunInstanceMethod(type, methodName, factory, new object[2] { null, timeoutPolicy }); Assert.Equal(timeoutPolicy, policy3); var policy4 = (ISyncPolicy)Helper.RunInstanceMethod(type, methodName, factory, new object[2] { retryPolicy, timeoutPolicy }); Assert.NotNull(policy4); Assert.NotEqual(retryPolicy, policy4); Assert.NotEqual(timeoutPolicy, policy4); Assert.Equal(retryPolicy, ((Polly.Wrap.PolicyWrap)policy4).Outer); Assert.Equal(timeoutPolicy, ((Polly.Wrap.PolicyWrap)policy4).Inner); }
public PolicyManagerImpl( Agent agentInstance ) { fPolicyFactory = (PolicyFactory)ObjectFactory.GetInstance().CreateInstance( ObjectFactory.ADKFactoryType.POLICY_FACTORY, agentInstance ); }
public void CombinePolicyConfigsTest() { var type = typeof(PolicyFactory); PolicyFactory factory = new PolicyFactory(); string methodName = "CombinePolicyConfigs"; var configs = (List <IPolicyConfig>)Helper.RunInstanceMethod(type, methodName, factory, new object[3] { null, null, null }); Assert.Empty(configs); var factoryPolicies = new List <IPolicyConfig>() { }; var apiPolicies = new List <IPolicyConfig>() { }; var sortIndexs = new List <int>(); var configs2 = (List <IPolicyConfig>)Helper.RunInstanceMethod(type, methodName, factory, new object[3] { factoryPolicies, apiPolicies, sortIndexs }); Assert.Empty(configs2); RetryPolicy retryPolicy = new RetryPolicy(5); factoryPolicies.Add(retryPolicy); var configs3 = (List <IPolicyConfig>)Helper.RunInstanceMethod(type, methodName, factory, new object[3] { factoryPolicies, apiPolicies, sortIndexs }); Assert.NotEmpty(configs3); Assert.Single(configs3); TimeoutPolicy timeoutPolicy = new TimeoutPolicy(300); apiPolicies.Add(timeoutPolicy); var configs4 = (List <IPolicyConfig>)Helper.RunInstanceMethod(type, methodName, factory, new object[3] { factoryPolicies, apiPolicies, sortIndexs }); Assert.NotEmpty(configs4); Assert.Equal(2, configs4.Count); Assert.Equal(retryPolicy, configs4[0]); RetryPolicy apiRetryPolicy = new RetryPolicy(8); apiPolicies.Add(apiRetryPolicy); var configs5 = (List <IPolicyConfig>)Helper.RunInstanceMethod(type, methodName, factory, new object[3] { factoryPolicies, apiPolicies, sortIndexs }); Assert.Equal(2, configs5.Count); Assert.Equal(apiRetryPolicy, configs5[0]); sortIndexs = new List <int>() { 5, 4, 3, 2, 1 }; var configs6 = (List <IPolicyConfig>)Helper.RunInstanceMethod(type, methodName, factory, new object[3] { factoryPolicies, apiPolicies, sortIndexs }); Assert.NotEmpty(configs6); Assert.Equal(timeoutPolicy, configs6[0]); }