示例#1
0
        public void Interpret_EmptyIsolate_IsUndetermined()
        {
            var isolate = new IsolateBase();

            var interpretation = isolateInterpretation.Interpret(isolate);

            interpretation.Interpretation.Should().Contain("Diskrepante Ergebnisse");
            interpretation.InterpretationDisclaimer.Should().BeEmpty();
        }
示例#2
0
        public void Interpret_BexaAndAgglutinationIsNegative_WithRespectiveSeroType_NotTypable(SerotypePcr serotype)
        {
            var isolate = new IsolateBase
            {
                SerotypePcr   = serotype,
                Agglutination = SerotypeAgg.Negative,
                BexA          = TestResult.Negative
            };

            var interpretation = isolateInterpretation.Interpret(isolate);

            interpretation.Interpretation.Should().Contain("nicht-typisierbar");
            interpretation.InterpretationPreliminary.Should().Contain("Diskrepante");
            interpretation.InterpretationDisclaimer.Should()
            .Contain("Meldekategorie dieses Befundes: Haemophilus influenzae, unbekapselt.");
        }
示例#3
0
        public void Interpret_OnlyNegativeAgglutination_TypingNotEfficient()
        {
            var isolate = new IsolateBase
            {
                SerotypePcr   = SerotypePcr.NotDetermined,
                Agglutination = SerotypeAgg.Negative,
                BexA          = TestResult.NotDetermined
            };

            var interpretation = isolateInterpretation.Interpret(isolate);

            var expectedInterpretation = "Das Ergebnis spricht für einen nicht-typisierbaren Haemophilus influenzae (NTHi).";

            interpretation.Interpretation.Should().Be(expectedInterpretation + " Eine molekularbiologische Typisierung wurde aus epidemiologischen und Kostengründen nicht durchgeführt.");
            interpretation.InterpretationPreliminary.Should().Be(expectedInterpretation);
        }
示例#4
0
        public void Interpret_AgglutinationBexAAndSerotypAreNotDeterminedButGrowthIsYes_WithRespectiveSeroType_RequestForResend()
        {
            var isolate = new IsolateBase
            {
                SerotypePcr   = SerotypePcr.NotDetermined,
                Agglutination = SerotypeAgg.NotDetermined,
                BexA          = TestResult.NotDetermined,
                Growth        = YesNoOptional.Yes
            };

            var interpretation = isolateInterpretation.Interpret(isolate);

            interpretation.Interpretation.Should().Contain("Um Wiedereinsendung wird gebeten");
            interpretation.InterpretationPreliminary.Should().Contain("Diskrepante");
            interpretation.InterpretationDisclaimer.Should()
            .Contain("Eine telefonische Vorabmitteilung ist erfolgt.");
        }
示例#5
0
        public void Interpret_AgglutinationBexAAndSerotypAreNotDetermined_ButGrowthIsNo_ReportEvaluation()
        {
            var isolate = new IsolateBase
            {
                SerotypePcr   = SerotypePcr.NotDetermined,
                Agglutination = SerotypeAgg.NotDetermined,
                BexA          = TestResult.NotDetermined,
                Growth        = YesNoOptional.No,
                Evaluation    = Evaluation.HaemophilusSpeciesNoHaemophilusInfluenzae
            };

            var interpretation = isolateInterpretation.Interpret(isolate);

            interpretation.Interpretation.Should().Contain("Kein Nachweis von Haemophilus influenzae.");
            interpretation.InterpretationPreliminary.Should().Contain("Diskrepante");
            interpretation.InterpretationDisclaimer.Should()
            .Contain("Beim eingesendeten Isolat handelt es sich am ehesten um Haemophilus sp., nicht H. influenzae.");
        }
示例#6
0
        public void Interpret_NegativeAgglutinationButDistinctSerotypeWithNegativeBexA_IsSpecificTyping(
            SerotypePcr serotypePcr)
        {
            var serotypeString = serotypePcr.ToString().ToLower();
            var isolate        = new IsolateBase
            {
                SerotypePcr   = serotypePcr,
                Agglutination = SerotypeAgg.Negative,
                BexA          = TestResult.Negative
            };

            var interpretation         = isolateInterpretation.Interpret(isolate);
            var expectedInterpretation = $"Die Ergebnisse sprechen für einen phänotpischen nicht-typisierbaren Haemophilus influenzae (NTHi). Ein vorhandener genetischer Kapsellocus für Polysaccharide des Serotyps {serotypeString} wird nicht exprimiert.";

            interpretation.Interpretation.Should().Be(expectedInterpretation);
            interpretation.InterpretationPreliminary.Should().Contain("Diskrepante");
            interpretation.InterpretationDisclaimer.Should()
            .Contain("Meldekategorie dieses Befundes: Haemophilus influenzae, unbekapselt.");
        }
