source: geniuswebcore/test/geniusweb/bidspace/pareto/PartialParetoTest.py@ 100

from decimal import Decimal
from typing import Set, Dict
import unittest
from unittest.mock import Mock

from geniusweb.bidspace.pareto.PartialPareto import PartialPareto
from geniusweb.issuevalue.Bid import Bid
from geniusweb.issuevalue.DiscreteValueSet import DiscreteValueSet
from geniusweb.issuevalue.Domain import Domain
from geniusweb.issuevalue.NumberValue import NumberValue
from geniusweb.issuevalue.NumberValueSet import NumberValueSet
from geniusweb.issuevalue.Value import Value
from geniusweb.issuevalue.ValueSet import ValueSet
from geniusweb.profile.utilityspace.LinearAdditive import LinearAdditive


class PartialParetoTest(unittest.TestCase):
        D0_0 = Decimal(0)
        D0_2 = Decimal("0.2")
        D0_1 = Decimal("0.1")
        D0_3 = Decimal("0.3")
        D0_4 = Decimal("0.4")
        D0_5 = Decimal("0.5")

        space1 = Mock(LinearAdditive)
        space2 = Mock(LinearAdditive)

        domain = Mock(Domain)
        issues:Set[str] = set(["issue1", "issue2"])
        value1a = Mock(Value)
        value1b = Mock(Value)
        value2a = Mock(Value) 
        value2b = Mock(Value)

        def setUp(self):

                map:Dict[str, Value] = {}
                map["issue1"] = self.value1a
                self.bid10 = Bid(map)
                map["issue1"] = self.value1b
                self.bid20 = Bid(map)

                map = {}
                map["issue2"] = self.value2a
                self.bid01 = Bid(map)
                map["issue2"] = self.value2b
                self.bid02 = Bid(map)

                self.space1.getUtility = Mock(side_effect=lambda b: \
                        {self.bid10:self.D0_1, self.bid20:self.D0_2, \
                        self.bid01:self.D0_0, self.bid02:self.D0_0 }[b]) 
                self.space2.getUtility = Mock(side_effect=lambda b: \
                        {self.bid10:self.D0_0, self.bid20:self.D0_0, \
                        self.bid01:self.D0_0, self.bid02:self.D0_2 }[b]) 

                self.space1.getDomain = Mock(return_value=self.domain)
                self.domain.getIssues = Mock(return_value=self.issues)
                self.issue1valueset = DiscreteValueSet([self.value1a, self.value1b])
                self.domain.getValues = Mock(side_effect=lambda iss:\
                                        {"issue1":self.issue1valueset, "issue2":self.issue2valueset}[iss])
                        
                # by putting the best value first in the list now,
                # we may trigger a different evaluation path in the PartialPareto
                # algorithm, improving coverage
                self.issue2valueset = DiscreteValueSet([self.value2b, self.value2a])

        def testOneIssueTest(self):
                pp = PartialPareto.create([self.space1, self.space2], ["issue1"])
                # bid22 is best for both. Check that's the only remaining point
                self.assertEqual(1, len(pp.getPoints()))
                map:Dict[str, Value] = {}
                map["issue1"] = self.value1b
                # there is no value for issue2 because we asked to exclude it from the
                # pareto.
                self.assertEqual(Bid(map), pp.getPoints()[0].getBid())

        def testTwoIssuesTest(self):
                pp = PartialPareto.create([self.space1, self.space2],
                                ["issue1", "issue2"])
                # bid22 is best for both. Check that's the only remaining point
                self.assertEqual(1, len(pp.getPoints()))
                map:Dict[str, Value] = {}
                map["issue1"] = self.value1b
                map["issue2"] = self.value2b
                self.assertEqual(Bid(map), pp.getPoints()[0].getBid())