public void AddPolicy(bool isEnabled, bool isTypeSet, bool expectedAdded)
        {
            var policyCache = new ResourceTriggerFilterPolicyCache(new List <IFilteredTargetHandlerFactory>());

            ResourceTriggerFilterDef policy = CreateDummyPolicy();

            policy.TriggerEnabled = isEnabled;

            if (!isTypeSet)
            {
                policy.TriggeredOnType = null;
            }

            policyCache.UpdateOrAddPolicy(policy);

            if (expectedAdded)
            {
                Assert.That(policyCache.PolicyToFieldsMap.ContainsKey(policy.Id), Is.True);
                Assert.That(policyCache.TypePolicyMap.ContainsKey(policy.TriggeredOnType.Id), Is.True);
            }
            else
            {
                Assert.That(policyCache.PolicyToFieldsMap, Is.Empty);
                Assert.That(policyCache.TypePolicyMap, Is.Empty);
            }
        }
        public void PolicyHandlerMapSetUp()
        {
            var dummyType = Entity.Create <EntityType>();

            dummyType.Name = "ResourceTriggerFilterTest type";
            dummyType.Save();

            var factory = new TestFactory(dummyType, new TestHandler());

            var policyCache = new ResourceTriggerFilterPolicyCache(factory.ToEnumerable());

            Assert.That(policyCache.PolicyTypeHandlerMap.Count(), Is.EqualTo(1));
        }
        public void CacheCleanedWhenPolicyRemoved()
        {
            ResourceTriggerFilterDef policy = CreateDummyPolicy();

            var policyCache = new ResourceTriggerFilterPolicyCache(new List <IFilteredTargetHandlerFactory>());

            policyCache.UpdateOrAddPolicy(policy);
            policyCache.RemovePolicy(policy.Id);

            Assert.That(policyCache.PolicyToFieldsMap.ContainsKey(policy.Id), Is.False);

            var policies = policyCache.TypePolicyMap[policy.TriggeredOnType.Id];

            Assert.That(policies.FirstOrDefault(p => p.Id == policy.Id), Is.Null);
        }
        void TestTrigger(TestHandler testHandler,
                         Action <ResourceTriggerFilterDef> configurePolicyAction,
                         Action <ResourceTriggerFilterDef> doStuff)
        {
            var dummyPolicyType = Entity.Create <EntityType>();

            dummyPolicyType.Name = "ResourceTriggerFilterTest type";
            dummyPolicyType.Inherits.Add(Entity.Get <EntityType>("core:resourceTriggerFilterDef"));
            dummyPolicyType.Save();
            _toDelete.Add(dummyPolicyType.Id);

            var factory = new TestFactory(dummyPolicyType, testHandler);

            var policyCache = new ResourceTriggerFilterPolicyCache(factory.ToEnumerable());

            using (var scope = Factory.Current.BeginLifetimeScope(builder =>
            {
                builder.Register(ctx => factory).As <IFilteredTargetHandlerFactory>();
                builder.Register(ctx => policyCache).As <IResourceTriggerFilterPolicyCache>();
            }))
                using (Factory.SetCurrentScope(scope))
                {
                    var dummyTriggerType = Entity.Create <EntityType>();
                    dummyTriggerType.Save();
                    _toDelete.Add(dummyTriggerType.Id);

                    var policy = Entity.Create(dummyPolicyType.Id).As <ResourceTriggerFilterDef>();
                    policy.TriggerEnabled  = true;
                    policy.TriggeredOnType = dummyTriggerType;
                    policy.Save();
                    _toDelete.Add(policy.Id);

                    configurePolicyAction(policy);

                    testHandler.Clear();

                    doStuff(policy);

                    testHandler.Check();
                }
        }