public void GivenAGeneralizeSetting_WhenCreate_SettingPropertiesShouldBeParsedCorrectly(Dictionary <string, object> config, string expectedCases, string expectedOtherValues) { var generalizeSetting = GeneralizeSetting.CreateFromRuleSettings(config); Assert.Equal(expectedCases, generalizeSetting.Cases.ToString()); Assert.Equal(expectedOtherValues, generalizeSetting.OtherValues.ToString()); }
public ProcessResult Process(ElementNode node, ProcessContext context = null, Dictionary <string, object> settings = null) { EnsureArg.IsNotNull(node); EnsureArg.IsNotNull(context?.VisitedNodes); EnsureArg.IsNotNull(settings); var result = new ProcessResult(); if (!ModelInfo.IsPrimitive(node.InstanceType)) { throw new AnonymizerRuleNotApplicableException( $"Generalization is not applicable on the node with type {node.InstanceType}. Only FHIR primitive nodes (ref: https://www.hl7.org/fhir/datatypes.html#primitive) are applicable."); } if (node.Value == null) { return(result); } var generalizeSetting = GeneralizeSetting.CreateFromRuleSettings(settings); foreach (var eachCase in generalizeSetting.Cases) { try { if (node.Predicate(eachCase.Key)) { node.Value = node.Scalar(eachCase.Value.ToString()); result.AddProcessRecord(AnonymizationOperations.Generalize, node); return(result); } } catch (Exception ex) { throw new AnonymizerProcessingException($"Generalize failed when processing {eachCase}.", ex); } } if (generalizeSetting.OtherValues == GeneralizationOtherValuesOperation.Redact) { node.Value = null; } result.AddProcessRecord(AnonymizationOperations.Generalize, node); return(result); }
public ProcessResult Process(ElementNode node, ProcessContext context = null, Dictionary <string, object> settings = null) { EnsureArg.IsNotNull(node); EnsureArg.IsNotNull(context?.VisitedNodes); EnsureArg.IsNotNull(settings); var result = new ProcessResult(); if (!ModelInfo.IsPrimitive(node.InstanceType) || node.Value == null) { return(result); } var generalizeSetting = GeneralizeSetting.CreateFromRuleSettings(settings); foreach (var eachCase in generalizeSetting.Cases) { try { if (node.Predicate(eachCase.Key)) { node.Value = node.Scalar(eachCase.Value); result.AddProcessRecord(AnonymizationOperations.Generalize, node); return(result); } } catch (InvalidOperationException ex) { throw new AnonymizerConfigurationErrorsException( $"Invalid cases expression '{eachCase}': {ex.Message}", ex); } } if (generalizeSetting.OtherValues == GeneralizationOtherValuesOperation.Redact) { node.Value = null; } result.AddProcessRecord(AnonymizationOperations.Generalize, node); return(result); }
public void Validate(AnonymizerConfiguration config) { if (string.IsNullOrEmpty(config.FhirVersion)) { _logger.LogWarning($"Version is not specified in configuration file."); } else if (!string.Equals(Constants.SupportedVersion, config.FhirVersion, StringComparison.InvariantCultureIgnoreCase)) { throw new AnonymizerConfigurationErrorsException($"Configuration of fhirVersion {config.FhirVersion} is not supported. Expected fhirVersion: {Constants.SupportedVersion}"); } if (config.FhirPathRules == null) { throw new AnonymizerConfigurationErrorsException("The configuration is invalid, please specify any fhirPathRules"); } FhirPathCompiler compiler = new FhirPathCompiler(); var supportedMethods = Enum.GetNames(typeof(AnonymizerMethod)).ToHashSet(StringComparer.InvariantCultureIgnoreCase); foreach (var rule in config.FhirPathRules) { if (!rule.ContainsKey(Constants.PathKey) || !rule.ContainsKey(Constants.MethodKey)) { throw new AnonymizerConfigurationErrorsException("Missing path or method in Fhir path rule config."); } // Grammar check on FHIR path try { compiler.Compile(rule[Constants.PathKey].ToString()); } catch (Exception ex) { throw new AnonymizerConfigurationErrorsException($"Invalid FHIR path {rule[Constants.PathKey]}", ex); } // Method validate string method = rule[Constants.MethodKey].ToString(); if (!supportedMethods.Contains(method)) { throw new AnonymizerConfigurationErrorsException($"Anonymization method {method} not supported."); } // Should provide replacement value for substitute rule if (string.Equals(method, AnonymizerMethod.Substitute.ToString(), StringComparison.InvariantCultureIgnoreCase)) { SubstituteSetting.ValidateRuleSettings(rule); } if (string.Equals(method, AnonymizerMethod.Perturb.ToString(), StringComparison.InvariantCultureIgnoreCase)) { PerturbSetting.ValidateRuleSettings(rule); } if (string.Equals(method, AnonymizerMethod.Generalize.ToString(), StringComparison.InvariantCultureIgnoreCase)) { GeneralizeSetting.ValidateRuleSettings(rule); } } // Check AES key size is valid (16, 24 or 32 bytes). if (!string.IsNullOrEmpty(config.ParameterConfiguration?.EncryptKey)) { using Aes aes = Aes.Create(); var encryptKeySize = Encoding.UTF8.GetByteCount(config.ParameterConfiguration.EncryptKey) * 8; if (!IsValidKeySize(encryptKeySize, aes.LegalKeySizes)) { throw new AnonymizerConfigurationErrorsException($"Invalid encrypt key size : {encryptKeySize} bits! Please provide key sizes of 128, 192 or 256 bits."); } } }
public void GivenAInvalidGeneralizeSetting_WhenValidate_ExceptionShouldBeThrown(Dictionary <string, object> config) { Assert.Throws <AnonymizerConfigurationErrorsException>(() => GeneralizeSetting.ValidateRuleSettings(config)); }