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]);
}
