tests.test_engine.test_multiple_rules_engine() - Code Metrics - borfast/decision-engine - Measure and Improve Code Quality continuously with Scrutinizer

tests.test_engine.test_multiple_rules_engine() B
last analyzed 2024-07-15 20:51 UTC

↳ Parent: tests.test_engine

Complexity

Conditions

Size

Total Lines	60
Code Lines	48

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	48
dl	0
loc	60
rs	8.7018
c	0
b	0
f	0
cc	1
nop	5

How to fix Long Method

# coding=utf-8
import pytest

from decision_engine.comparisons import GreaterThanOrEqual, Equal, \
    LessThanOrEqual
from decision_engine.engine import Engine
from decision_engine.rules import SimpleComparisonRule, BooleanAndRule
from decision_engine.sources import DictSource, FixedValueSource, \
    PercentageSource


def test_single_stupid_rule_engine():
    hundred = FixedValueSource(100)
    five_thousand = FixedValueSource(5000)
    rule = SimpleComparisonRule(five_thousand, hundred, GreaterThanOrEqual())
    engine = Engine([rule])

    data = {}

    assert engine.decide(data) is True
    assert engine.__repr__() == f"Name: '{engine.name}' | " \
                                f"rules: {[r.name for r in engine.rules]}"


@pytest.mark.parametrize("salary, expected", [
    (100000, True),
    (10000, False)
])
def test_single_rule_engine(salary, expected):
    salary_percentage = PercentageSource(0.75, DictSource('salary'))
    minimum_salary = FixedValueSource(50000)
    rule = SimpleComparisonRule(salary_percentage, minimum_salary,
                                GreaterThanOrEqual())
    engine = Engine([rule])

    data = {
        'salary': salary
    }

    assert engine.decide(data) == expected


@pytest.mark.parametrize("air_miles, land_miles, age, vip, expected", [
    (5000, 1000, 37, 'yes', True),
    (1500, 1000, 37, 'yes', False),
    (5000, 5001, 37, 'yes', False),
    (5000, 1000, 16, 'yes', False),
    (5000, 1000, 70, 'yes', False),
    (5000, 1000, 37, 'no', False),
    (100, 50, 15, 'no', False)
])
def test_multiple_rules_engine(air_miles, land_miles, age, vip, expected):
    air_miles_source = DictSource('air_miles')
    minimum_miles_source = FixedValueSource(3500)
    minimum_air_miles_rule = SimpleComparisonRule(air_miles_source,
                                                  minimum_miles_source,
                                                  GreaterThanOrEqual())

    land_miles_source = DictSource('land_miles')
    less_land_than_air_miles_rule = SimpleComparisonRule(land_miles_source,
                                                         air_miles_source,
                                                         LessThanOrEqual())

    air_miles_percentage = PercentageSource(0.05, air_miles_source)
    air_miles_percentage_rule = SimpleComparisonRule(land_miles_source,
                                                     air_miles_percentage,
                                                     GreaterThanOrEqual())

    air_and_land_miles_rule = BooleanAndRule([minimum_air_miles_rule,
                                              less_land_than_air_miles_rule,
                                              air_miles_percentage_rule])

    age_source = DictSource('age')
    minimum_age_source = FixedValueSource(21)
    minimum_age_rule = SimpleComparisonRule(age_source, minimum_age_source,
                                            GreaterThanOrEqual())

    maximum_age_source = FixedValueSource(65)
    maximum_age_rule = SimpleComparisonRule(age_source, maximum_age_source,
                                            LessThanOrEqual())

    vip_status_source = DictSource('vip')
    positive_vip_status = FixedValueSource('yes')
    vip_status_rule = SimpleComparisonRule(vip_status_source,
                                           positive_vip_status,
                                           Equal())

    engine = Engine([
        air_and_land_miles_rule,
        minimum_age_rule,
        maximum_age_rule,
        vip_status_rule
    ])

    data = {
        'air_miles': air_miles,
        'land_miles': land_miles,
        'age': age,
        'vip': vip
    }

    assert engine.decide(data) == expected


