public void Fees_GetListFromObjects_ProviderProcCodeDefault() { string suffix = MethodBase.GetCurrentMethod().Name; ProcedureCode procedureCode = ProcedureCodeT.CreateProcCode("D1110"); Fee fee = CreateSingleFee(suffix, (_defaultFeeAmt * _rand.NextDouble()), hasProv: true, codeNum: procedureCode.CodeNum); //Update our new provider so that they are associated to the new fee schedule that was just created. Provider prov = Providers.GetProv(fee.ProvNum); prov.FeeSched = fee.FeeSched; ProviderT.Update(prov); //Make the default provider associated to the procedure code our new provider. procedureCode.ProvNumDefault = prov.ProvNum; ProcedureCodeT.Update(procedureCode); //The fees associated to the fee schedule of the procedure code's default provider should be returned by GetListFromObjects(). List <Fee> listFees = Fees.GetListFromObjects(new List <ProcedureCode>() { procedureCode }, null, null, 0, 0, 0, null, null, null, null, 0); Assert.IsTrue(listFees.Exists(x => x.FeeNum == fee.FeeNum)); }
public void Fees_GetListFromObjects_ProviderPatientSecondary() { string suffix = MethodBase.GetCurrentMethod().Name; ProcedureCode procedureCode = ProcedureCodeT.CreateProcCode("D1110"); Fee fee = CreateSingleFee(suffix, (_defaultFeeAmt * _rand.NextDouble()), hasProv: true, codeNum: procedureCode.CodeNum); //Update our new provider so that they are associated to the new fee schedule that was just created. Provider prov = Providers.GetProv(fee.ProvNum); prov.FeeSched = fee.FeeSched; ProviderT.Update(prov); //Act like this provider is a secondary provider of a patient which should return the fees for the provider by GetListFromObjects(). List <Fee> listFees = Fees.GetListFromObjects(new List <ProcedureCode>() { procedureCode }, null, null, 0, prov.ProvNum, 0, null, null, null, null, 0); Assert.IsTrue(listFees.Exists(x => x.FeeNum == fee.FeeNum)); }
public void Fees_GetListFromObjects_AppointmentProviderSecondary() { string suffix = MethodBase.GetCurrentMethod().Name; ProcedureCode procedureCode = ProcedureCodeT.CreateProcCode("D1110"); Fee fee = CreateSingleFee(suffix, (_defaultFeeAmt * _rand.NextDouble()), hasProv: true, codeNum: procedureCode.CodeNum); //Update our new provider so that they are associated to the new fee schedule that was just created. Provider prov = Providers.GetProv(fee.ProvNum); prov.FeeSched = fee.FeeSched; ProviderT.Update(prov); //Make an appointment that has the new provider set as the secondary provider. Appointment appt = AppointmentT.CreateAppointment(0, DateTime.Now, 0, 0, provHyg: prov.ProvNum); //The fees associated to the fee schedule of the appointment's secondary provider should be returned by GetListFromObjects(). List <Fee> listFees = Fees.GetListFromObjects(new List <ProcedureCode>() { procedureCode }, null, null, 0, 0, 0, null, null, new List <Appointment>() { appt }, null, 0); Assert.IsTrue(listFees.Exists(x => x.FeeNum == fee.FeeNum)); }
public void Fees_GetListFromObjects_ProviderPracticeDefault() { string suffix = MethodBase.GetCurrentMethod().Name; ProcedureCode procedureCode = ProcedureCodeT.CreateProcCode("D1110"); Fee fee = CreateSingleFee(suffix, (_defaultFeeAmt * _rand.NextDouble()), hasProv: true, codeNum: procedureCode.CodeNum); //Update our new provider so that they are associated to the new fee schedule that was just created. Provider prov = Providers.GetProv(fee.ProvNum); prov.FeeSched = fee.FeeSched; ProviderT.Update(prov); //Update the database so that the practice provider is the provider associated to our new fee. long practiceDefaultProvOld = PrefC.GetLong(PrefName.PracticeDefaultProv); PrefT.UpdateLong(PrefName.PracticeDefaultProv, fee.ProvNum); //Since our new fee is associated to the fee schedule of the practice default provider, it should be returned by GetListFromObjects(). List <Fee> listFees = Fees.GetListFromObjects(new List <ProcedureCode>() { procedureCode }, null, null, 0, 0, 0, null, null, null, null, 0); //Put the default provider back the way it was prior to asserting. PrefT.UpdateLong(PrefName.PracticeDefaultProv, practiceDefaultProvOld); Assert.IsTrue(listFees.Exists(x => x.FeeNum == fee.FeeNum)); }
public void ProcedureCodes_GetSubstituteCodeNum_InsPlanOverrideAlways() { //First, setup the test scenario. string suffix = MethodBase.GetCurrentMethod().Name; Patient pat = PatientT.CreatePatient(suffix); Carrier carrier = CarrierT.CreateCarrier(MethodBase.GetCurrentMethod().Name); InsPlan plan = new InsPlan(); plan.CarrierNum = carrier.CarrierNum; plan.PlanType = ""; plan.CobRule = EnumCobRule.Basic; plan.PlanNum = InsPlans.Insert(plan); //Add a substitution code on the procedure level. ProcedureCode originalProcCode = ProcedureCodes.GetProcCode("D2330"); ProcedureCode downgradeProcCode = ProcedureCodes.GetProcCode("D2140"); originalProcCode.SubstitutionCode = "D2140"; originalProcCode.SubstOnlyIf = SubstitutionCondition.Always; ProcedureCodeT.Update(originalProcCode); //Add an override for the inplan above for the originalProcCode ProcedureCode downgradeProcCodeForIns = ProcedureCodes.GetProcCode("D2150"); SubstitutionLinkT.CreateSubstitutionLink(originalProcCode.CodeNum, downgradeProcCodeForIns.ProcCode, SubstitutionCondition.Always, plan.PlanNum); //Next, perform the thing you're trying to test. Procedure proc = ProcedureT.CreateProcedure(pat, originalProcCode.ProcCode, ProcStat.C, "9", 100);//Tooth 9 long subCodeNum = ProcedureCodes.GetSubstituteCodeNum(originalProcCode.ProcCode, proc.ToothNum, plan.PlanNum); //Finally, use one or more asserts to verify the results. Assert.AreEqual(downgradeProcCodeForIns.CodeNum, subCodeNum); }
protected static void FeeTestSetup() { //Some unit tests cannot handle duplicate procedure codes being present within the database. //This is acceptable because that scenario should be impossible (we block the user via the UI layer). //Delete all duplicate procedure codes. Dictionary <string, ProcedureCode> dictProcCodes = ProcedureCodes.GetAllCodes().GroupBy(x => x.ProcCode).ToDictionary(x => x.Key, x => x.First()); ProcedureCodeT.ClearProcedureCodeTable(); foreach (ProcedureCode procedureCode in dictProcCodes.Values) { ProcedureCodes.Insert(procedureCode); } ProcedureCodes.RefreshCache(); _listProcCodes = ProcedureCodes.GetAllCodes(); //Just in case the PKs matter to some tests. _listProcCodesOld = _listProcCodes.Select(x => x.Copy()).ToList(); if (Fees.GetCountByFeeSchedNum(_standardFeeSchedNum) <= 0) { List <Fee> listFees = new List <Fee>(); foreach (ProcedureCode procCode in _listProcCodes) { listFees.Add(new Fee() { FeeSched = _standardFeeSchedNum, CodeNum = procCode.CodeNum, Amount = _defaultFeeAmt * _rand.NextDouble(), ClinicNum = 0, ProvNum = 0 }); //create the default fee schedule fee } Fees.InsertMany(listFees); } }
public void ProcedureCodes_GetSubstituteCodeNum_Posterior() { //First, setup the test scenario. string suffix = MethodBase.GetCurrentMethod().Name; Patient pat = PatientT.CreatePatient(suffix); Carrier carrier = CarrierT.CreateCarrier(MethodBase.GetCurrentMethod().Name); InsPlan plan = new InsPlan(); plan.CarrierNum = carrier.CarrierNum; plan.PlanType = ""; plan.CobRule = EnumCobRule.Basic; plan.PlanNum = InsPlans.Insert(plan); //Add a substitution code on the procedure level. ProcedureCode originalProcCode = ProcedureCodes.GetProcCode("D2740"); ProcedureCode downgradeProcCode = ProcedureCodes.GetProcCode("D2750"); originalProcCode.SubstitutionCode = "D2750"; originalProcCode.SubstOnlyIf = SubstitutionCondition.Posterior; ProcedureCodeT.Update(originalProcCode); //Posterior Procedure= ToothNum 4 Procedure proc = ProcedureT.CreateProcedure(pat, originalProcCode.ProcCode, ProcStat.C, "4", 100);//Tooth 4 long subCodeNum = ProcedureCodes.GetSubstituteCodeNum(originalProcCode.ProcCode, proc.ToothNum, plan.PlanNum); //Finally, use one or more asserts to verify the results. Assert.AreEqual(downgradeProcCode.CodeNum, subCodeNum); }
public void ProcedureCodes_GetSubstituteCodeNum_InsPlanOverridePosterior() { //First, setup the test scenario. string suffix = MethodBase.GetCurrentMethod().Name; Patient pat = PatientT.CreatePatient(suffix); Carrier carrier = CarrierT.CreateCarrier(MethodBase.GetCurrentMethod().Name); InsPlan plan = new InsPlan(); plan.CarrierNum = carrier.CarrierNum; plan.PlanType = ""; plan.CobRule = EnumCobRule.Basic; plan.PlanNum = InsPlans.Insert(plan); //Procedure code does not have a substitution code ProcedureCode originalProcCode = ProcedureCodes.GetProcCode("D2740"); //clear out any substitution codes on this procedure originalProcCode.SubstitutionCode = ""; ProcedureCodeT.Update(originalProcCode); //Add an override for the inplan above for the originalProcCode to substitute if posterior ProcedureCode downgradeProcCodeForIns = ProcedureCodes.GetProcCode("D2750"); SubstitutionLinkT.CreateSubstitutionLink(originalProcCode.CodeNum, downgradeProcCodeForIns.ProcCode, SubstitutionCondition.Posterior, plan.PlanNum); //Posterior procedure Procedure proc = ProcedureT.CreateProcedure(pat, originalProcCode.ProcCode, ProcStat.C, "4", 100);//Tooth 4 long subCodeNum = ProcedureCodes.GetSubstituteCodeNum(originalProcCode.ProcCode, proc.ToothNum, plan.PlanNum); //The ins override is set to substitute only if posterior. Assert.AreEqual(downgradeProcCodeForIns.CodeNum, subCodeNum); }
public void InsPlan_PpoNoSubWriteoffsNoSub() { string suffix = MethodBase.GetCurrentMethod().Name; Patient pat = PatientT.CreatePatient(suffix); long ucrFeeSchedNum = FeeSchedT.CreateFeeSched(FeeScheduleType.Normal, "UCR Fees" + suffix); long ppoFeeSchedNum = FeeSchedT.CreateFeeSched(FeeScheduleType.Normal, "PPO " + suffix); InsuranceInfo ins = InsuranceT.AddInsurance(pat, suffix, planType: "p", feeSchedNum: ppoFeeSchedNum); ins.PriInsPlan.HasPpoSubstWriteoffs = false; InsPlans.Update(ins.PriInsPlan); BenefitT.CreateCategoryPercent(ins.PriInsPlan.PlanNum, EbenefitCategory.Restorative, 50); ProcedureCode originalProcCode = ProcedureCodes.GetProcCode("D2330"); ProcedureCode downgradeProcCode = ProcedureCodes.GetProcCode("D2140"); originalProcCode.SubstitutionCode = ""; //NOT substituting originalProcCode.SubstOnlyIf = SubstitutionCondition.Always; ProcedureCodeT.Update(originalProcCode); FeeT.CreateFee(ucrFeeSchedNum, originalProcCode.CodeNum, 100); FeeT.CreateFee(ucrFeeSchedNum, downgradeProcCode.CodeNum, 80); FeeT.CreateFee(ppoFeeSchedNum, originalProcCode.CodeNum, 60); FeeT.CreateFee(ppoFeeSchedNum, downgradeProcCode.CodeNum, 50); Procedure proc = ProcedureT.CreateProcedure(pat, "D2330", ProcStat.C, "9", 100);//Tooth 9 List <ClaimProc> listClaimProcs = ClaimProcs.Refresh(pat.PatNum); List <Procedure> listProcs = Procedures.Refresh(pat.PatNum); ins.RefreshBenefits(); Claim claim = ClaimT.CreateClaim("P", ins.ListPatPlans, ins.ListInsPlans, listClaimProcs, listProcs, pat, listProcs, ins.ListBenefits, ins.ListInsSubs); ClaimProc clProc = ClaimProcs.Refresh(pat.PatNum)[0]; //Should only be one Assert.AreEqual(50, clProc.Percentage); Assert.AreEqual(30, clProc.BaseEst); Assert.AreEqual(30, clProc.InsPayEst); Assert.AreEqual(40, clProc.WriteOffEst); }
public void ProcedureCodes_GetSubstituteCodeNum_InsPlanOverrideNever() { //First, setup the test scenario. string suffix = MethodBase.GetCurrentMethod().Name; Patient pat = PatientT.CreatePatient(suffix); Carrier carrier = CarrierT.CreateCarrier(MethodBase.GetCurrentMethod().Name); InsPlan plan = new InsPlan(); plan.CarrierNum = carrier.CarrierNum; plan.PlanType = ""; plan.CobRule = EnumCobRule.Basic; plan.PlanNum = InsPlans.Insert(plan); //Add a substitution code on the procedure level that has SubstitutionCondition.Never. ProcedureCode originalProcCode = ProcedureCodes.GetProcCode("D2330"); //clear out any substitution codes on this procedure originalProcCode.SubstitutionCode = ""; ProcedureCodeT.Update(originalProcCode); //Add an override for the inplan above for the originalProcCode to never substitute ProcedureCode downgradeProcCodeForIns = ProcedureCodes.GetProcCode("D2150"); SubstitutionLinkT.CreateSubstitutionLink(originalProcCode.CodeNum, downgradeProcCodeForIns.ProcCode, SubstitutionCondition.Never, plan.PlanNum); //Next, perform the thing you're trying to test. Procedure proc = ProcedureT.CreateProcedure(pat, originalProcCode.ProcCode, ProcStat.C, "9", 100);//Tooth 9 long subCodeNum = ProcedureCodes.GetSubstituteCodeNum(originalProcCode.ProcCode, proc.ToothNum, plan.PlanNum); //The procedure level and ins override is set SubstitutionCondition.Never so it should use originalProcCode.CodeNum Assert.AreEqual(originalProcCode.CodeNum, subCodeNum); }
public void RpProcNotBilledIns_GetProcsNotBilled_MedicalInsOnly() { string suffix = MethodBase.GetCurrentMethod().Name; Patient patient = PatientT.CreatePatient(suffix); Carrier carrier = CarrierT.CreateCarrier(suffix); ProcedureCode procedureCode = ProcedureCodeT.CreateProcCode("T7782"); //Create a primary medical insurance plan InsuranceInfo insuranceInfo = InsuranceT.AddInsurance(patient, carrier.CarrierName, ordinal: 1, isMedical: true); insuranceInfo.AddBenefit(BenefitT.CreatePercentForProc(insuranceInfo.MedInsPlan.PlanNum, procedureCode.CodeNum, 80)); Procedure procedure = ProcedureT.CreateProcedure(patient, procedureCode.ProcCode, ProcStat.TP, "", 55, procDate: DateTime.Now.AddDays(-3)); ProcedureT.ComputeEstimates(patient, insuranceInfo); ProcedureT.SetComplete(procedure, patient, insuranceInfo); //Run the procs not billed report with "includeMedProcs" set to false. //The patient should not be returned due to not having any dental insurance estimates. DataTable table = RpProcNotBilledIns.GetProcsNotBilled(new List <long>(), false, DateTime.Now.AddDays(-10), DateTime.Now, false, false); Assert.IsNotNull(table); Assert.IsFalse(table.Select().Select(x => PIn.Long(x["PatNum"].ToString())).Contains(patient.PatNum)); //Run the procs not billed report with "includeMedProcs" set to true. //The patient should be returned due to the medical insurance estimates. table = RpProcNotBilledIns.GetProcsNotBilled(new List <long>(), true, DateTime.Now.AddDays(-10), DateTime.Now, false, false); Assert.IsNotNull(table); Assert.IsTrue(table.Rows.Count > 0); Assert.IsTrue(table.Select().Select(x => PIn.Long(x["PatNum"].ToString())).Contains(patient.PatNum)); }
public void InsPlans_ComputeEstimatesForSubscriber_CanadianLabFees() { string suffix = MethodBase.GetCurrentMethod().Name; CultureInfo curCulture = CultureInfo.CurrentCulture; Thread.CurrentThread.CurrentCulture = new CultureInfo("en-CA"); //Canada try { //Create a patient and treatment plan a procedure with a lab fee. Patient pat = PatientT.CreatePatient(); ProcedureCodeT.AddIfNotPresent("14611"); ProcedureCodeT.AddIfNotPresent("99111", isCanadianLab: true); Procedure proc = ProcedureT.CreateProcedure(pat, "14611", ProcStat.TP, "", 250); Procedure procLab = ProcedureT.CreateProcedure(pat, "99111", ProcStat.TP, "", 149, procNumLab: proc.ProcNum); //Create a new primary insurance plan for this patient. //It is important that we add the insurance plan after the procedure has already been created for this particular scenario. Carrier carrier = CarrierT.CreateCarrier(suffix); InsPlan plan = InsPlanT.CreateInsPlan(carrier.CarrierNum); InsSub sub = InsSubT.CreateInsSub(pat.PatNum, plan.PlanNum); PatPlan patPlan = PatPlanT.CreatePatPlan(1, pat.PatNum, sub.InsSubNum); //Invoking ComputeEstimatesForAll() will simulate the logic of adding a new insurance plan from the Family module. //The bug that this unit test is preventing is that a duplicate claimproc was being created for the lab fee. //This was causing a faux line to show up when a claim was created for the procedure in question. //It ironically doesn't matter if the procedures above are even covered by insurance because they'll get claimprocs created regardless. InsPlans.ComputeEstimatesForSubscriber(sub.Subscriber); //Check to see how many claimproc enteries there are for the current patient. There should only be two. List <ClaimProc> listClaimProcs = ClaimProcs.Refresh(pat.PatNum); Assert.AreEqual(2, listClaimProcs.Count); } finally { Thread.CurrentThread.CurrentCulture = curCulture; } }
public void Fees_GetListFromObjects_ProviderFirst() { string suffix = MethodBase.GetCurrentMethod().Name; ProcedureCode procedureCode = ProcedureCodeT.CreateProcCode("D1110"); Fee fee = CreateSingleFee(suffix, (_defaultFeeAmt * _rand.NextDouble()), codeNum: procedureCode.CodeNum); //Update the database so that provFirst is associated to the new fee schedule we just created. Provider provFirst = Providers.GetFirst(); provFirst.FeeSched = fee.FeeSched; ProviderT.Update(provFirst); //Since our new fee is associated to the fee schedule of the first provider, it should be returned by GetListFromObjects(). List <Fee> listFees = Fees.GetListFromObjects(new List <ProcedureCode>() { procedureCode }, null, null, 0, 0, 0, null, null, null, null, 0); Assert.IsTrue(listFees.Exists(x => x.FeeNum == fee.FeeNum)); }
public void Fees_GetListFromObjects_DiscountPlan() { string suffix = MethodBase.GetCurrentMethod().Name; ProcedureCode procedureCode = ProcedureCodeT.CreateProcCode("D1110"); Fee fee = CreateSingleFee(suffix, (_defaultFeeAmt * _rand.NextDouble()), hasProv: true, codeNum: procedureCode.CodeNum); //Create a discount plan and associate it to the fee schedule that was just created. DiscountPlan discountPlan = DiscountPlanT.CreateDiscountPlan(suffix, feeSchedNum: fee.FeeSched); //Act like a discount plan has our fee schedule which should return the corresponding fees by GetListFromObjects(). List <Fee> listFees = Fees.GetListFromObjects(new List <ProcedureCode>() { procedureCode }, null, null, 0, 0, 0, null, null, null, null, discountPlan.DiscountPlanNum); Assert.IsTrue(listFees.Exists(x => x.FeeNum == fee.FeeNum)); }
public void Fees_GetListFromObjects_InsPlanAllowedFeeSched() { string suffix = MethodBase.GetCurrentMethod().Name; ProcedureCode procedureCode = ProcedureCodeT.CreateProcCode("D1110"); Fee fee = CreateSingleFee(suffix, (_defaultFeeAmt * _rand.NextDouble()), hasProv: true, codeNum: procedureCode.CodeNum); //Create an insurance plan and associate the allowed fee schedule to the fee schedule that was just created. InsPlan insPlan = InsPlanT.CreateInsPlan(0, allowedFeeSched: fee.FeeSched); //Act like an ins plan has our fee schedule which should return the corresponding fees by GetListFromObjects(). List <Fee> listFees = Fees.GetListFromObjects(new List <ProcedureCode>() { procedureCode }, null, null, 0, 0, 0, new List <InsPlan>() { insPlan }, null, null, null, 0); Assert.IsTrue(listFees.Exists(x => x.FeeNum == fee.FeeNum)); }
public static void SetupClass(TestContext testContext) { //Add anything here that you want to run once before the tests in this class run. ProcedureCodeT.AddIfNotPresent("D0120"); ProcedureCodeT.AddIfNotPresent("D1110"); ProcedureCodeT.AddIfNotPresent("D0602"); ProcedureCodeT.AddIfNotPresent("D1206"); ProcedureCodes.RefreshCache(); //Refresh cache if the codes above were added _x271 = new X271(Properties.Resources.x271Test); }
public void RpProcNotBilledIns_GetProcsNotBilled_ShowProcsBeforeIns() { string suffix = MethodBase.GetCurrentMethod().Name; Patient patient = PatientT.CreatePatient(suffix); Carrier carrier = CarrierT.CreateCarrier(suffix); ProcedureCode procedureCode = ProcedureCodeT.CreateProcCode("T7782"); Procedure procedure = ProcedureT.CreateProcedure(patient, procedureCode.ProcCode, ProcStat.C, "", 55, procDate: DateTime.Now.AddDays(-3)); //Add insurance after the procedure has been set complete. InsuranceInfo insuranceInfo = InsuranceT.AddInsurance(patient, carrier.CarrierName, ordinal: 1, isMedical: true); //The patient should not be returned when 'showProcsBeforeIns' is set to false. DataTable table = RpProcNotBilledIns.GetProcsNotBilled(new List <long>(), false, DateTime.Now.AddDays(-10), DateTime.Now, false, false); Assert.IsNotNull(table); Assert.IsFalse(table.Select().Select(x => PIn.Long(x["PatNum"].ToString())).Contains(patient.PatNum)); //The patient should be returned when 'showProcsBeforeIns' is set to true. table = RpProcNotBilledIns.GetProcsNotBilled(new List <long>(), true, DateTime.Now.AddDays(-10), DateTime.Now, true, false); Assert.IsNotNull(table); Assert.IsTrue(table.Rows.Count > 0); Assert.IsTrue(table.Select().Select(x => PIn.Long(x["PatNum"].ToString())).Contains(patient.PatNum)); }
public void ProcedureCodes_GetProcCodesByTreatmentArea_MouthCodes() { string suffix = MethodBase.GetCurrentMethod().Name; List <ProcedureCode> listMouthProcCodesOld = ProcedureCodes.GetProcCodesByTreatmentArea(false, TreatmentArea.Mouth); int i = 0; do { i++; //Add a nonexisting proc code. }while(!ProcedureCodeT.AddIfNotPresent("D" + i.ToString().PadLeft(4, '0')) && i < 10000); ProcedureCode newProc = ProcedureCodes.GetOne("D" + i.ToString().PadLeft(4, '0')); newProc.TreatArea = TreatmentArea.Mouth; newProc.Descript = suffix; ProcedureCodeT.Update(newProc); List <ProcedureCode> listMouthProcCodesNew = ProcedureCodes.GetProcCodesByTreatmentArea(false, TreatmentArea.Mouth); Assert.IsFalse(listMouthProcCodesNew.Any(x => x.TreatArea != TreatmentArea.Mouth)); Assert.IsTrue((listMouthProcCodesOld.Count + 1) == listMouthProcCodesNew.Count); Assert.IsTrue(listMouthProcCodesNew.Exists(x => x.CodeNum == newProc.CodeNum)); }
public void Fees_GetListFromObjects_PatientFeeSched() { string suffix = MethodBase.GetCurrentMethod().Name; ProcedureCode procedureCode = ProcedureCodeT.CreateProcCode("D1110"); Fee fee = CreateSingleFee(suffix, (_defaultFeeAmt * _rand.NextDouble()), hasProv: true, codeNum: procedureCode.CodeNum); //Act like a patient has our fee schedule which should return the corresponding fees by GetListFromObjects(). List <Fee> listFees = Fees.GetListFromObjects(new List <ProcedureCode>() { procedureCode }, null, null, 0, 0, fee.FeeSched, null, null, null, null, 0); Assert.IsTrue(listFees.Exists(x => x.FeeNum == fee.FeeNum)); }