def testCloneEncounter(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
testName = "testCloneEncounter"
testContent = hydracontent.create_hydra_content(
pdmap.PDMap,
owner=origPub,
originalPublisher=origPub,
instanceName = testName)
dummy = hydracontent.create_hydra_content(
pdmap.PDMap,
owner=testEntity,
instanceName='dummy')
dummy.put()
testContent.masks = []
testContent.masks.append( dummy.key())
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNot( result, testContent)
self.assertEqual(result.owner, testEntity)
self.assertEqual(result.originalPublisher, origPub)
self.assertEqual(result.instanceName, testName)
self.assertIsInstance( result, pdmap.PDMap)
self.assertEqual( len(result.masks), 1)
self.assertEqual( result.masks[0], dummy)
def testCloneItem(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
dummy = hydracontent.create_hydra_content(
hydracontent.HydraContent,
owner=testEntity,
instanceName='dummy')
dummy.put()
testName = "testCloneItem"
testContent = hydracontent.create_hydra_content(
item.Item,
mass = dummy,
owner=origPub,
originalPublisher=origPub,
instanceName = testName)
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNot( result, testContent)
self.assertEqual(result.owner, testEntity)
self.assertEqual(result.originalPublisher, origPub)
self.assertEqual(result.instanceName, testName)
self.assertIsInstance( result, item.Item)
self.assertEqual( result.mass, dummy)
def testCloneLyonnesseRoundEffect(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
testAdv = lyonnesseadvantage.get_lyonnesseadvantage(lyonnesseadvantage.LYONESSEADVANTAGE_ABSURD,
origPub)
testyAction = lyonnesseroundaction.LyonnesseRoundAction( moveDestination = [1.0,2.0,3.0],
action = lyonnesseroundaction.LYONNESSEROUNDACTION_ATTACK,
strengthEffort = True,
agilityEffort = False,
speedEffort = True,
poised = True,
repeat = False,
advantage = testAdv,
parent = origPub
)
testyAction.put()
testContent = lyonnesseroundeffect.LyonnesseRoundEffect(roundAction = testyAction,
wounds=0,
fatigue=1,
moveDestination=[1.0,2.0,3.0],
parent=origPub)
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNotNone(result)
self.assertIsInstance( result, lyonnesseroundeffect.LyonnesseRoundEffect)
self.assertEqual( result.roundAction, testyAction)
self.assertEqual( result.wounds, 0)
self.assertEqual( result.fatigue, 1)
self.assertEqual( result, testContent) # test __eq__
def testCloneParty(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
dummy = hydracontent.create_hydra_content(
party.Party,
owner=testEntity,
instanceName='dummy')
dummy.put()
testName = "testCloneParty"
testContent = hydracontent.create_hydra_content(
party.Party,
owner=origPub,
originalPublisher=origPub,
partyMorale=dummy,
instanceName = testName)
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNot( result, testContent)
self.assertEqual(result.owner, testEntity)
self.assertEqual(result.originalPublisher, origPub)
self.assertEqual(result.instanceName, testName)
self.assertIsInstance( result, party.Party)
self.assertEqual(result.partyMorale, dummy)
def testCloneCampaign(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
testName = "testCloneCampaign"
testContent = hydracontent.create_hydra_content(
campaign.Campaign,
owner=origPub,
originalPublisher=origPub,
instanceName = testName)
dummy = hydracontent.create_hydra_content(
campaign.Campaign,
owner=testEntity,
instanceName='dummy')
testContent.sessions = []
testContent.sessions.append( dummy.put())
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNot( result, testContent)
self.assertEqual(result.owner, testEntity)
self.assertEqual(result.originalPublisher, origPub)
self.assertEqual(result.instanceName, testName)
self.assertIsInstance( result, campaign.Campaign)
self.assertEqual( len(result.sessions), 1)
self.assertEqual( result.sessions[0], dummy)
def testCloneLyonnesseWeapon(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
testWS = lyonnessespeed.get_lyonnessespeed(lyonnessespeed.LYONNESSESPEED_AVERAGE, origPub)
testPS = lyonnessespeed.get_lyonnessespeed(lyonnessespeed.LYONNESSESPEED_CHARACTERS)
testName = 'Battle Axe'
testContent = hydracontent.create_hydra_content(lyonnesseweapon.LyonnesseWeapon,
owner=origPub,
originalPublisher=origPub,
weaponSpeed=testWS,
poisedSpeed=testPS,
length=8,
instanceName=testName
)
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNotNone(result)
self.assertIsInstance( result, lyonnesseweapon.LyonnesseWeapon)
self.assertEqual( result.weaponSpeed, testWS)
self.assertEqual( result.poisedSpeed, testPS)
self.assertEqual( result.instanceName, testName)
self.assertEqual( result.length, 8)
def testInsertHydraUser(self):
emailAddr = "*****@*****.**"
hydrauser.create_hydra_user(users.User(email=emailAddr))
result = hydrauser.get_hydra_user(emailAddr)
self.assertIsNotNone(result)
self.assertEqual(result.userID.email(), emailAddr)
def testCloneNPC(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
testName = "testCloneNPC"
testContent = hydracontent.create_hydra_content(
npc.NPC,
owner=origPub,
originalPublisher=origPub,
instanceName = testName)
dummy = hydracontent.create_hydra_content(
npc.NPC,
owner=testEntity,
instanceName='dummy')
dummy.put()
testContent.challenges = []
testContent.challenges.append( dummy.key())
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNot( result, testContent)
self.assertEqual(result.owner, testEntity)
self.assertEqual(result.originalPublisher, origPub)
self.assertEqual(result.instanceName, testName)
self.assertIsInstance( result, npc.NPC)
self.assertEqual( len(result.challenges), 1)
self.assertEqual( result.challenges[0], dummy)
def testCloneChallenge(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
testName = "testInsertCreature"
testContent = hydracontent.create_hydra_content(
creature.Creature,
owner=origPub,
originalPublisher=origPub,
instanceName = testName)
dummy = hydracontent.create_hydra_content(
hydracontent.HydraContent,
owner=testEntity,
instanceName='dummy')
dummy.put()
testContent.talents = []
testContent.talents.append( dummy.key())
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNot( result, testContent)
self.assertEqual(result.owner, testEntity)
self.assertEqual(result.originalPublisher, origPub)
self.assertEqual(result.instanceName, testName)
self.assertIsInstance( result, creature.Creature)
self.assertEqual( len(result.talents), 1)
self.assertEqual( result.talents[0], dummy)
def testCloneLyonnessePC(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
strength = lyonnessemass.get_lyonnessemass(lyonnessemass.LYONNESSEMASS_LARGE,
owner=origPub)
ag = lyonnessespeed.get_lyonnessespeed( lyonnessespeed.LYONNESSESPEED_CREEPING,
origPub)
sp = lyonnessespeed.get_lyonnessespeed( lyonnessespeed.LYONNESSESPEED_DELIBERATE)
dur = lyonnessemass.get_lyonnessemass(lyonnessemass.LYONNESSEMASS_LARGE)
testName = "Instance Name"
testDesc = "I want to ride my bicycle"
testLE = hydracontent.create_hydra_content(lyonnesselogentry.LyonnesseLogEntry,
instanceName = testName,
description = testDesc,
owner = testEntity
)
testLE.put()
testHistory = hydracontent.create_hydra_content(lyonnessecreaturehistory.LyonnesseCreatureHistory,
owner = testEntity,
logEntries = [testLE.key()]
)
testHistory.put()
testContent = hydracontent.create_hydra_content( lyonnessepc.LyonnessePC,
owner=origPub,
originalPublisher=origPub,
strength = strength,
agility=ag,
speed=sp,
durability=dur,
wounds = 1,
fatigue = 2,
maxhits = 12,
history = testHistory,
instanceName = testName
)
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNot( result, testContent)
self.assertEqual(result.owner, testEntity)
self.assertEqual(result.originalPublisher, origPub)
self.assertEqual(result.instanceName, testName)
self.assertIsInstance( result, lyonnessepc.LyonnessePC)
self.assertEqual( result.strength, strength)
self.assertEqual( result.agility, ag)
self.assertEqual( result.speed, sp)
self.assertEqual( result.durability, dur)
self.assertEqual( result.maxhits, 12)
self.assertEqual( result.wounds, 1)
self.assertEqual( result.fatigue, 2)
self.assertEqual( result.history, testHistory)
def testLoadAllHydraUsers(self):
emailAddrs = [
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
]
for eAddr in emailAddrs:
hydrauser.create_hydra_user(users.User(email=eAddr))
result = hydrauser.load_hydra_users()
self.assertIsNotNone(result)
self.assertEqual(len(result), len(emailAddrs))
def testInsertCampaign(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
testContent = hydracontent.create_hydra_content(
campaign.Campaign,
owner=testEntity)
dummy = hydracontent.create_hydra_content(
campaign.Campaign,
owner=testEntity,
instanceName='dummy')
testContent.sessions = []
testContent.sessions.append( dummy.put())
testContent.put()
result = hydracontent.load_hydra_content( testEntity)
self.assertIsNotNone(result)
self.assertEqual( len(result), 2)
result = db.get( testContent.key())
self.assertEqual( result.owner, testEntity)
self.assertIsInstance( result, campaign.Campaign)
self.assertEqual( len(result.sessions), 1)
self.assertEqual( db.get(result.sessions[0]), dummy)
def testEnumerateLyonnesseMass(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
result = lyonnessemass.get_lyonnessemass(lyonnessemass.LYONNESSEMASS_NEGLIGIBLE, owner=testEntity)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnessemass.LYONNESSEMASS_NEGLIGIBLE)
self.assertEqual( result.valName, 'Negligible')
result = lyonnessemass.get_lyonnessemass(lyonnessemass.LYONNESSEMASS_TINY)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnessemass.LYONNESSEMASS_TINY)
self.assertEqual( result.valName, 'Tiny')
result = lyonnessemass.get_lyonnessemass(lyonnessemass.LYONNESSEMASS_SMALL)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnessemass.LYONNESSEMASS_SMALL)
self.assertEqual( result.valName, 'Small')
result = lyonnessemass.get_lyonnessemass(lyonnessemass.LYONNESSEMASS_AVERAGE)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnessemass.LYONNESSEMASS_AVERAGE)
self.assertEqual( result.valName, 'Average')
result = lyonnessemass.get_lyonnessemass(lyonnessemass.LYONNESSEMASS_LARGE)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnessemass.LYONNESSEMASS_LARGE)
self.assertEqual( result.valName, 'Large')
result = lyonnessemass.get_lyonnessemass(lyonnessemass.LYONNESSEMASS_HUGE)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnessemass.LYONNESSEMASS_HUGE)
self.assertEqual( result.valName, 'Huge')
def testEnumerateLyonnesseProtection(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
result = lyonnesseprotection.get_lyonnesseprotection(lyonnesseprotection.LYONESSEPROTECTION_NEGLIGIBLE,
owner=testEntity)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseprotection.LYONESSEPROTECTION_NEGLIGIBLE)
self.assertEqual( result.valName, 'Negligible')
result = lyonnesseprotection.get_lyonnesseprotection(lyonnesseprotection.LYONESSEPROTECTION_TINY)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseprotection.LYONESSEPROTECTION_TINY)
self.assertEqual( result.valName, 'Tiny')
result = lyonnesseprotection.get_lyonnesseprotection(lyonnesseprotection.LYONESSEPROTECTION_LIGHT)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseprotection.LYONESSEPROTECTION_LIGHT)
self.assertEqual( result.valName, 'Light')
result = lyonnesseprotection.get_lyonnesseprotection(lyonnesseprotection.LYONESSEPROTECTION_MEDIUM)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseprotection.LYONESSEPROTECTION_MEDIUM)
self.assertEqual( result.valName, 'Medium')
result = lyonnesseprotection.get_lyonnesseprotection(lyonnesseprotection.LYONESSEPROTECTION_HEAVY)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseprotection.LYONESSEPROTECTION_HEAVY)
self.assertEqual( result.valName, 'Heavy')
result = lyonnesseprotection.get_lyonnesseprotection(lyonnesseprotection.LYONESSEPROTECTION_DEVASTATING)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseprotection.LYONESSEPROTECTION_DEVASTATING)
self.assertEqual( result.valName, 'Devastating')
def testEnumerateLyonnesseSkillLevel(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
result = lyonnesseskilllevel.get_lyonnesseskilllevel(lyonnesseskilllevel.LYONNESSESKILLLEVEL_UNSKILLED, owner=testEntity)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseskilllevel.LYONNESSESKILLLEVEL_UNSKILLED)
self.assertEqual( result.valName, 'Unskilled')
result = lyonnesseskilllevel.get_lyonnesseskilllevel(lyonnesseskilllevel.LYONNESSESKILLLEVEL_NEOPHYTE)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseskilllevel.LYONNESSESKILLLEVEL_NEOPHYTE)
self.assertEqual( result.valName, 'Neophyte')
result = lyonnesseskilllevel.get_lyonnesseskilllevel(lyonnesseskilllevel.LYONNESSESKILLLEVEL_VETERAN)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseskilllevel.LYONNESSESKILLLEVEL_VETERAN)
self.assertEqual( result.valName, 'Veteran')
result = lyonnesseskilllevel.get_lyonnesseskilllevel(lyonnesseskilllevel.LYONNESSESKILLLEVEL_SKILLED)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseskilllevel.LYONNESSESKILLLEVEL_SKILLED)
self.assertEqual( result.valName, 'Skilled')
result = lyonnesseskilllevel.get_lyonnesseskilllevel(lyonnesseskilllevel.LYONNESSESKILLLEVEL_MASTER)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseskilllevel.LYONNESSESKILLLEVEL_MASTER)
self.assertEqual( result.valName, 'Master')
result = lyonnesseskilllevel.get_lyonnesseskilllevel(lyonnesseskilllevel.LYONNESSESKILLLEVEL_SUPERLATIVE)
self.assertIsNotNone(result)
self.assertEqual( result.value, lyonnesseskilllevel.LYONNESSESKILLLEVEL_SUPERLATIVE)
self.assertEqual( result.valName, 'Superlative')
def testInsertNPC(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
testContent = hydracontent.create_hydra_content(
npc.NPC,
owner=testEntity)
testContent.challenges = []
dummy = hydracontent.create_hydra_content(
npc.NPC,
owner=testEntity,
instanceName='dummy')
dummy.put()
testContent.challenges.append( dummy.key())
testContent.put()
result = hydracontent.load_hydra_content( testEntity)
self.assertIsNotNone(result)
self.assertEqual( len(result), 2)
result = db.get( testContent.key())
self.assertEqual( result.owner, testEntity)
self.assertIsInstance( result, npc.NPC)
self.assertEqual( len(result.challenges), 1)
self.assertEqual( db.get(result.challenges[0]), dummy)
def testInsertLyonnesseArmor(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
testMass = lyonnessemass.get_lyonnessemass(lyonnessemass.LYONNESSEMASS_LARGE,
owner=testEntity)
testProt = lyonnesseprotection.get_lyonnesseprotection(lyonnesseprotection.LYONESSEPROTECTION_MEDIUM,
testEntity)
testContent = hydracontent.create_hydra_content(
lyonnessearmor.LyonnesseArmor,
owner = testEntity,
mass = testMass,
protection = testProt,
cover = "Full Body"
)
testContent.put()
result = hydracontent.load_hydra_content( testEntity)
self.assertIsNotNone(result)
result = db.get( testContent.key())
self.assertEqual( result.owner, testEntity)
self.assertIsInstance( result, lyonnessearmor.LyonnesseArmor)
self.assertEqual( result.cover, "Full Body")
self.assertEqual( result.mass, testMass)
self.assertEqual( result.protection, testProt)
def testInsertPDMap(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
dummy = hydracontent.create_hydra_content(
pdmap.PDMap,
owner=testEntity,
instanceName='dummy')
dummy.put()
testContent = hydracontent.create_hydra_content(
pdmap.PDMap,
owner=testEntity)
testContent.masks = []
testContent.masks.append( dummy.key())
testContent.put()
result = hydracontent.load_hydra_content( testEntity)
self.assertIsNotNone(result)
self.assertEqual( len(result), 2)
result = db.get( testContent.key())
self.assertEqual( result.owner, testEntity)
self.assertIsInstance( result, pdmap.PDMap)
self.assertEqual( len(result.masks), 1)
self.assertEqual( db.get(result.masks[0]), dummy)
def testInsertLyonnesseRoundAction(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
testAdv = lyonnesseadvantage.get_lyonnesseadvantage(lyonnesseadvantage.LYONESSEADVANTAGE_ABSURD,
testEntity)
testContent = lyonnesseroundaction.LyonnesseRoundAction( moveDestination = [1.0,2.0,3.0],
action = lyonnesseroundaction.LYONNESSEROUNDACTION_ATTACK,
strengthEffort = True,
agilityEffort = False,
speedEffort = True,
poised = True,
repeat = False,
advantage = testAdv,
parent = testEntity
)
testContent.put()
result = lyonnesseroundaction.LyonnesseRoundAction.all().get()
self.assertIsNotNone(result)
self.assertIsInstance( result, lyonnesseroundaction.LyonnesseRoundAction)
self.assertEqual( result.action, lyonnesseroundaction.LYONNESSEROUNDACTION_ATTACK)
self.assertEqual( result.strengthEffort, True)
self.assertEqual( result.agilityEffort, False)
self.assertEqual( result.speedEffort, True)
self.assertEqual( result.poised, True)
self.assertEqual( result.repeat, False)
self.assertEqual( result.advantage, testAdv)
self.assertEqual( result, testContent) # test __eq__
def testCloneContentToContent(self):
eAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=eAddr))
testNames = ['testCloneContentToContent0',
'testCloneContentToContent1']
testContent0 = hydracontent.create_hydra_content(hydracontent.HydraContent,
owner=testEntity,
instanceName=testNames[0]
)
testContent0.put()
testContent1 = hydracontent.create_hydra_content(hydracontent.HydraContent,
owner=testEntity,
instanceName=testNames[1]
)
testContent1.put()
# clone the content to an item owned by the first content item
result = testContent1.clone( testContent0)
self.assertIsNot( result, testContent1)
self.assertIsNot( result, testContent0)
self.assertEqual( result.owner, testEntity)
self.assertEqual( testContent0.owner, testEntity)
self.assertEqual( testContent1.owner, testEntity)
self.assertEqual( result.instanceName, testNames[1])
self.assertEqual( testContent0.instanceName, testNames[0])
self.assertEqual( testContent1.instanceName, testNames[1])
self.assertEqual( len(result.contentSet), 0)
self.assertEqual( len(testContent0.contentSet), 1)
self.assertEqual( len(testContent1.contentSet), 0)
def testCloneToContentWithContent(self):
eAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=eAddr))
testNames = ['testCloneContentToContent0',
'testCloneContentToContent1',
'subcontent']
testContent = []
for t in testNames:
c = hydracontent.create_hydra_content( hydracontent.HydraContent,
owner=testEntity,
instanceName=t)
c.put()
testContent.append(c)
# clone the content to an item owned by the first content item
c0 = testContent[2].clone( testContent[0])
c1 = testContent[1].clone( testContent[0])
self.assertIsNot( c0, testContent[2])
self.assertIsNot( c1, testContent[1])
self.assertEqual( c0.owner, testEntity)
self.assertEqual( c1.owner, testEntity)
self.assertEqual( c0.instanceName, testNames[2])
self.assertEqual( c1.instanceName, testNames[1])
self.assertEqual( len(c0.contentSet), 0)
self.assertEqual( len(c1.contentSet), 0)
self.assertEqual( len(testContent[0].contentSet), 2)
def testInsertLyonnesseCreatureHistory(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
testName = "Instance Name"
testDesc = "I want to ride my bicycle"
testLE = hydracontent.create_hydra_content(lyonnesselogentry.LyonnesseLogEntry,
instanceName = testName,
description = testDesc,
owner = testEntity
)
testLE.put()
testContent = hydracontent.create_hydra_content(lyonnessecreaturehistory.LyonnesseCreatureHistory,
owner = testEntity,
logEntries = [testLE.key()]
)
testContent.put()
result = hydracontent.load_hydra_content( testEntity)
self.assertIsNotNone(result)
result = db.get( testContent.key())
self.assertEqual( result.owner, testEntity)
self.assertIsInstance( result, lyonnessecreaturehistory.LyonnesseCreatureHistory)
self.assertEqual( len( result.logEntries), 1)
result = db.get( result.logEntries[0]) # logentry
self.assertIsNotNone( result)
self.assertEqual( result.owner, testEntity)
self.assertIsInstance( result, lyonnesselogentry.LyonnesseLogEntry)
self.assertEqual( result.instanceName, testName)
self.assertEqual( result.description, testDesc)
def testInsertCreature(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
testContent = hydracontent.create_hydra_content(
creature.Creature,
owner=testEntity)
dummy = hydracontent.create_hydra_content(
creature.Creature,
owner=testEntity,
instanceName='dummy')
dummy.put()
testContent.talents = []
testContent.talents.append( dummy.key())
testContent.put()
result = hydracontent.load_hydra_content( testEntity)
self.assertIsNotNone(result)
self.assertEqual( len(result), 2)
result = db.get( testContent.key())
self.assertEqual( result.owner, testEntity)
self.assertIsInstance( result, creature.Creature)
self.assertEqual( len(result.talents), 1)
self.assertEqual( db.get(result.talents[0]), dummy)
def testInsertLyonnesseWeapon(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
testWS = lyonnessespeed.get_lyonnessespeed(lyonnessespeed.LYONNESSESPEED_AVERAGE, testEntity)
testPS = lyonnessespeed.get_lyonnessespeed(lyonnessespeed.LYONNESSESPEED_CHARACTERS)
testName = 'Battle Axe'
testContent = hydracontent.create_hydra_content(lyonnesseweapon.LyonnesseWeapon,
owner=testEntity,
weaponSpeed=testWS,
poisedSpeed=testPS,
length=8,
instanceName=testName
)
testContent.put()
result = hydracontent.load_hydra_content( testEntity)
self.assertIsNotNone(result)
result = db.get( testContent.key())
self.assertIsNotNone(result)
self.assertIsInstance( result, lyonnesseweapon.LyonnesseWeapon)
self.assertEqual( result.weaponSpeed, testWS)
self.assertEqual( result.poisedSpeed, testPS)
self.assertEqual( result.instanceName, testName)
self.assertEqual( result.length, 8)
self.assertEqual( result, testContent) # test __eq__
def testCloneAdventure(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
testName = "testCloneAdventure"
testContent = hydracontent.create_hydra_content(
adventure.Adventure,
owner=origPub,
originalPublisher=origPub,
instanceName = testName)
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNot( result, testContent)
self.assertEqual(result.owner, testEntity)
self.assertEqual(result.originalPublisher, origPub)
self.assertEqual(result.instanceName, testName)
self.assertIsInstance( result, adventure.Adventure)
def testCloneGameSystem(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
testName = "testInsertPDFContent"
testContent = hydracontent.create_hydra_content(
pdfcontent.PDFContent,
owner=origPub,
originalPublisher=origPub,
instanceName = testName)
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNot( result, testContent)
self.assertEqual(result.owner, testEntity)
self.assertEqual(result.originalPublisher, origPub)
self.assertEqual(result.instanceName, testName)
self.assertIsInstance( result, pdfcontent.PDFContent)
def testClonePlayerCharacter(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
testName = "testClonePlayerCharacter"
testContent = hydracontent.create_hydra_content(
playercharacter.PlayerCharacter,
owner=origPub,
originalPublisher=origPub,
instanceName = testName)
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNot( result, testContent)
self.assertEqual(result.owner, testEntity)
self.assertEqual(result.originalPublisher, origPub)
self.assertEqual(result.instanceName, testName)
self.assertIsInstance( result, playercharacter.PlayerCharacter)
def testCloneLyonnesseItem(self):
eAddrs=['*****@*****.**',
'*****@*****.**']
testEntity = hydrauser.create_hydra_user(users.User(email=eAddrs[0]))
origPub = hydrauser.create_hydra_user(users.User(email=eAddrs[1]))
testName = "testCloneLyonnesseItem"
testContent = hydracontent.create_hydra_content( lyonnesseitem.LyonnesseItem,
owner=origPub,
originalPublisher=origPub,
instanceName = testName,
damaged = True)
testContent.put()
result = testContent.clone( testEntity)
self.assertIsNot( result, testContent)
self.assertEqual(result.owner, testEntity)
self.assertEqual(result.originalPublisher, origPub)
self.assertEqual(result.instanceName, testName)
self.assertIsInstance( result, lyonnesseitem.LyonnesseItem)
self.assertEqual( result.damaged, True)
def testCreateLyonnesseSkillLevel(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
testContent = lyonnesseskilllevel.get_lyonnesseskilllevel(lyonnesseskilllevel.LYONNESSESKILLLEVEL_NEOPHYTE,
owner=testEntity
)
result = lyonnesseskilllevel.get_lyonnesseskilllevel(lyonnesseskilllevel.LYONNESSESKILLLEVEL_NEOPHYTE)
self.assertIsNotNone(result)
self.assertEqual( result, testContent)
self.assertEqual( result.value, lyonnesseskilllevel.LYONNESSESKILLLEVEL_NEOPHYTE)
self.assertEqual( result.valName, 'Neophyte')
def testCreateLyonnesseMass(self):
emailAddr='*****@*****.**'
testEntity = hydrauser.create_hydra_user(users.User(email=emailAddr))
testContent = lyonnessemass.get_lyonnessemass(lyonnessemass.LYONNESSEMASS_TINY,
owner=testEntity
)
result = lyonnessemass.get_lyonnessemass(lyonnessemass.LYONNESSEMASS_TINY)
self.assertIsNotNone(result)
self.assertEqual( result, testContent)
self.assertEqual( result.value, lyonnessemass.LYONNESSEMASS_TINY)
self.assertEqual( result.valName, 'Tiny')
