source: geniuswebcore/test/geniusweb/protocol/session/SessionResultTest.py

# Generated from java by J2P
from __future__ import annotations
from decimal import Decimal
from geniusweb.actions.PartyId import PartyId
from geniusweb.inform.Agreements import Agreements
from geniusweb.issuevalue.Bid import Bid
from geniusweb.issuevalue.DiscreteValue import DiscreteValue
from geniusweb.issuevalue.Value import Value
from geniusweb.protocol.session.SessionResult import SessionResult
from geniusweb.references.Parameters import Parameters
from geniusweb.references.PartyRef import PartyRef
from geniusweb.references.PartyWithParameters import PartyWithParameters
from geniusweb.references.PartyWithProfile import PartyWithProfile
from geniusweb.references.ProfileRef import ProfileRef
from pyson.ObjectMapper import ObjectMapper
from tudelft.utilities.exception.ExceptionContainer import ExceptionContainer
from typing import Dict
from typing import List
from typing import Optional
from unitpy.GeneralTests import GeneralTests
from unitpy.RunWith import RunWith
from unitpy.Runner import JUnit4ClassRunner
from unitpy.Runner import runTests
from unitpy.Test import Test
from unittest import TestCase
from uri.uri import URI
import json


@RunWith(JUnit4ClassRunner)
class SessionResultTest(GeneralTests):
 
 def __init__(self):
  self.__error:BaseException = BaseException("test")
  self.__ISSUE1:str = "issue1"
  self.__result1:SessionResult = None
  self.__result1a:SessionResult = None
  self.__result2:SessionResult = None
  self.__result3:SessionResult = None
  self.__result4:SessionResult = None
  self.__result5:SessionResult = None
  self.__jsonstring:str = "{\"participants\":{\"party1\":{\"party\":{\"partyref\":\"party2\",\"parameters\":{}},\"profile\":\"profile2\"},\"party3\":{\"party\":{\"partyref\":\"party1\",\"parameters\":{}},\"profile\":\"profile1\"}},\"agreements\":{\"party2\":{\"issuevalues\":{\"issue1\":\"a\"}},\"party1\":{\"issuevalues\":{\"issue1\":\"a\"}}},\"penalties\":{\"party2\":0.2,\"party1\":0.1},\"error\":null}"
  self.__nopenalties:Dict[PartyId,float] = dict()
  self.__penalties:Dict[PartyId,float] = dict()
  self.__PARTY1:PartyId = PartyId("party1")
  self.__PARTY2:PartyId = PartyId("party2")
  self.__PARTY3:PartyId = PartyId("party3")
  super().__init__()
  self.__penalties[self.__PARTY1]=0.1
  self.__penalties[self.__PARTY2]=0.2
  self.__nopenalties[self.__PARTY1]=0.
  self.__nopenalties[self.__PARTY2]=0.
  errorstring:str = "\"error\":{\"java.lang.RuntimeException\":" + json.dumps(SessionResultTest.__jackson.toJson(self.__error),separators=(',', ':')) + "}"
  party1:PartyWithParameters = PartyWithParameters(PartyRef(URI("party1")),Parameters({}))
  party2:PartyWithParameters = PartyWithParameters(PartyRef(URI("party2")),Parameters({}))
  partyprofile1:PartyWithProfile = PartyWithProfile(party1,ProfileRef(URI("profile1")))
  partyprofile2:PartyWithProfile = PartyWithProfile(party2,ProfileRef(URI("profile2")))
  issuevalues1:Dict[str,Value] = dict()
  issuevalues1[self.__ISSUE1]=DiscreteValue("a")
  bid1:Bid = Bid(issuevalues1)
  agreement1:Agreements = Agreements({}).With(Agreements.create(bid1,set([self.__PARTY1,self.__PARTY2])))
  #  different order but that shouldn't matter
  issuevalues2:Dict[str,Value] = dict()
  issuevalues2[self.__ISSUE1]=DiscreteValue("b")
  bid2:Bid = Bid(issuevalues2)
  agreement2:Agreements = Agreements({}).With(Agreements.create(bid2,set([self.__PARTY1,self.__PARTY3])))
  partiesmap:Dict[PartyId,PartyWithProfile] = dict()
  partiesmap[self.__PARTY1]=partyprofile1
  partiesmap[self.__PARTY2]=partyprofile2
  partiesmap2:Dict[PartyId,PartyWithProfile] = dict()
  partiesmap2[self.__PARTY1]=partyprofile2
  partiesmap2[self.__PARTY3]=partyprofile1
  self.__result1=SessionResult(partiesmap,agreement1,self.__nopenalties,None)
  self.__result1a=SessionResult(partiesmap,agreement1,self.__nopenalties,None)
  self.__result2=SessionResult(partiesmap,agreement2,self.__nopenalties,None)
  self.__result3=SessionResult(partiesmap2,agreement1,self.__nopenalties,None)
  self.__result4=SessionResult(partiesmap2,agreement1,self.__penalties,None)
  self.__result5=SessionResult(partiesmap,agreement1,self.__nopenalties,ExceptionContainer.fromException(self.__error))
 
 #Override
 def getGeneralTestData(self) -> Optional[List[Optional[List[Optional[SessionResult]]]]]:
  return [[self.__result1,self.__result1a],(lambda _: _ if type(_)==list else [_])(self.__result2),(lambda _: _ if type(_)==list else [_])(self.__result3),(lambda _: _ if type(_)==list else [_])(self.__result4),(lambda _: _ if type(_)==list else [_])(self.__result5)]
 
 #Override
 def getGeneralTestStrings(self) -> Optional[List[Optional[str]]]:
  return ["SessionResult.*((party2.*profile2.*)|(party1.*profile1.*))+Agreements.*Bid.*issue1.*\"a\".*0\\.0.*0\\.0.*" + SessionResultTest.__NULL + ".*","SessionResult.*((party2.*profile2.*)|(party1.*profile1.*))+Agreements.*Bid.*issue1.*\"b\".*0\\.0.*0\\.0.*" + SessionResultTest.__NULL + ".*","SessionResult.*((party1.*profile2.*)|(party3.*profile1.*))+Agreements.*Bid.*issue1.*\"a\".*0\\.0.*0\\.0.*" + SessionResultTest.__NULL + ".*","SessionResult.*((party1.*profile2.*)|(party3.*profile1.*))+Agreements.*Bid.*issue1.*\"a\".*Bid.*,*issue1.*((party2.*0\\.2.*)|(party1.*0\\.1.*))+.*" + SessionResultTest.__NULL + ".*","(?s)SessionResult.*((party2.*profile2.*)|(party1.*profile1.*))+Agreements.*Bid.*issue1.*\"a\".*0\\.0.*0\\.0.*Exception.*test.*"]
 
 @Test()
 def serializeTest(self) -> None:
  TestCase().assertEqual(json.loads(self.__jsonstring),SessionResultTest.__jackson.toJson(self.__result4))
 
 @Test()
 def deserializeTest(self) -> None:
  act:SessionResult = SessionResultTest.__jackson.parse(json.loads(self.__jsonstring, parse_float=lambda _:Decimal(_)),SessionResult)
  TestCase().assertEqual(self.__result4,act)
 @staticmethod
 def _static_init_():
  SessionResultTest.__jackson:ObjectMapper = ObjectMapper()
  SessionResultTest.__NULL:str = "((null)|(None))"
SessionResultTest._static_init_()

class Test(TestCase):
 def test(self):
  runTests(SessionResultTest)