public void Fees_Import()
{
FeeTestArgs args = CreateManyFees(1, 1, 1, MethodBase.GetCurrentMethod().Name);
FeeCache cache = new FeeCache();
List <Fee> listImportedFees = cache.GetListFees(args.emptyFeeSchedNum, 0, 0);
foreach (Fee fee in cache.GetListFees(_standardFeeSchedNum, 0, 0))
{
string codeText = _listProcCodes.Where(x => x.CodeNum == fee.CodeNum).Select(x => x.ProcCode).FirstOrDefault();
listImportedFees = Fees.Import(codeText, fee.Amount, args.emptyFeeSchedNum, fee.ClinicNum, fee.ProvNum, listImportedFees);
}
Fees.InsertMany(listImportedFees);
//Not able to use CollectionsAssert AreEqual because the FeeNums will be different
for (int i = 0; i < listImportedFees.Count; i++)
{
Fee fee = listImportedFees[i];
Fee originalFee = cache.GetFee(fee.CodeNum, _standardFeeSchedNum, fee.ClinicNum, fee.ProvNum);
try {
Assert.AreEqual(originalFee.Amount, fee.Amount);
}
catch (Exception e) {
throw new Exception("Import failed for fee at index :" + i + " with CodeNum=" + fee.CodeNum + " Inner:" + e.Message);
}
}
}
public void FeeCache_Transaction()
{
FeeTestArgs args = CreateManyFees(2, 6, 2, MethodBase.GetCurrentMethod().Name);
List <Tuple <Fee, long> > listChanges = new List <Tuple <Fee, long> >();
List <Fee> listFeesToUse = args.ListFees.OrderBy(x => _rand.Next()).Take(100).ToList();
FeeCache cache = new FeeCache();
cache.BeginTransaction();
foreach (Fee fee in listFeesToUse)
{
int flip = _rand.Next(2);
Fee newFee = null;
switch (flip)
{
case 0:
newFee = new Fee()
{
FeeSched = args.emptyFeeSchedNum,
Amount = _defaultFeeAmt,
CodeNum = _listProcCodes[_rand.Next(_listProcCodes.Count - 1)].CodeNum,
ClinicNum = args.ListClinics[_rand.Next(args.ListClinics.Count - 1)].ClinicNum,
};
args.ListFees.Add(newFee);
cache.Add(newFee);
break;
case 1:
fee.Amount = fee.Amount * _rand.NextDouble();
cache.Update(fee);
break;
case 2:
cache.Remove(fee);
args.ListFees.Remove(fee);
break;
}
listChanges.Add(Tuple.Create <Fee, long>(newFee ?? fee, flip));
}
cache.SaveToDb();
foreach (Tuple <Fee, long> change in listChanges)
{
Fee fee = change.Item1;
switch (change.Item2)
{
case 0:
Assert.IsNotNull(cache.GetFee(fee.CodeNum, fee.FeeSched, fee.ClinicNum, fee.ProvNum, true));
break;
case 1:
Assert.AreEqual(fee.Amount, cache.GetAmount0(fee.CodeNum, fee.FeeSched, fee.ClinicNum, fee.ProvNum), 0.01);
break;
case 2:
Assert.IsNull(cache.GetFee(fee.CodeNum, fee.FeeSched, fee.ClinicNum, fee.ProvNum, true));
break;
}
}
}
public void FeeSchedTools_ClearFeeSchedule()
{
FeeTestArgs feeArgs = CreateManyFees(1, 1, 1, MethodBase.GetCurrentMethod().Name);
long feeSchedNum = feeArgs.ListFeeSchedNums[0];
Assert.IsTrue(Fees.GetCountByFeeSchedNum(feeSchedNum) > 0);
Fees.DeleteFees(feeSchedNum, feeArgs.ListClinics[0].ClinicNum, feeArgs.ListProvNums[0]);
Assert.AreEqual(0, Fees.GetCountByFeeSchedNum(feeSchedNum));
}
public void FeeCache_AddClinic()
{
FeeTestArgs args = CreateManyFees(1, 1, 1, MethodBase.GetCurrentMethod().Name);
FeeCache cache = new FeeCache();
List <Fee> listExpectedFees = args.ListFees.Where(x => x.ClinicNum == args.ListClinics.Select(y => y.ClinicNum).Last()).OrderBy(x => x.FeeNum).ToList();
List <Fee> listActualFees = cache.GetFeesForClinic(args.ListClinics.Select(y => y.ClinicNum).Last()).OrderBy(x => x.FeeNum).ToList();
Assert.IsTrue(AreListsSimilar(listExpectedFees, listActualFees));
}
/// <summary>Creates the request number of fee schedules, clinics and providers, and creates fees for each combination and code num.</summary>
private FeeTestArgs CreateManyFees(int numFeeScheds, int numClinics, int numProvs, string suffix)
{
FeeTestArgs retVal = new FeeTestArgs();
//Set up fee schedules
for (int i = 0; i < numFeeScheds; i++)
{
retVal.ListFeeSchedNums.Add(FeeSchedT.CreateFeeSched(FeeScheduleType.Normal, suffix, false));
}
//Set up clinics
Prefs.UpdateBool(PrefName.EasyNoClinics, false);
for (int i = 0; i < numClinics; i++)
{
retVal.ListClinics.Add(ClinicT.CreateClinic(suffix + i));
}
//Set up providers
for (int i = 0; i < numProvs; i++)
{
retVal.ListProvNums.Add(ProviderT.CreateProvider(suffix));
}
//Create the fees
List <Fee> listFees = new List <Fee>();
foreach (long codeNum in _listProcCodes.Select(x => x.CodeNum))
{
foreach (long feeSchedNum in retVal.ListFeeSchedNums)
{
foreach (Clinic clinic in retVal.ListClinics)
{
foreach (long provNum in retVal.ListProvNums)
{
listFees.Add(new Fee()
{
FeeSched = feeSchedNum,
ClinicNum = clinic.ClinicNum,
ProvNum = provNum,
CodeNum = codeNum,
Amount = _defaultFeeAmt * _rand.NextDouble()
});
}
}
}
}
Fees.InsertMany(listFees);
retVal.ListFees = Fees.GetByFeeSchedNumsClinicNums(retVal.ListFeeSchedNums, retVal.ListClinics.Select(x => x.ClinicNum).ToList())
.Union(Fees.GetByFeeSchedNumsClinicNums(new List <long>()
{
_standardFeeSchedNum
}, new List <long>()
{
0
})).ToList();
//create an empty feeschedule for the Insert/Update/Delete tests
retVal.emptyFeeSchedNum = FeeSchedT.CreateFeeSched(FeeScheduleType.Normal, "Empty" + suffix, false);
return(retVal);
}
public void Fees_InvalidateFeeSchedules()
{
FeeTestArgs args = CreateManyFees(3, 1, 1, MethodBase.GetCurrentMethod().Name);
FeeCache cache = new FeeCache(args.ListFees);
Fee fee1 = args.ListFees.First();
Fee fee2 = args.ListFees.First(x => x.FeeSched != fee1.FeeSched);
Fee fee3 = args.ListFees.First(x => x.FeeSched != fee2.FeeSched);
cache.Invalidate(fee1.FeeSched);
cache.Invalidate(fee2.FeeSched);
Assert.AreEqual(fee1.Amount, cache.GetFee(fee1.CodeNum, fee1.FeeSched, fee1.ClinicNum, fee1.ProvNum).Amount);
Assert.AreEqual(fee2.Amount, cache.GetFee(fee2.CodeNum, fee2.FeeSched, fee2.ClinicNum, fee2.ProvNum).Amount);
Assert.AreEqual(fee3.Amount, cache.GetFee(fee3.CodeNum, fee3.FeeSched, fee3.ClinicNum, fee3.ProvNum).Amount);
}
public void FeeCache_Initialize()
{
FeeTestArgs args = CreateManyFees(1, 1, 1, MethodBase.GetCurrentMethod().Name);
Clinics.ClinicNum = args.ListClinics.First().ClinicNum;
FeeCache cache = new FeeCache();
//If we are running multiple tests, it is possible that some additional fees with clinic 0 were created, and these would be loaded into the cache,
//which is the correct behavior. To check this is right, first check that all of the expected fees are there
List <Fee> listExpected = args.ListFees.OrderBy(x => x.FeeNum).ToList();
List <Fee> listActual = cache.Where(x => x.FeeSched == _standardFeeSchedNum || args.ListFeeSchedNums.Contains(x.FeeSched)).OrderBy(x => x.FeeNum).ToList();
Assert.IsTrue(AreListsSimilar(listExpected, listActual));
//Second, we check to make sure that no additional clinics, beyond HQ and the current clinic were loaded into the cache.
Assert.IsNull(cache.Where(x => x.ClinicNum != 0 && x.ClinicNum != Clinics.ClinicNum).FirstOrDefault());
}
public void Fees_FillCache()
{
FeeTestArgs args = CreateManyFees(1, 1, 1, MethodBase.GetCurrentMethod().Name);
Clinics.ClinicNum = args.ListClinics.First().ClinicNum;
List <Fee> listExpectedFees = args.ListFees.OrderBy(x => x.FeeNum).ToList();
Fees.FillCache();
FeeCache cacheCopy = Fees.GetCache();
//It is possible another test created a fee with a different fee schednum and clinicNum=0. The fee cache *should* load these if they exist
//but for the purpose of the test it is simpler to just exclude them here.
List <Fee> listCachedFees = cacheCopy.Where(x => !(x.ClinicNum == 0 && x.FeeSched != _standardFeeSchedNum)).OrderBy(x => x.FeeNum).ToList();
Assert.IsTrue(AreListsSimilar(listExpectedFees, listCachedFees));
}
public void FeeCache_GetCopy()
{
FeeTestArgs args = CreateManyFees(5, 3, 2, MethodBase.GetCurrentMethod().Name);
FeeCache cache = new FeeCache();
cache.GetFeesForClinics(args.ListClinics.Select(x => x.ClinicNum)); //load these clinics into memory
long invalidatedFeeSched = args.ListFeeSchedNums.Last();
Fee fee = args.ListFees.First(x => x.FeeSched == invalidatedFeeSched);
//Before we invalidate the fee sched, make sure it's actually in our cache
Assert.AreEqual(fee.Amount, cache.GetFee(fee.CodeNum, fee.FeeSched, fee.ClinicNum, fee.ProvNum).Amount);
cache.Invalidate(invalidatedFeeSched);
FeeCache copiedCache = (FeeCache)cache.GetCopy();
Assert.AreEqual(fee.Amount, copiedCache.GetFee(fee.CodeNum, fee.FeeSched, fee.ClinicNum, fee.ProvNum).Amount);
}
public void FeeSchedTools_ImportExport()
{
FeeTestArgs feeArgs = CreateManyFees(1, 1, 1, MethodBase.GetCurrentMethod().Name);
long exportedSched = feeArgs.ListFeeSchedNums[0];
long importedSched = feeArgs.EmptyFeeSchedNum;
long clinicNum = feeArgs.ListClinics[0].ClinicNum;
string filename = MethodBase.GetCurrentMethod().Name;
FeeScheds.ExportFeeSchedule(exportedSched, clinicNum, feeArgs.ListProvNums[0], filename);
OpenDental.FeeL.ImportFees(filename, importedSched, clinicNum, feeArgs.ListProvNums[0]);
foreach (ProcedureCode procCode in _listProcCodes.Where(x => !string.IsNullOrWhiteSpace(x.ProcCode))) //unable to import without a proccodes
{
Fee expected = Fees.GetFee(procCode.CodeNum, exportedSched, clinicNum, feeArgs.ListProvNums[0]);
Fee actual = Fees.GetFee(procCode.CodeNum, importedSched, clinicNum, feeArgs.ListProvNums[0]);
Assert.AreEqual(expected.Amount, actual.Amount);
}
}
public void FeeSchedTools_Increase()
{
FeeTestArgs args = CreateManyFees(0, 0, 0, MethodBase.GetCurrentMethod().Name);
int percent = 5;
List <Fee> listStandardFees = Fees.GetListExact(_standardFeeSchedNum, 0, 0).OrderBy(x => x.FeeNum).ToList();
List <Fee> listIncreasedFees = listStandardFees.Select(x => x.Copy()).ToList();
listIncreasedFees = Fees.IncreaseNew(_standardFeeSchedNum, percent, 2, listIncreasedFees, 0, 0).OrderBy(x => x.FeeNum).ToList();
foreach (Fee fee in listIncreasedFees)
{
Fee expectedFee = Fees.GetFee(fee.CodeNum, fee.FeeSched, fee.ClinicNum, fee.ProvNum);
double amount = fee.Amount / (1 + (double)percent / 100);
amount = Math.Round(amount, 2);
try {
Assert.AreEqual(expectedFee.Amount, amount);
}
catch (Exception e) {
throw new Exception("Failed for fee: " + expectedFee.FeeNum, e);
}
}
}
