public void Should_return_Maximum_Constants_for_Social_Engine_when_Year_2013()
{
IEnginesHistory <ISocialEngine> engines = SocialEnginesHistory.CreateEngines();
ISocialEngine engine = engines.ResolveEngine(testPeriod);
Assert.AreEqual(1242432m, engine.PeriodMaximumAnnualBasis(testPeriod));
}
public void Should_return_Maximum_Constants_for_Health_Engine_when_Year_2013()
{
IEnginesHistory <IHealthEngine> engines = HealthEnginesHistory.CreateEngines();
IHealthEngine engine = engines.ResolveEngine(testPeriod);
Assert.AreEqual(0, engine.PeriodMaximumAnnualBasis(testPeriod));
}
public void Should_return_Weekly_Seconds_Constants_for_Period_Engine_when_Year_2015()
{
IEnginesHistory <IPeriodEngine> engines = PeriodEnginesHistory.CreateEngines();
IPeriodEngine engine = engines.ResolveEngine(testPeriod);
Assert.AreEqual(144000, engine.PeriodWeeklyWorkingSeconds(testPeriod));
}
public void Should_return_Factor_Constants_for_Health_Engine_when_Year_2013()
{
IEnginesHistory <IHealthEngine> engines = HealthEnginesHistory.CreateEngines();
IHealthEngine engine = engines.ResolveEngine(testPeriod);
Assert.AreEqual(13.5m, engine.PeriodCompoundFactor(testPeriod));
}
public void Should_return_Minimum_Constants_for_Social_Engine_when_Year_2012()
{
IEnginesHistory <ISocialEngine> engines = SocialEnginesHistory.CreateEngines();
ISocialEngine engine = engines.ResolveEngine(testPeriod);
Assert.AreEqual(0, engine.PeriodMandatoryBasis(testPeriod));
}
public static IEnginesHistory <ITaxingEngine> CreateEngines()
{
IEnginesHistory <ITaxingEngine> engine = CreateInstance();
engine.InitEngines();
return(engine);
}
public void Should_return_HealthEngine2015_for_DefaultEngine_when_Year_2015()
{
IEnginesHistory <IHealthEngine> engines = HealthEnginesHistory.CreateEngines();
IHealthEngine engine2015 = engines.DefaultEngine();
Assert.AreEqual(FULL_CLASS_NAME_2015, engine2015.GetType().ToString());
}
public static IEnginesHistory <ITaxingEngine> CreateEngines(Assembly setupAssembly)
{
IEnginesHistory <ITaxingEngine> enginesHistory = CreateInstance();
enginesHistory.InitEngines(setupAssembly);
return(enginesHistory);
}
public void Should_return_TaxingEngine2013_for_ClassNameEngine_when_Year_2013()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
MonthPeriod period2013 = new MonthPeriod(2013, 1);
ITaxingEngine engine2013 = engines.ResolveEngine(period2013);
Assert.AreEqual(FULL_CLASS_NAME_2013, engine2013.GetType().ToString());
}
public void Should_return_PeriodEngine2015_for_ClassNameEngine_when_Year_2014()
{
IEnginesHistory <IPeriodEngine> engines = PeriodEnginesHistory.CreateEngines();
MonthPeriod period2014 = new MonthPeriod(2014, 1);
IPeriodEngine engine2014 = engines.ResolveEngine(period2014);
Assert.AreEqual(FULL_CLASS_NAME_2015, engine2014.GetType().ToString());
}
public void Should_return_Minimum_Constants_for_Health_Engine_when_Month_12_2013()
{
MonthPeriod testPeriod12 = new MonthPeriod(2013, 12);
IEnginesHistory <IHealthEngine> engines = HealthEnginesHistory.CreateEngines();
IHealthEngine engine = engines.ResolveEngine(testPeriod12);
Assert.AreEqual(8500, engine.PeriodMandatoryBasis(testPeriod12));
}
public void Should_return_Factor_Constants_for_Taxing_Engine_when_Year_2015()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
Assert.AreEqual(15.0m, engine.PeriodAdvancesFactor(testPeriod));
Assert.AreEqual(15.0m, engine.PeriodWithholdFactor(testPeriod));
Assert.AreEqual(7.0m, engine.PeriodSolidaryFactor(testPeriod));
}
public void Should_return_Maximum_Constants_for_Taxing_Engine_when_Year_2015()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
Assert.AreEqual(5025, engine.PeriodMaximumValidAmountOfTaxBonus(testPeriod));
Assert.AreEqual(100, engine.PeriodMaximumIncomeToApplyRoundingToSingles(testPeriod));
Assert.AreEqual(10000, engine.PeriodMaximumIncomeToApplyWithholdTax(testPeriod));
}
public void Should_return_SocialEngine2012_for_ClassNameEngine_when_Year_2012()
{
IEnginesHistory <ISocialEngine> engines = SocialEnginesHistory.CreateEngines();
MonthPeriod period2012 = new MonthPeriod(2012, 1);
ISocialEngine engine2012 = engines.ResolveEngine(period2012);
Assert.AreEqual(FULL_CLASS_NAME_2012, engine2012.GetType().ToString());
}
public void Should_return_HealthEngine2011_for_ClassNameEngine_when_Year_2011()
{
IEnginesHistory <IHealthEngine> engines = HealthEnginesHistory.CreateEngines();
MonthPeriod period2011 = new MonthPeriod(2011, 1);
IHealthEngine engine2011 = engines.ResolveEngine(period2011);
Assert.AreEqual(FULL_CLASS_NAME_2011, engine2011.GetType().ToString());
}
public void Should_return_Minimum_Constants_for_Taxing_Engine_when_Year_2015()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
Assert.AreEqual(50, engine.PeriodMinimumValidAmountOfTaxBonus(testPeriod));
Assert.AreEqual(8500, engine.PeriodMinimumIncomeRequiredForTaxBonus(testPeriod));
Assert.AreEqual(103768, engine.PeriodMinimumIncomeToApplySolidaryIncrease(testPeriod));
}
public void Should_return_100_for_Advances_Basis_when_Income_is_100_00()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
decimal testIncome = 100.00m;
decimal resultValue = engine.AdvancesRoundedBasis(testPeriod, testIncome);
Assert.AreEqual(100, resultValue);
}
public void Should_return_200_for_Withhold_Basis_when_Income_is_100_01()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
decimal testIncome = 100.01m;
decimal resultValue = engine.WithholdRoundedBasis(testPeriod, testIncome);
Assert.AreEqual(101, resultValue);
}
public void Should_return_17_467_for_Regulary_Tax_when_Income_is_116_444_CZK()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
decimal testIncome = 116444m;
decimal resultValue = engine.WithholdResultTax(testPeriod, testIncome);
Assert.AreEqual(17467m, resultValue);
}
public void Should_return_1500_for_Regulary_Tax_when_Regulary_Basis_is_10_000_CZK()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
decimal testIncome = 10000m;
decimal resultValue = engine.WithholdResultTax(testPeriod, testIncome);
Assert.AreEqual(1500m, resultValue);
}
public void Should_return_0_for_Solidary_Basis_when_Income_is_106_443_CZK()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
decimal testIncome = 106443m;
decimal resultValue = engine.AdvancesSolidaryBasis(testPeriod, testIncome);
Assert.AreEqual(0m, resultValue);
}
public void Should_return_Factor_Constants_for_Social_Engine_when_Year_2013()
{
IEnginesHistory <ISocialEngine> engines = SocialEnginesHistory.CreateEngines();
ISocialEngine engine = engines.ResolveEngine(testPeriod);
Assert.AreEqual(6.5m, engine.PeriodEmployeeFactor(testPeriod, PENSION_SCHEME_NON));
Assert.AreEqual(3.5m, engine.PeriodEmployeeFactor(testPeriod, PENSION_SCHEME_YES));
Assert.AreEqual(5.0m, engine.PeriodEmployeeGarantFactor(testPeriod));
Assert.AreEqual(3.0m, engine.PeriodPensionsReduceFactor(testPeriod));
Assert.AreEqual(25.0m, engine.PeriodEmployerFactor(testPeriod));
Assert.AreEqual(26.0m, engine.PeriodEmployerElevatedFactor(testPeriod));
}
public void Should_return_10_000_for_Garant_Basis_when_Basis_is_10_000_CZK_and_Garant_Scheme_is_ON()
{
IEnginesHistory <ISocialEngine> engines = SocialEnginesHistory.CreateEngines();
ISocialEngine engine = engines.ResolveEngine(testPeriod);
decimal testEmployeeBasis = 10000m;
decimal resultValue = engine.PensionCalculatedBasis(testPeriod,
GARANT_SCHEME_YES, testEmployeeBasis);
Assert.AreEqual(10000m, resultValue);
}
public void Should_return_335_for_Study_Allowance_when_Signed_Declaration_and_Residet_CZECH()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
bool testStatementSigned = true;
Int32 resultValue = engine.StatementPayerStudyAllowance(testPeriod,
testStatementSigned);
Assert.AreEqual(335, resultValue);
}
public void Should_return_900_for_Health_Increase_when_Income_is_10_000_CZK()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
bool testWithholdTaxing = true;
decimal testIncome = 10000m;
decimal resultValue = engine.WithholdTaxableHealth(testPeriod, testWithholdTaxing, testIncome);
Assert.AreEqual(900m, resultValue);
}
public void Should_return_1501_for_Social_Increase_when_Income_is_6_003_CZK()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
bool testWithholdTaxing = true;
decimal testIncome = 6003m;
decimal resultValue = engine.WithholdTaxableSocial(testPeriod, testWithholdTaxing, testIncome);
Assert.AreEqual(1501m, resultValue);
}
public void Should_return_2500_for_Social_Increase_when_Income_is_10_000_CZK()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
bool testAdvancesTaxing = true;
decimal testIncome = 10000m;
decimal resultValue = engine.AdvancesTaxableSocial(testPeriod, testAdvancesTaxing, testIncome);
Assert.AreEqual(2500m, resultValue);
}
public void Should_return_540_for_Health_Increase_when_Income_is_6_003_CZK()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
bool testAdvancesTaxing = true;
decimal testIncome = 6003m;
decimal resultValue = engine.AdvancesTaxableHealth(testPeriod, testAdvancesTaxing, testIncome);
Assert.AreEqual(540m, resultValue);
}
public void Should_return_500_for_Payment_when_Basis_is_10_000_CZK()
{
IEnginesHistory <ISocialEngine> engines = SocialEnginesHistory.CreateEngines();
ISocialEngine engine = engines.ResolveEngine(testPeriod);
decimal testEmployeeBasis = 10000m;
bool testNegativeSuppress = true;
decimal resultValue = engine.EmployeeGarantContribution(testPeriod,
testNegativeSuppress, testEmployeeBasis);
Assert.AreEqual(500m, resultValue);
}
public void Should_return_Zero_for_Withhold_Selector_when_Income_is_1000_and_Withhold_Taxing_is_False()
{
IEnginesHistory <ITaxingEngine> engines = TaxingEnginesHistory.CreateEngines();
ITaxingEngine engine = engines.ResolveEngine(testPeriod);
bool testWithholdTaxing = false;
decimal testIncome = 1000m;
decimal resultValue = engine.WithholdTaxSelector(testPeriod,
testWithholdTaxing, testIncome);
Assert.AreEqual(0, resultValue);
}
