public void SetUp()
 {
     provider = new LoggingSettingsManageabilityProvider(new Dictionary<Type, ConfigurationElementManageabilityProvider>(0));
     machineKey = new MockRegistryKey(true);
     userKey = new MockRegistryKey(true);
     section = new LoggingSettings();
     configurationSource = new DictionaryConfigurationSource();
     configurationSource.Add(LoggingSettings.SectionName, section);
 }
        public void ManageabilityProviderGeneratesProperAdmContentForEmptySection()
        {
            DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
            configurationSource.Add(LoggingSettings.SectionName, section);

            Dictionary<Type, ConfigurationElementManageabilityProvider> subProviders
                = new Dictionary<Type, ConfigurationElementManageabilityProvider>();
            provider = new LoggingSettingsManageabilityProvider(subProviders);

            MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();

            provider.AddAdministrativeTemplateDirectives(contentBuilder, section, configurationSource, "TestApp");

            MockAdmContent content = contentBuilder.GetMockContent();
            IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
            Assert.IsTrue(categoriesEnumerator.MoveNext());
            IEnumerator<AdmCategory> subCategoriesEnumerator = categoriesEnumerator.Current.Categories.GetEnumerator();
            Assert.IsTrue(subCategoriesEnumerator.MoveNext());
            Assert.IsTrue(subCategoriesEnumerator.MoveNext());
            Assert.IsTrue(subCategoriesEnumerator.MoveNext());
            Assert.IsTrue(subCategoriesEnumerator.MoveNext());
            Assert.IsTrue(subCategoriesEnumerator.MoveNext());
            Assert.IsFalse(subCategoriesEnumerator.MoveNext());
            IEnumerator<AdmPolicy> sectionPoliciesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
            Assert.IsTrue(sectionPoliciesEnumerator.MoveNext());
            IEnumerator<AdmPart> sectionPartsEnumerator = sectionPoliciesEnumerator.Current.Parts.GetEnumerator();
            Assert.IsTrue(sectionPartsEnumerator.MoveNext());
            Assert.AreSame(typeof(AdmDropDownListPart), sectionPartsEnumerator.Current.GetType());
            Assert.AreEqual(LoggingSettingsManageabilityProvider.DefaultCategoryPropertyName,
                            ((AdmDropDownListPart)sectionPartsEnumerator.Current).ValueName);
            Assert.IsTrue(sectionPartsEnumerator.MoveNext());
            Assert.AreSame(typeof(AdmCheckboxPart), sectionPartsEnumerator.Current.GetType());
            Assert.AreEqual(LoggingSettingsManageabilityProvider.LogWarningOnNoMatchPropertyName,
                            ((AdmCheckboxPart)sectionPartsEnumerator.Current).ValueName);
            Assert.IsTrue(sectionPartsEnumerator.MoveNext());
            Assert.AreSame(typeof(AdmCheckboxPart), sectionPartsEnumerator.Current.GetType());
            Assert.AreEqual(LoggingSettingsManageabilityProvider.TracingEnabledPropertyName,
                            ((AdmCheckboxPart)sectionPartsEnumerator.Current).ValueName);
            Assert.IsTrue(sectionPartsEnumerator.MoveNext());
            Assert.AreSame(typeof(AdmCheckboxPart), sectionPartsEnumerator.Current.GetType());
            Assert.AreEqual(LoggingSettingsManageabilityProvider.RevertImpersonationPropertyName,
                            ((AdmCheckboxPart)sectionPartsEnumerator.Current).ValueName);
            Assert.IsFalse(sectionPartsEnumerator.MoveNext());
            Assert.IsFalse(sectionPoliciesEnumerator.MoveNext());
            Assert.IsFalse(categoriesEnumerator.MoveNext());
        }
        public void RegisteredListenerDataProviderIsCalledWithCorrectOverrides()
        {
            MockConfigurationElementManageabilityProvider registeredProvider
                = new MockConfigurationElementManageabilityProvider();
            Dictionary<Type, ConfigurationElementManageabilityProvider> subProviders
                = new Dictionary<Type, ConfigurationElementManageabilityProvider>();
            subProviders.Add(typeof(FormattedEventLogTraceListenerData), registeredProvider);
            provider = new LoggingSettingsManageabilityProvider(subProviders);

            FormattedEventLogTraceListenerData listenerData
                = new FormattedEventLogTraceListenerData("listener1", "source", "formatter");
            section.TraceListeners.Add(listenerData);

            MockRegistryKey machineListenersKey = new MockRegistryKey(false);
            machineKey.AddSubKey(LoggingSettingsManageabilityProvider.TraceListenersKeyName, machineListenersKey);
            MockRegistryKey machineListenerKey = new MockRegistryKey(false);
            machineListenersKey.AddSubKey("listener1", machineListenerKey);
            MockRegistryKey machineOtherListenerKey = new MockRegistryKey(false);
            machineListenersKey.AddSubKey("listener2", machineOtherListenerKey);

            MockRegistryKey userListenersKey = new MockRegistryKey(false);
            userKey.AddSubKey(LoggingSettingsManageabilityProvider.TraceListenersKeyName, userListenersKey);
            MockRegistryKey userListenerKey = new MockRegistryKey(false);
            userListenersKey.AddSubKey("listener1", userListenerKey);
            MockRegistryKey userOtherListenerKey = new MockRegistryKey(false);
            userListenersKey.AddSubKey("listener2", userOtherListenerKey);

            provider.OverrideWithGroupPolicies(section, true, machineKey, userKey);

            Assert.IsTrue(registeredProvider.called);
            Assert.AreSame(listenerData, registeredProvider.LastConfigurationObject);
            Assert.AreSame(machineListenerKey, registeredProvider.machineKey);
            Assert.AreSame(userListenerKey, registeredProvider.userKey);

            Assert.IsTrue(
                MockRegistryKey.CheckAllClosed(machineListenersKey, machineListenerKey, machineOtherListenerKey,
                                               userListenersKey, userListenerKey, userOtherListenerKey));
        }
        public void RegisteredTraceListenerDataProviderIsCalledWithNoOverrides()
        {
            MockConfigurationElementManageabilityProvider registeredProvider
                = new MockConfigurationElementManageabilityProvider();
            Dictionary<Type, ConfigurationElementManageabilityProvider> subProviders
                = new Dictionary<Type, ConfigurationElementManageabilityProvider>();
            subProviders.Add(typeof(FormattedEventLogTraceListenerData), registeredProvider);
            provider = new LoggingSettingsManageabilityProvider(subProviders);

            FormattedEventLogTraceListenerData listenerData
                = new FormattedEventLogTraceListenerData("name", "source", "formatter");
            section.TraceListeners.Add(listenerData);

            provider.OverrideWithGroupPolicies(section, true, machineKey, userKey);

            Assert.IsTrue(registeredProvider.called);
            Assert.AreSame(listenerData, registeredProvider.LastConfigurationObject);
            Assert.AreEqual(null, registeredProvider.machineKey);
            Assert.AreEqual(null, registeredProvider.userKey);
        }
        public void RegisteredLogFilterDataProviderIsCalledWithCorrectOverrides()
        {
            MockConfigurationElementManageabilityProvider registeredProvider
                = new MockConfigurationElementManageabilityProvider();
            Dictionary<Type, ConfigurationElementManageabilityProvider> subProviders
                = new Dictionary<Type, ConfigurationElementManageabilityProvider>();
            subProviders.Add(typeof(PriorityFilterData), registeredProvider);
            provider = new LoggingSettingsManageabilityProvider(subProviders);

            PriorityFilterData filterData = new PriorityFilterData("filter1", 10);
            section.LogFilters.Add(filterData);

            MockRegistryKey machineFiltersKey = new MockRegistryKey(false);
            machineKey.AddSubKey(LoggingSettingsManageabilityProvider.LogFiltersKeyName, machineFiltersKey);
            MockRegistryKey machineFilterKey = new MockRegistryKey(false);
            machineFiltersKey.AddSubKey("filter1", machineFilterKey);
            MockRegistryKey machineOtherFilterKey = new MockRegistryKey(false);
            machineFiltersKey.AddSubKey("filter2", machineOtherFilterKey);

            MockRegistryKey userFiltersKey = new MockRegistryKey(false);
            userKey.AddSubKey(LoggingSettingsManageabilityProvider.LogFiltersKeyName, userFiltersKey);
            MockRegistryKey userFilterKey = new MockRegistryKey(false);
            userFiltersKey.AddSubKey("filter1", userFilterKey);
            MockRegistryKey userOtherFilterKey = new MockRegistryKey(false);
            userFiltersKey.AddSubKey("filter2", userOtherFilterKey);

            provider.OverrideWithGroupPolicies(section, true, machineKey, userKey);

            Assert.IsTrue(registeredProvider.called);
            Assert.AreSame(filterData, registeredProvider.LastConfigurationObject);
            Assert.AreSame(machineFilterKey, registeredProvider.machineKey);
            Assert.AreSame(userFilterKey, registeredProvider.userKey);

            Assert.IsTrue(
                MockRegistryKey.CheckAllClosed(machineFiltersKey, machineFilterKey, machineOtherFilterKey,
                                               userFiltersKey, userFilterKey, userOtherFilterKey));
        }
        public void RegisteredLogFilterDataProviderIsCalledWithNoOverrides()
        {
            MockConfigurationElementManageabilityProvider registeredProvider
                = new MockConfigurationElementManageabilityProvider();
            Dictionary<Type, ConfigurationElementManageabilityProvider> subProviders
                = new Dictionary<Type, ConfigurationElementManageabilityProvider>();
            subProviders.Add(typeof(PriorityFilterData), registeredProvider);
            provider = new LoggingSettingsManageabilityProvider(subProviders);

            PriorityFilterData filterData = new PriorityFilterData(10);
            section.LogFilters.Add(filterData);

            provider.OverrideWithGroupPolicies(section, true, machineKey, userKey);

            Assert.IsTrue(registeredProvider.called);
            Assert.AreSame(filterData, registeredProvider.LastConfigurationObject);
            Assert.AreEqual(null, registeredProvider.machineKey);
            Assert.AreEqual(null, registeredProvider.userKey);
        }
        public void TraceListenerWithDisabledPolicyIsNotRemovedIfGroupPoliciesAreDisabled()
        {
            MockConfigurationElementManageabilityProvider registeredProvider
                = new MockConfigurationElementManageabilityProvider();
            Dictionary<Type, ConfigurationElementManageabilityProvider> subProviders
                = new Dictionary<Type, ConfigurationElementManageabilityProvider>();
            subProviders.Add(typeof(TraceListenerData), registeredProvider);
            provider = new LoggingSettingsManageabilityProvider(subProviders);

            TraceListenerData traceListener1Data = new TraceListenerData();
            traceListener1Data.Name = "traceListener1";
            section.TraceListeners.Add(traceListener1Data);
            TraceListenerData traceListener2Data = new TraceListenerData();
            traceListener2Data.Name = "traceListener2";
            section.TraceListeners.Add(traceListener2Data);

            MockRegistryKey machineTraceListenersKey = new MockRegistryKey(false);
            machineKey.AddSubKey(LoggingSettingsManageabilityProvider.TraceListenersKeyName, machineTraceListenersKey);
            MockRegistryKey machineTraceListener2Key = new MockRegistryKey(false);
            machineTraceListenersKey.AddSubKey("traceListener2", machineTraceListener2Key);
            machineTraceListener2Key.AddBooleanValue(AdmContentBuilder.AvailableValueName, false);

            provider.OverrideWithGroupPolicies(section, false, machineKey, userKey);

            Assert.AreEqual(2, section.TraceListeners.Count);
            Assert.IsNotNull(section.TraceListeners.Get("traceListener1"));
            Assert.IsNotNull(section.TraceListeners.Get("traceListener2"));

            Assert.IsTrue(MockRegistryKey.CheckAllClosed(machineTraceListenersKey, machineTraceListener2Key));
        }
        public void LogFormatterWithDisabledPolicyIsRemoved()
        {
            MockConfigurationElementManageabilityProvider registeredProvider
                = new MockConfigurationElementManageabilityProvider();
            Dictionary<Type, ConfigurationElementManageabilityProvider> subProviders
                = new Dictionary<Type, ConfigurationElementManageabilityProvider>();
            subProviders.Add(typeof(FormatterData), registeredProvider);
            provider = new LoggingSettingsManageabilityProvider(subProviders);

            FormatterData logFormatter1Data = new FormatterData("logFormatter1", typeof(Object));
            section.Formatters.Add(logFormatter1Data);
            FormatterData logFormatter2Data = new FormatterData("logFormatter2", typeof(Object));
            section.Formatters.Add(logFormatter2Data);

            MockRegistryKey machineLogFormattersKey = new MockRegistryKey(false);
            machineKey.AddSubKey(LoggingSettingsManageabilityProvider.LogFormattersKeyName, machineLogFormattersKey);
            MockRegistryKey machineLogFormatter2Key = new MockRegistryKey(false);
            machineLogFormattersKey.AddSubKey("logFormatter2", machineLogFormatter2Key);
            machineLogFormatter2Key.AddBooleanValue(AdmContentBuilder.AvailableValueName, false);

            provider.OverrideWithGroupPolicies(section, true, machineKey, userKey);

            Assert.AreEqual(1, section.Formatters.Count);
            Assert.IsNotNull(section.Formatters.Get("logFormatter1"));

            Assert.IsTrue(MockRegistryKey.CheckAllClosed(machineLogFormattersKey, machineLogFormatter2Key));
        }
        public void ManageabilityProviderInvokesRegisteredElementProvidersWhileGeneratingAdmContent()
        {
            DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
            configurationSource.Add(LoggingSettings.SectionName, section);

            section.LogFilters.Add(new LogFilterData("filter", typeof(object)));
            section.Formatters.Add(new FormatterData("formatter", typeof(object)));
            section.TraceListeners.Add(new FlatFileTraceListenerData("listener", "file", "formatter"));

            MockConfigurationElementManageabilityProvider subProvider = new MockConfigurationElementManageabilityProvider();
            Dictionary<Type, ConfigurationElementManageabilityProvider> subProviders
                = new Dictionary<Type, ConfigurationElementManageabilityProvider>();
            subProviders.Add(typeof(LogFilterData), subProvider);
            subProviders.Add(typeof(FormatterData), subProvider);
            subProviders.Add(typeof(FlatFileTraceListenerData), subProvider);
            provider = new LoggingSettingsManageabilityProvider(subProviders);

            MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();

            provider.AddAdministrativeTemplateDirectives(contentBuilder, section, configurationSource, "TestApp");

            Assert.AreEqual(3, subProvider.configurationObjects.Count);
            Assert.AreSame(typeof(LogFilterData), subProvider.configurationObjects[0].GetType());
            Assert.AreSame(typeof(FormatterData), subProvider.configurationObjects[1].GetType());
            Assert.AreSame(typeof(FlatFileTraceListenerData), subProvider.configurationObjects[2].GetType());
        }
        public void ManageabilityProviderGeneratesProperAdmContentForSpecialTraceSources()
        {
            DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
            configurationSource.Add(LoggingSettings.SectionName, section);
            section.TraceListeners.Add(new FlatFileTraceListenerData("listener1", "file", ""));

            Dictionary<Type, ConfigurationElementManageabilityProvider> subProviders
                = new Dictionary<Type, ConfigurationElementManageabilityProvider>();
            provider = new LoggingSettingsManageabilityProvider(subProviders);

            MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();

            provider.AddAdministrativeTemplateDirectives(contentBuilder, section, configurationSource, "TestApp");

            MockAdmContent content = contentBuilder.GetMockContent();
            IEnumerator<AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
            categoriesEnumerator.MoveNext();
            IEnumerator<AdmCategory> subCategoriesEnumerator = categoriesEnumerator.Current.Categories.GetEnumerator();
            subCategoriesEnumerator.MoveNext(); // first is trace sources category
            subCategoriesEnumerator.MoveNext(); // second is special sources category
            IEnumerator<AdmPolicy> specialSourcePoliciesEnumerator = subCategoriesEnumerator.Current.Policies.GetEnumerator();
            Assert.IsTrue(specialSourcePoliciesEnumerator.MoveNext());
            IEnumerator<AdmPart> sourcePartsEnumerator = specialSourcePoliciesEnumerator.Current.Parts.GetEnumerator();
            Assert.IsTrue(sourcePartsEnumerator.MoveNext());
            Assert.AreSame(typeof(AdmDropDownListPart), sourcePartsEnumerator.Current.GetType());
            Assert.AreEqual(LoggingSettingsManageabilityProvider.SourceDefaultLevelPropertyName,
                            sourcePartsEnumerator.Current.ValueName);
            Assert.IsTrue(sourcePartsEnumerator.MoveNext());
            Assert.AreSame(typeof(AdmCheckboxPart), sourcePartsEnumerator.Current.GetType());
            Assert.AreEqual(LoggingSettingsManageabilityProvider.SourceAutoFlushPropertyName,
                            sourcePartsEnumerator.Current.ValueName);
            Assert.IsTrue(sourcePartsEnumerator.MoveNext());
            Assert.AreSame(typeof(AdmTextPart), sourcePartsEnumerator.Current.GetType());
            Assert.IsTrue(sourcePartsEnumerator.MoveNext());
            Assert.AreSame(typeof(AdmCheckboxPart), sourcePartsEnumerator.Current.GetType());
            Assert.AreEqual("listener1", sourcePartsEnumerator.Current.ValueName);
            Assert.AreEqual("listener1", sourcePartsEnumerator.Current.PartName);
            Assert.IsTrue(sourcePartsEnumerator.Current.KeyName.EndsWith(LoggingSettingsManageabilityProvider.SourceTraceListenersPropertyName));
            Assert.IsFalse(sourcePartsEnumerator.MoveNext());
            Assert.IsTrue(specialSourcePoliciesEnumerator.MoveNext());
            Assert.IsTrue(specialSourcePoliciesEnumerator.MoveNext()); // there are 3 special sources
            Assert.IsFalse(specialSourcePoliciesEnumerator.MoveNext());
        }