示例#1
0
        /// <summary>
        /// Initializes a new instance of the <see cref="PaymentTypeMedicareSequesterController"/> class.
        /// </summary>
        public PaymentTypeMedicareSequesterController()
        {
            int    facilityId       = Convert.ToInt32(System.Web.HttpContext.Current.Request.Headers[Constants.BubbleDataSource]);
            string bubbleDataSource = GetFacilityConnection(facilityId);

            _paymentTypeMedicareSequesterLogic = new PaymentTypeMedicareSequesterLogic(bubbleDataSource);
        }
        public void PaymentTypeMedicareSequesterConstructorUnitTest2()
        {
            var mockAddNewPaymentTypeMedicareSequester = new Mock <IPaymentTypeMedicareSequesterRepository>();
            PaymentTypeMedicareSequesterLogic target   = new PaymentTypeMedicareSequesterLogic(mockAddNewPaymentTypeMedicareSequester.Object);

            Assert.IsInstanceOfType(target, typeof(PaymentTypeMedicareSequesterLogic));
        }
        public void PaymentTypeMedicareSequesterParameterlessConstructorUnitTest()
        {
            var target = new PaymentTypeMedicareSequesterLogic(Constants.ConnectionString);

            //Assert
            Assert.IsInstanceOfType(target, typeof(PaymentTypeMedicareSequesterLogic));
        }
        public void PaymentTypeMedicareSequesterConstructorUnitTest1()
        {
            PaymentTypeMedicareSequesterRepository medicareSequesterRepository = new PaymentTypeMedicareSequesterRepository(Constants.ConnectionString);

            _target = new PaymentTypeMedicareSequesterLogic(medicareSequesterRepository);
            Assert.IsInstanceOfType(_target, typeof(PaymentTypeMedicareSequesterLogic));
        }
        public void AddNewPaymentTypeMedicareSequesterValueIfNullTest()
        {
            var mockAddNewPaymentTypeMedicareSequester = new Mock <IPaymentTypeMedicareSequesterRepository>();

            mockAddNewPaymentTypeMedicareSequester.Setup(f => f.AddEditPaymentTypeMedicareSequester(It.IsAny <PaymentTypeMedicareSequester>())).Returns(0);
            PaymentTypeMedicareSequesterLogic target = new PaymentTypeMedicareSequesterLogic(mockAddNewPaymentTypeMedicareSequester.Object);
            long actual = target.AddEditPaymentType(null);

            Assert.AreEqual(0, actual);
        }
        public void AddNewPaymentTypeMedicareSequesterValueTest()
        {
            var mockAddNewPaymentTypeMedicareSequester = new Mock <IPaymentTypeMedicareSequesterRepository>();

            mockAddNewPaymentTypeMedicareSequester.Setup(f => f.AddEditPaymentTypeMedicareSequester(It.IsAny <PaymentTypeMedicareSequester>())).Returns(1);
            PaymentTypeMedicareSequesterLogic target = new PaymentTypeMedicareSequesterLogic(mockAddNewPaymentTypeMedicareSequester.Object);
            PaymentTypeMedicareSequester      paymentTypeMedicareSequester = new PaymentTypeMedicareSequester {
                PaymentTypeDetailId = 1
            };
            long actual = target.AddEditPaymentType(paymentTypeMedicareSequester);

            Assert.AreEqual(1, actual);
        }
        public void GetPaymentTypeMedicareSequesterIfParameterIsNullTest()
        {
            //Mock Input
            PaymentTypeMedicareSequester paymentTypePercentageDiscount = new PaymentTypeMedicareSequester {
                PaymentTypeId = 0, ContractId = 0, ServiceTypeId = 0
            };
            //Mock output
            PaymentTypeMedicareSequester expectedResult = new PaymentTypeMedicareSequester {
                Percentage = 0, PaymentTypeDetailId = 0
            };
            var mockGetPaymentTypeMedicareSequester = new Mock <IPaymentTypeMedicareSequesterRepository>();

            mockGetPaymentTypeMedicareSequester.Setup(f => f.GetPaymentTypeMedicareSequester(paymentTypePercentageDiscount)).Returns(expectedResult);
            PaymentTypeMedicareSequesterLogic target = new PaymentTypeMedicareSequesterLogic(mockGetPaymentTypeMedicareSequester.Object);
            PaymentTypeMedicareSequester      actual = (PaymentTypeMedicareSequester)target.GetPaymentType(paymentTypePercentageDiscount);

            Assert.AreEqual(expectedResult.Percentage, actual.Percentage);
            Assert.AreEqual(expectedResult.PaymentTypeDetailId, actual.PaymentTypeDetailId);
        }
        public void EvaluateIfAdjudicatedValueIsNotNullTest()
        {
            List <PaymentResult> paymentResults = new List <PaymentResult>
            {
                new PaymentResult {
                    ClaimId = 123, AdjudicatedValue = 350, ClaimTotalCharges = 110, ServiceTypeId = 1
                },
                new PaymentResult {
                    ClaimId = 123, Line = 1, AdjudicatedValue = 85, ClaimTotalCharges = 110, ServiceTypeId = 1
                }
            };
            // Arrange
            var mockContractServiceTypeLogic = new Mock <IContractServiceTypeLogic>();
            var mockPaymentResultLogic       = new Mock <IPaymentResultLogic>();

            mockPaymentResultLogic.Setup(
                x =>
                x.Evaluate(It.IsAny <EvaluateableClaim>(), It.IsAny <List <PaymentResult> >(), It.IsAny <bool>(),
                           It.IsAny <bool>())).Returns(paymentResults);
            Mock <IPaymentTypeMedicareSequesterRepository> paymentTypeMedicareSequesterRepository = new Mock <IPaymentTypeMedicareSequesterRepository>();

            paymentTypeMedicareSequesterRepository.Setup(x => x.GetPaymentTypeMedicareSequester(It.IsAny <PaymentTypeMedicareSequester>()))
            .Returns(new PaymentTypeMedicareSequester());

            PaymentTypeMedicareSequester paymentTypeMedicareSequester = new PaymentTypeMedicareSequester
            {
                Conditions = new List <ICondition>
                {
                    new Condition
                    {
                        ConditionOperator = (byte)Enums.ConditionOperation.EqualTo,
                        LeftOperands      = new List <string> {
                            "300"
                        },
                        OperandType  = (byte)Enums.OperandIdentifier.HcpcsCode,
                        RightOperand = "300"
                    }
                },
                ServiceTypeId = 1,
                ValidLineIds  = new List <int> {
                    1, 2
                },
                HcpcsCode  = "ABCDE",
                ContractId = 1,
                Percentage = 50
            };

            _target = new PaymentTypeMedicareSequesterLogic(paymentTypeMedicareSequesterRepository.Object)
            {
                PaymentTypeBase = paymentTypeMedicareSequester
            };

            IEvaluateableClaim evaluateableClaim = new EvaluateableClaim
            {
                PatientResponsibility = 25
            };

            evaluateableClaim.ClaimId      = 123;
            evaluateableClaim.ClaimTotal   = 100;
            evaluateableClaim.ClaimCharges = new List <ClaimCharge>
            {
                new ClaimCharge
                {
                    Line    = 1,
                    Amount  = 20,
                    RevCode = "250"
                }
            };

            List <PaymentResult> updatedPaymentResults = new List <PaymentResult>
            {
                new PaymentResult {
                    ClaimId = 123, ContractId = 1, AdjudicatedValue = 110, ClaimTotalCharges = 110, ServiceTypeId = 1
                },
                new PaymentResult {
                    ClaimId = 123, Line = 1, ContractId = 1, AdjudicatedValue = 110, ClaimTotalCharges = 110, ServiceTypeId = 1
                }
            };

            Mock <ContractBaseLogic> mockContractBaseLogic = new Mock <ContractBaseLogic>();

            mockContractServiceTypeLogic.Setup(x => x.Evaluate(evaluateableClaim, paymentResults, false, false))
            .Returns(updatedPaymentResults);
            mockContractBaseLogic.SetupAllProperties();

            //Act
            List <PaymentResult> actual = _target.EvaluatePaymentType(evaluateableClaim, paymentResults, false, false);

            // Assert
            Assert.AreEqual(2, actual.Count);
            var firstOrDefault = paymentResults.FirstOrDefault();

            if (firstOrDefault != null)
            {
                Assert.AreEqual(162.5, firstOrDefault.MedicareSequesterAmount);
            }
            if (firstOrDefault != null)
            {
                Assert.AreEqual(187.5, firstOrDefault.AdjudicatedValue);
            }
        }