1			# coding=utf-8
2			import pytest
3
4			from decision_engine.comparisons import GreaterThanOrEqual, Equal, \
5			LessThanOrEqual
6			from decision_engine.engine import Engine
7			from decision_engine.rules import SimpleComparisonRule, BooleanAndRule
8			from decision_engine.sources import DictSource, FixedValueSource, \
9			PercentageSource
10
11
12			def test_single_stupid_rule_engine():
13			hundred = FixedValueSource(100)
14			five_thousand = FixedValueSource(5000)
15			rule = SimpleComparisonRule(five_thousand, hundred, GreaterThanOrEqual())
16			engine = Engine([rule])
17
18			data = {}
19
20			assert engine.decide(data) is True
21			assert engine.__repr__() == f"Name: '{engine.name}' \| " \
22			f"rules: {[r.name for r in engine.rules]}"
23
24
25			@pytest.mark.parametrize("salary, expected", [
26			(100000, True),
27			(10000, False)
28			])
29			def test_single_rule_engine(salary, expected):
30			salary_percentage = PercentageSource(0.75, DictSource('salary'))
31			minimum_salary = FixedValueSource(50000)
32			rule = SimpleComparisonRule(salary_percentage, minimum_salary,
33			GreaterThanOrEqual())
34			engine = Engine([rule])
35
36			data = {
37			'salary': salary
38			}
39
40			assert engine.decide(data) == expected
41
42
43			@pytest.mark.parametrize("air_miles, land_miles, age, vip, expected", [
44			(5000, 1000, 37, 'yes', True),
45			(1500, 1000, 37, 'yes', False),
46			(5000, 5001, 37, 'yes', False),
47			(5000, 1000, 16, 'yes', False),
48			(5000, 1000, 70, 'yes', False),
49			(5000, 1000, 37, 'no', False),
50			(100, 50, 15, 'no', False)
51			])
52			def test_multiple_rules_engine(air_miles, land_miles, age, vip, expected):
53			air_miles_source = DictSource('air_miles')
54			minimum_miles_source = FixedValueSource(3500)
55			minimum_air_miles_rule = SimpleComparisonRule(air_miles_source,
56			minimum_miles_source,
57			GreaterThanOrEqual())
58
59			land_miles_source = DictSource('land_miles')
60			less_land_than_air_miles_rule = SimpleComparisonRule(land_miles_source,
61			air_miles_source,
62			LessThanOrEqual())
63
64			air_miles_percentage = PercentageSource(0.05, air_miles_source)
65			air_miles_percentage_rule = SimpleComparisonRule(land_miles_source,
66			air_miles_percentage,
67			GreaterThanOrEqual())
68
69			air_and_land_miles_rule = BooleanAndRule([minimum_air_miles_rule,
70			less_land_than_air_miles_rule,
71			air_miles_percentage_rule])
72
73			age_source = DictSource('age')
74			minimum_age_source = FixedValueSource(21)
75			minimum_age_rule = SimpleComparisonRule(age_source, minimum_age_source,
76			GreaterThanOrEqual())
77
78			maximum_age_source = FixedValueSource(65)
79			maximum_age_rule = SimpleComparisonRule(age_source, maximum_age_source,
80			LessThanOrEqual())
81
82			vip_status_source = DictSource('vip')
83			positive_vip_status = FixedValueSource('yes')
84			vip_status_rule = SimpleComparisonRule(vip_status_source,
85			positive_vip_status,
86			Equal())
87
88			engine = Engine([
89			air_and_land_miles_rule,
90			minimum_age_rule,
91			maximum_age_rule,
92			vip_status_rule
93			])
94
95			data = {
96			'air_miles': air_miles,
97			'land_miles': land_miles,
98			'age': age,
99			'vip': vip
100			}
101
102			assert engine.decide(data) == expected
103

borfast / decision-engine

tests.test_engine.test_multiple_rules_engine() B last analyzed 2024-07-15 20:51 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

tests.test_engine.test_multiple_rules_engine() B
last analyzed 2024-07-15 20:51 UTC