示例#7
0
        Interpret_DistinctAgglutinationWithPositiveBexA_EitherMatchingOrNotDeterminedSerotype_IsSpecificTyping(
            SerotypeAgg serotypeAgg,
            SerotypePcr serotypePcr)
        {
            var serotypeString = serotypeAgg.ToString().ToLower();
            var isolate        = new IsolateBase
            {
                SerotypePcr   = serotypePcr,
                Agglutination = serotypeAgg,
                BexA          = TestResult.Positive
            };

            var interpretation = isolateInterpretation.Interpret(isolate);

            var expectedInterpretation = string.Format("Die Ergebnisse sprechen für eine Infektion mit Haemophilus influenzae des Serotyp {0} (Hi{0}).",
                                                       serotypeString);
            var expectedDisclaimer = $"Meldekategorie dieses Befundes: Haemophilus influenzae, Serotyp {serotypeString}";

            interpretation.Interpretation.Should().Be(expectedInterpretation);
            interpretation.InterpretationPreliminary.Should().Contain("Diskrepante");
            interpretation.InterpretationDisclaimer.Should().Contain(expectedDisclaimer);
        }
示例#8
0
        public InterpretationResult Interpret(IsolateBase isolate)
        {
            var serotypePcr = isolate.SerotypePcr;
            var serotypePcrDescription = EnumEditor.GetEnumDescription(serotypePcr);
            var agglutination = isolate.Agglutination;
            var agglutinationDescription = EnumEditor.GetEnumDescription(agglutination);
            var bexA = isolate.BexA;
            var growth = isolate.Growth;
            var interpretation = "Diskrepante Ergebnisse, bitte Datenbankeinträge kontrollieren.";
            var interpretationPreliminary = "Diskrepante Ergebnisse, bitte Datenbankeinträge kontrollieren.";
            var interpretationDisclaimer = string.Empty;

            if (agglutination == SerotypeAgg.Negative)
            {
                if (bexA == TestResult.Negative)
                {
                    if (serotypePcr == SerotypePcr.Negative || serotypePcr == SerotypePcr.NotDetermined)
                    {
                        interpretation = TypingNotPossiblePlural;
                    }
                    else if (serotypePcr != SerotypePcr.NotDetermined)
                    {
                        interpretation =
                            $"{TypingNotPossiblePlural2} Ein vorhandener genetischer Kapsellocus für Polysaccharide des Serotyps {serotypePcrDescription} wird nicht exprimiert.";
                    }
                }
                else if (bexA == TestResult.NotDetermined && serotypePcr == SerotypePcr.NotDetermined)
                {
                    interpretationPreliminary = TypingNotPossibleSingular;
                    interpretation =
                        $"{TypingNotPossibleSingular} Eine molekularbiologische Typisierung wurde aus epidemiologischen und Kostengründen nicht durchgeführt.";
                }
                interpretationDisclaimer = string.Format(DisclaimerTemplate, "Haemophilus influenzae, unbekapselt");
            }
            if (SpecificAgglutination.Contains(agglutination) && (bexA == TestResult.Positive || bexA == TestResult.NotDetermined) &&
                (agglutination.ToString() == serotypePcr.ToString() || serotypePcr == SerotypePcr.NotDetermined))
            {
                if (serotypePcr == SerotypePcr.NotDetermined && bexA == TestResult.NotDetermined)
                {
                    interpretationPreliminary =
                        $"Das Ergebnis spricht für eine Infektion mit Haemophilus influenzae des Serotyp {agglutinationDescription} (Hi{agglutinationDescription}).";
                }
                if (bexA == TestResult.Positive)
                {
                    interpretation =
                        $"Die Ergebnisse sprechen für eine Infektion mit Haemophilus influenzae des Serotyp {agglutinationDescription} (Hi{agglutinationDescription}).";
                }
                interpretationDisclaimer = string.Format(DisclaimerTemplate,
                    $"Haemophilus influenzae, Serotyp {agglutinationDescription}");
            }

            if (agglutination == SerotypeAgg.NotDetermined && serotypePcr == SerotypePcr.NotDetermined && bexA == TestResult.NotDetermined && growth != YesNoOptional.NotStated)
            {
                if (growth == YesNoOptional.Yes)
                {
                    interpretation = "Der eingesendete Stamm konnte nicht angezüchtet werden. Um Wiedereinsendung wird gebeten.";
                    interpretationDisclaimer = "Eine telefonische Vorabmitteilung ist erfolgt.";
                }
                else if (growth == YesNoOptional.No)
                {
                    var evaluation = EnumEditor.GetEnumDescription(isolate.Evaluation);
                    interpretation = "Kein Nachweis von Haemophilus influenzae.";
                    interpretationDisclaimer = $"Beim eingesendeten Isolat handelt es sich am ehesten um {evaluation}.";
                }
            }
            return new InterpretationResult
            {
                Interpretation = interpretation,
                InterpretationPreliminary = interpretationPreliminary,
                InterpretationDisclaimer = interpretationDisclaimer
            };
        }