12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006 |
- import unittest
- import sys
- try:
- from unit.utils import *
- import unit.log_output as log_output
- except ImportError: #for Python2
- from utils import *
- import log_output as log_output
- sys.path.append("wrappers")
- from modelverse import *
- import threading
- model_hierarchy = \
- {"formalisms/": {"SimpleClassDiagrams": {},
- "TypeMapping": {},
- "Tracability": {},
- "ProcessModel": {},
- "ActionLanguage": {},
- "ManualOperation": {},
- "Bottom": {},
- },
- "models/": {},
- "administration/": {"core": {},
- "CoreFormalism": {},
- },
- "users/": {"admin/": {},
- "LoLA/": {},
- "HUTN/": {},
- "files/": {},
- "DEVS/": {},
- "DEVS_batch/": {},
- "JSON/": {},
- },
- "type mappings/": {"1": {},
- "2": {},
- "3": {},
- "4": {},
- "5": {},
- "6": {},
- "7": {},
- "8": {},
- "9": {},
- },
- "merged/": {},
- "tmp/": {},
- "RAMified/": {},
- }
- def verify_clean():
- compare_locations("", set())
- compare_locations("models", set())
- compare_locations("formalisms", set())
- def get_model_list(location):
- try:
- location_parts = location.split("/")
- current = model_hierarchy
- while location_parts:
- l = location_parts.pop(0)
- if l != "":
- current = current[l + "/"]
- return set(current.keys())
- except:
- return set([])
- def compare_locations(location, extra_to_default):
- assert model_list(location) == get_model_list(location) | set(extra_to_default)
- def compare_unordered_lists(got, expected):
- assert len(got) == len(expected)
- for i in got:
- assert i in expected
- for i in expected:
- assert i in got
- class TestModelverse(unittest.TestCase):
- proc = None
- def runTest(self):
- pass
- @classmethod
- def setUpClass(self):
- TestModelverse.proc, address = start_mvc()
- init(address)
- login("user", "user")
- @classmethod
- def tearDownClass(self):
- try:
- kill(TestModelverse.proc)
- except:
- print("Got exception during teardown.")
- def setUp(self):
- verify_clean()
- folder_create("users/user/test")
- def tearDown(self):
- model_delete("users/user/test")
- verify_clean()
- pass
- def test_op_model_list(self):
- assert model_list("") == set(["formalisms/",
- "models/",
- "administration/",
- "type mappings/",
- "users/",
- "merged/",
- "RAMified/",
- "tmp/",
- ])
- assert model_list("formalisms") == set(["SimpleClassDiagrams",
- "ActionLanguage",
- "TypeMapping",
- "Tracability",
- "ProcessModel",
- "ManualOperation",
- "Bottom",
- ])
- assert model_list("formalisms/") == set(["SimpleClassDiagrams",
- "ActionLanguage",
- "TypeMapping",
- "Tracability",
- "ProcessModel",
- "ManualOperation",
- "Bottom",
- ])
- # Try unreadable location
- try:
- model_list("administration")
- self.fail()
- except ReadPermissionDenied:
- pass
- # Try non-existing location
- try:
- model_list("adfjafdla")
- self.fail()
- except UnknownLocation:
- pass
- # Try model list of a model itself
- assert model_list("formalisms/SimpleClassDiagrams") == set([])
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/b", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/c", "formalisms/SimpleClassDiagrams")
- assert model_list("users/user/test") == set(["a", "b", "c"])
- assert model_list("users/user/test/") == set(["a", "b", "c"])
- def test_op_model_list_full(self):
- assert model_list_full("") == set([("formalisms/", "admin", "admin", "221"),
- ("models/", "admin", "admin", "221"),
- ("administration/", "admin", "admin", "110"),
- ("type mappings/", "admin", "admin", "221"),
- ("users/", "admin", "admin", "221"),
- ("merged/", "admin", "nobody", "222"),
- ("RAMified/", "admin", "nobody", "222"),
- ("tmp/", "admin", "nobody", "222"),
- ])
- assert model_list_full("formalisms") == set([("SimpleClassDiagrams", "admin", "admin", "221"),
- ("ActionLanguage", "admin", "admin", "221"),
- ("TypeMapping", "admin", "admin", "221"),
- ("Tracability", "admin", "admin", "221"),
- ("ProcessModel", "admin", "admin", "221"),
- ("ManualOperation", "admin", "admin", "221"),
- ("Bottom", "admin", "admin", "221"),
- ])
- # Try unreadable location
- try:
- model_list_full("administration")
- self.fail()
- except ReadPermissionDenied:
- pass
- # Try non-existing location
- try:
- model_list_full("adfjafdla")
- self.fail()
- except UnknownLocation:
- pass
- # Try model list of a model itself
- assert model_list_full("formalisms/SimpleClassDiagrams") == set([])
- def test_op_verify(self):
- # Verify M3 --> M3
- assert verify("formalisms/SimpleClassDiagrams", "formalisms/SimpleClassDiagrams") == "OK"
- # Verify with bottom
- assert verify("formalisms/SimpleClassDiagrams", "formalisms/Bottom") == "OK"
- # Verify the type mapping models
- for tm in model_types("formalisms/SimpleClassDiagrams"):
- assert verify(tm[1], "formalisms/TypeMapping") == "OK"
- # Verify wrong
- try:
- verify("formalisms/SimpleClassDiagrams", "formalisms/ProcessModel")
- self.fail()
- except UnknownMetamodellingHierarchy:
- pass
- # Verify M2 --> M3
- assert verify("formalisms/ProcessModel", "formalisms/SimpleClassDiagrams") == "OK"
- assert verify("formalisms/ProcessModel", "formalisms/Bottom") == "OK"
- for tm in model_types("formalisms/ProcessModel"):
- assert verify(tm[1], "formalisms/TypeMapping") == "OK"
- try:
- verify("formalisms/ProcessModel", "formalisms/ProcessModel")
- self.fail()
- except UnknownMetamodellingHierarchy:
- pass
- # Verify M1 --> M2
- model_add("users/user/test/a", "formalisms/ProcessModel")
- # Fails with lacking instances of Start and Finish class
- assert verify("users/user/test/a", "formalisms/ProcessModel").startswith("Lower cardinality violated for class: ")
- instantiate("users/user/test/a", "Start")
- # Fails with lacking instances of Finish class
- assert verify("users/user/test/a", "formalisms/ProcessModel") == "Lower cardinality violated for class: Finish"
- instantiate("users/user/test/a", "Finish")
- # Succeeds
- assert verify("users/user/test/a", "formalisms/ProcessModel") == "OK"
- # Test unreadable model
- try:
- verify("administration/core", "formalisms/ProcessModel")
- self.fail()
- except ReadPermissionDenied:
- pass
- # Test unreadable metamodel
- try:
- verify("formalisms/Bottom", "administration/core")
- self.fail()
- except ReadPermissionDenied:
- pass
- # Test non-existing model
- try:
- verify("adfadf", "formalisms/SimpleClassDiagrams")
- self.fail()
- except UnknownModel:
- pass
- # Test non-existing metamodel
- try:
- verify("formalisms/SimpleClassDiagrams", "adfka")
- self.fail()
- except UnknownModel:
- pass
- def test_op_permission_modify(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "200")])
- # Check that we can read
- element_list_nice("users/user/test/a")
- # Check that we can write
- instantiate("users/user/test/a", "Class")
- assert permission_modify("users/user/test/a", "100") == None
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "100")])
- # Check that we can read
- element_list_nice("users/user/test/a")
- # Check that we can't write
- try:
- instantiate("users/user/test/a", "Class")
- self.fail()
- except WritePermissionDenied:
- pass
- assert permission_modify("users/user/test/a", "000") == None
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "000")])
- # Check that we can't read
- try:
- element_list_nice("users/user/test/a")
- self.fail()
- except ReadPermissionDenied:
- pass
- # Check that we can't write
- try:
- instantiate("users/user/test/a", "Class")
- self.fail()
- except WritePermissionDenied:
- pass
- except ReadPermissionDenied:
- pass
- assert permission_modify("users/user/test/a", "200") == None
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "200")])
- # Check that we can read
- element_list_nice("users/user/test/a")
- # Check that we can write
- instantiate("users/user/test/a", "Class")
- # Cannot modify permissions if we don't own the model
- try:
- permission_modify("formalisms/SimpleClassDiagrams", "222")
- self.fail()
- except UserPermissionDenied:
- pass
- # Cannot modify permissions even if we have full access, as long as we are not the owner
- model_add("users/user/test/z", "formalisms/SimpleClassDiagrams")
- permission_owner("users/user/test/z", "admin")
- try:
- permission_modify("users/user/test/z", "222")
- self.fail()
- except UserPermissionDenied:
- pass
- try:
- permission_owner("users/user/test/z", "user")
- self.fail()
- except UserPermissionDenied:
- pass
- # Cannot change non-existing model
- before = model_list("")
- try:
- permission_modify("adfadf", "111")
- self.fail()
- except UnknownModel:
- assert model_list("") == before
- # Check for type of permission string
- # Too long
- try:
- permission_modify("users/user/test/a", "1111")
- self.fail()
- except IncorrectFormat:
- assert [i[3] for i in model_list_full("users/user/test/") if i[0] == "a"][0] == "200"
- # Above 2
- try:
- permission_modify("users/user/test/a", "131")
- self.fail()
- except IncorrectFormat:
- assert [i[3] for i in model_list_full("users/user/test/") if i[0] == "a"][0] == "200"
- # Below 0
- try:
- permission_modify("users/user/test/a", "-111")
- self.fail()
- except IncorrectFormat:
- assert [i[3] for i in model_list_full("users/user/test/") if i[0] == "a"][0] == "200"
- # Non-integer
- try:
- permission_modify("users/user/test/a", "2a1")
- self.fail()
- except IncorrectFormat:
- assert [i[3] for i in model_list_full("users/user/test/") if i[0] == "a"][0] == "200"
- def test_op_model_add(self):
- assert model_list_full("users/user/test") == set([])
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- # Test permissions of newly created empty model
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "200")])
- model_add("users/user/test/b", "formalisms/SimpleClassDiagrams", \
- """
- Class A {
- name = "A"
- }
- Class B {
- name = "B"
- abstract = True
- }
- """)
- # Test permissions of newly created non-empty model
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "200"), ("b", "user", "nobody", "200")])
- # Test content of newly created model with code upload
- lst = element_list_nice("users/user/test/b")
- assert len(lst) == 2
- assert {'__id': "A", "__type": "Class", "abstract": None, "constraint": {"AL": ""}, "lower_cardinality": None, "upper_cardinality": None, "name": "A"} in lst
- assert {'__id': "B", "__type": "Class", "abstract": True, "constraint": {"AL": ""}, "lower_cardinality": None, "upper_cardinality": None, "name": "B"} in lst
- try:
- # Cannot upload model to occupied location
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- self.fail()
- except ModelExists:
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "200"), ("b", "user", "nobody", "200")])
- try:
- # Cannot upload model to unwritable location at root
- model_add("z", "formalisms/SimpleClassDiagrams")
- self.fail()
- except WritePermissionDenied:
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "200"), ("b", "user", "nobody", "200")])
- try:
- # Cannot upload model to unwritable location somewhere in hierarchy
- model_add("users/new_model", "formalisms/SimpleClassDiagrams")
- self.fail()
- except WritePermissionDenied:
- assert "new_model/" not in model_list("users/")
- try:
- # Cannot upload model to unwritable location somewhere in hierarchy with multiple new branches
- model_add("users/new_username/new_model", "formalisms/SimpleClassDiagrams")
- self.fail()
- except WritePermissionDenied:
- assert "new_username/" not in model_list("users/")
- model_add("users/user/test/c", "users/user/test/b", """
- A a {}
- """)
- try:
- # Cannot add this model, as it cannot be auto-typecasted to formalisms/SimpleClassDiagrams
- model_add("users/user/test/d", "users/user/test/c", """
- a c {}
- """)
- self.fail()
- except UnknownM3:
- assert model_list("users/user/test") == set(["a", "b", "c"])
- # We can add this model for multiple levels, as it can be automatically typecasted to formalisms/SimpleClassDiagrams, since it is empty
- model_add("users/user/test/d", "users/user/test/b")
- model_add("users/user/test/e", "users/user/test/d")
- model_add("users/user/test/f", "users/user/test/e")
- def test_op_model_add_compilation_error(self):
- try:
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- abdfaefeaf
- """)
- self.fail()
- except CompilationError:
- pass
- try:
- model_add("users/user/test/b", "formalisms/SimpleClassDiagrams", """
- Crass A {
- name = "b"
- }
- """)
- #TODO at the moment, this still succeeds!
- #self.fail()
- except:
- raise
- pass
- def test_op_model_move(self):
- # Test basic scenario
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "200")])
- assert model_move("users/user/test/a", "users/user/test/b") == None
- assert model_list_full("users/user/test") == set([("b", "user", "nobody", "200")])
- # Test if permissions are copied as well
- permission_modify("users/user/test/b", "222")
- assert model_list_full("users/user/test") == set([("b", "user", "nobody", "222")])
- assert model_move("users/user/test/b", "users/user/test/a") == None
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "222")])
- # Test move if destination exists
- model_add("users/user/test/b", "formalisms/SimpleClassDiagrams")
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "222"), ("b", "user", "nobody", "200")])
- try:
- model_move("users/user/test/a", "users/user/test/b")
- self.fail()
- except ModelExists:
- pass
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "222"), ("b", "user", "nobody", "200")])
- # Test move if source doesn't exist
- try:
- model_move("users/user/test/z", "users/user/test/y")
- self.fail()
- except UnknownModel:
- pass
- # Test if we can move a model we can't write to (i.e., not allowed to remove it)
- try:
- model_move("formalisms/ProcessModel", "users/user/test/x")
- self.fail()
- except WritePermissionDenied:
- pass
- # Test if we can move a model to a place we can't write to
- try:
- model_move("users/user/test/a", "administration/ProcessModel2")
- self.fail()
- except WritePermissionDenied:
- pass
- def test_op_model_delete(self):
- # Test basic delete
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "200")])
- assert model_delete("users/user/test/a") == None
- assert model_list_full("users/user/test") == set([])
- # Test delete of non-existing
- assert model_list_full("users/user/test") == set([])
- try:
- model_delete("users/user/test/a")
- self.fail()
- except UnknownModel:
- pass
- # Test delete of non-writable models
- try:
- model_delete("formalisms/SimpleClassDiagrams")
- self.fail()
- except WritePermissionDenied:
- pass
- # Try delete of a folder
- folder_create("users/user/test/b/c/d")
- model_add("users/user/test/b/c/d/e", "formalisms/SimpleClassDiagrams")
- assert model_list("users/user/test") == set(["b/"])
- assert model_list("users/user/test/b") == set(["c/"])
- assert model_list("users/user/test/b/c") == set(["d/"])
- assert model_list("users/user/test/b/c/d") == set(["e"])
- assert model_delete("users/user/test/b/c") == None
- # Removes recursively all subfolders and containing models
- assert model_list("users/user/test") == set(["b/"])
- assert model_list("users/user/test/b") == set([])
- try:
- model_list("users/user/test/b/c")
- self.fail()
- except UnknownLocation:
- pass
- try:
- element_list("users/user/test/b/c/d/e")
- self.fail()
- except UnknownModel:
- pass
- def test_op_model_overwrite(self):
- # Test overwrite of simple model
- assert model_list_full("users/user/test") == set([])
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- # Test permissions of newly created empty model
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "200")])
- assert element_list_nice("users/user/test/a") == []
- model_overwrite("users/user/test/a", \
- """
- Class A {
- name = "A"
- }
- Class B {
- name = "B"
- abstract = True
- }
- """)
- # Test permissions of newly created non-empty model
- assert model_list_full("users/user/test") == set([("a", "user", "nobody", "200")])
- # Test content of newly created model with code upload
- lst = element_list_nice("users/user/test/a")
- assert len(lst) == 2
- assert {'__id': "A", "__type": "Class", "abstract": None, "constraint": {"AL": ""}, "lower_cardinality": None, "upper_cardinality": None, "name": "A"} in lst
- assert {'__id': "B", "__type": "Class", "abstract": True, "constraint": {"AL": ""}, "lower_cardinality": None, "upper_cardinality": None, "name": "B"} in lst
- # Test non-writable model
- before = element_list("formalisms/SimpleClassDiagrams")
- try:
- model_overwrite("formalisms/SimpleClassDiagrams", "")
- self.fail()
- except WritePermissionDenied:
- # No changes were made
- assert element_list("formalisms/SimpleClassDiagrams") == before
- # Test non-existing model
- assert "adfafd" not in model_list("")
- try:
- model_overwrite("adfafd", "")
- self.fail()
- except UnknownModel:
- assert "adfafd" not in model_list("")
- # Test compilation error
- before = element_list_nice("users/user/test/a")
- try:
- model_overwrite("users/user/test/a", "afajk")
- self.fail()
- except CompilationError:
- assert element_list_nice("users/user/test/a") == before
- # Test overwrite of non-model location
- before = model_list("users/user/test")
- try:
- model_overwrite("users/user/test", "")
- self.fail()
- except UnknownMetamodellingHierarchy:
- assert model_list("users/user/test") == before
- def test_op_user_logout(self):
- try:
- element_list_nice("administration/core")
- self.fail()
- except ReadPermissionDenied:
- pass
- user_logout()
- login("admin", "admin")
- # Test user permissions
- assert len(element_list_nice("administration/core")) > 0
- user_logout()
- login("user", "user")
- try:
- element_list_nice("administration/core")
- self.fail()
- except ReadPermissionDenied:
- pass
-
- def test_op_all_instances(self):
- # Test M2 level
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- Class A {}
- Class B : A {}
- Association C (A, B) {}
- """)
- assert all_instances("users/user/test/a", "Class") == set(["A", "B", "C"])
- assert all_instances("users/user/test/a", "Association") == set(["C"])
- # Test M1 level
- model_add("users/user/test/b", "users/user/test/a", """
- A a {}
- B b {}
- C c(a, b) {}
- A d {}
- """)
- assert all_instances("users/user/test/b", "A") == set(["a", "b", "d"])
- assert all_instances("users/user/test/b", "B") == set(["b"])
- assert all_instances("users/user/test/b", "C") == set(["c"])
- # Test non-existing type
- try:
- all_instances("users/user/test/a", "non-existing")
- self.fail()
- except UnknownElement:
- pass
- # Test non-existing model
- try:
- all_instances("users/user/test/c", "Class")
- self.fail()
- except UnknownModel:
- pass
- # No read permission
- try:
- all_instances("administration/core", "Class")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permission, but can query
- assert type(all_instances("formalisms/SimpleClassDiagrams", "Class")) == set
- def test_op_admin_promote_demote(self):
- # Verify that user doesn't have admin permissions
- try:
- element_list("administration/core")
- self.fail()
- except ReadPermissionDenied:
- pass
- # Cannot do admin_promote ourselves
- try:
- admin_promote("user")
- except AdminPermissionDenied:
- pass
- # Cannot do admin_demote ourselves
- try:
- admin_demote("user")
- except AdminPermissionDenied:
- pass
- # Switch to admin for now
- self.do_as_user("admin", admin_promote, ["user"])
- # Verify that we can do admin operations
- assert len(element_list("administration/core")) > 0
- # And check that we can promote/demote other users
- admin_promote("HUTN")
- admin_demote("HUTN")
- # Unknown user
- try:
- admin_promote("user3")
- self.fail()
- except UnknownUser:
- pass
- try:
- admin_demote("user4")
- self.fail()
- except UnknownUser:
- pass
- # Can also demote ourselves again
- admin_demote("user")
- # Verify that user doesn't have admin permissions
- try:
- element_list("administration/core")
- self.fail()
- except ReadPermissionDenied:
- pass
- def test_op_user_password(self):
- # Test initial password
- user_logout()
- try:
- login("user", "user2")
- self.fail()
- except PermissionDenied:
- pass
- login("user", "user")
- # Change it to user2
- user_password("user", "user2")
- user_logout()
- try:
- login("user", "user")
- self.fail()
- except PermissionDenied:
- pass
- login("user", "user2")
- # Reset for further tests
- user_password("user", "user")
- # Change other users password
- try:
- user_password("user2", "user10")
- self.fail()
- except UserPermissionDenied:
- user_logout()
- login("user2", "user2")
- user_logout()
- login("user", "user")
- # But admin can do that
- self.do_as_user("admin", user_password, ["user2", "user10"])
- user_logout()
- login("user2", "user10")
- user_logout()
- login("user", "user")
- # Admin cannot change password of non-existing user
- try:
- self.do_as_user("admin", user_password, ["user10", "user10"])
- self.fail()
- except UnknownUser:
- user_logout()
- # Check that we can still create the new user with whatever password we want
- login("user10", "user11")
- user_logout()
- login("user", "user")
- def test_op_model_types(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- # Read model types of simple model
- lst = model_types("users/user/test/a")
- assert len(lst) == 1
- entry = lst.pop()
- assert entry[0] == "formalisms/SimpleClassDiagrams"
- assert entry[1].startswith("type mappings/")
- assert entry[2] == None
- # Create bottom and query afterwards
- alter_context("users/user/test/a", "formalisms/Bottom")
- element_list_nice("users/user/test/a")
- alter_context("users/user/test/a", "formalisms/SimpleClassDiagrams")
- lst = model_types("users/user/test/a")
- assert len(lst) == 2
- got = set()
- while lst:
- entry = lst.pop()
- assert entry[0] in ["formalisms/SimpleClassDiagrams", "formalisms/Bottom"]
- assert entry[0] not in got
- got.add(entry[0])
- assert entry[1].startswith("type mappings/")
- assert entry[2] == None
- # No type mapping for type mappings
- assert model_types(entry[1]) == set([("formalisms/TypeMapping", None, None)])
- # But there will be as soon as we open it
- element_list_nice(entry[1])
- lst = model_types(entry[1])
- assert len(lst) == 1
- entry = lst.pop()
- assert entry[0] == "formalisms/TypeMapping"
- assert entry[1].startswith("type mappings/")
- assert entry[2] == None
- # Test non-existing model
- try:
- model_types("adfadf")
- self.fail()
- except UnknownModel:
- pass
- # Test non-model location
- assert model_types("formalisms") == set([])
- def test_op_folder_create(self):
- # Create a folder
- assert folder_create("users/user/test/folder_a") == None
- assert model_list_full("users/user/test/") == set([("folder_a/", "user", "nobody", "200")])
- # Create folder with trailing slash
- assert folder_create("users/user/test/folder_b/") == None
- assert model_list_full("users/user/test/") == set([("folder_a/", "user", "nobody", "200"), ("folder_b/", "user", "nobody", "200")])
- assert model_list_full("users/user/test/folder_b") == set()
- # Create multiple folders
- assert folder_create("users/user/test/folder_a/folder_b/folder_c/folder_d") == None
- assert model_list_full("users/user/test/") == set([("folder_a/", "user", "nobody", "200"), ("folder_b/", "user", "nobody", "200")])
- assert model_list_full("users/user/test/folder_a") == set([("folder_b/", "user", "nobody", "200")])
- assert model_list_full("users/user/test/folder_a/folder_b") == set([("folder_c/", "user", "nobody", "200")])
- assert model_list_full("users/user/test/folder_a/folder_b/folder_c") == set([("folder_d/", "user", "nobody", "200")])
- # Create folder in non-writable location
- try:
- folder_create("a")
- self.fail()
- except WritePermissionDenied:
- pass
- assert "a" not in model_list("")
- # Create folder that already exists
- try:
- folder_create("users/user/test/folder_a")
- self.fail()
- except FolderExists:
- pass
- def test_op_alter_context(self):
- # Create a model that we will use
- model_add("users/user/test/a", "formalisms/ProcessModel", """
- Start start {}
- Finish finish {}
- """)
- # List elements using default context, that of creation
- lst = element_list_nice("users/user/test/a")
- assert len(lst) == 2
- assert {"__id": "start", "__type": "Start"} in lst
- assert {"__id": "finish", "__type": "Finish"} in lst
- # List elements using bottom context
- alter_context("users/user/test/a", "formalisms/Bottom")
- lst = element_list_nice("users/user/test/a")
- assert len(lst) == 2
- assert {"__id": "start", "__type": "Node"} in lst
- assert {"__id": "finish", "__type": "Node"} in lst
- # Switch back to default context
- alter_context("users/user/test/a", "formalisms/ProcessModel")
- lst = element_list_nice("users/user/test/a")
- assert len(lst) == 2
- assert {"__id": "start", "__type": "Start"} in lst
- assert {"__id": "finish", "__type": "Finish"} in lst
- # Switch to a non-existing context
- alter_context("users/user/test/a", "non-existing")
- try:
- element_list_nice("users/user/test/a")
- self.fail()
- except UnknownModel:
- pass
- # Set context for an unknown model
- # Note that this will only register locally, without communicating with the Modelverse
- # as such, errors are not noticed until the element is accessed!
- alter_context("non-existing", "formalisms/SimpleClassDiagrams")
- def test_op_element_list(self):
- model_add("users/user/test/a", "formalisms/ProcessModel", """
- Start start {}
- Finish finish {}
- Next nxt (start, finish) {}
- """)
- # Basic operation
- lst = element_list("users/user/test/a")
- assert len(lst) == 3
- assert ("start", "Start") in lst
- assert ("finish", "Finish") in lst
- assert ("nxt", "Next") in lst
- # Try on non-existing model
- try:
- element_list("a")
- self.fail()
- except UnknownModel:
- pass
- # Try a non-readable model
- try:
- element_list("administration/core")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permission, but can query
- assert type(element_list("formalisms/SimpleClassDiagrams")) == set
- def test_op_element_list_nice(self):
- # Test simple element_list_nice
- model_add("users/user/test/a", "formalisms/ProcessModel", """
- Start start {}
- Finish finish {}
- Next nxt (start, finish) {}
- """)
- # Basic operation
- lst = element_list_nice("users/user/test/a")
- assert len(lst) == 3
- assert {"__id": "start", "__type": "Start"} in lst
- assert {"__id": "finish", "__type": "Finish"} in lst
- assert {"__id": "nxt", "__type": "Next", "__source": "start", "__target": "finish"} in lst
- # Test a model with attributes
- model_add("users/user/test/b", "formalisms/ProcessModel", """
- Start start {}
- Exec exec1 {
- name = "first exec"
- }
- Finish finish {}
- Data d1 {
- name = "data 1"
- type = "type 1"
- }
- Next n1 (start, exec1) {}
- Next n2 (exec1, finish) {}
- Produces p1 (exec1, d1) {
- name = "producer"
- }
- """)
- lst = element_list_nice("users/user/test/b")
- assert len(lst) == 7
- assert {"__id": "start", "__type": "Start"} in lst
- assert {"__id": "finish", "__type": "Finish"} in lst
- assert {"__id": "exec1", "__type": "Exec", "name": "first exec"} in lst
- assert {"__id": "d1", "__type": "Data", "name": "data 1", "type": "type 1"} in lst
- assert {"__id": "n1", "__type": "Next", "__source": "start", "__target": "exec1"} in lst
- assert {"__id": "n2", "__type": "Next", "__source": "exec1", "__target": "finish"} in lst
- assert {"__id": "p1", "__type": "Produces", "__source": "exec1", "__target": "d1", "name": "producer"} in lst
- # Try one with defined attributes
- model_add("users/user/test/c", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute Natural {
- name = "natural"
- }
- SimpleAttribute String {
- name = "string"
- }
- Class place {
- name = "Place"
- name : String
- capacity : Natural
- }
- Class transition {
- name = "Transition"
- name : String
- }
- Association p2t (place, transition) {
- name = "P2T"
- weight : Natural
- }
- Association t2p (transition, place) {
- name = "T2P"
- weight : Natural
- }
- """)
- lst = element_list_nice("users/user/test/c")
- assert len(lst) == 11
- assert {"__id": "Natural", "__type": "SimpleAttribute", "constraint": {"AL": ""}, "name": "natural"} in lst
- assert {"__id": "String", "__type": "SimpleAttribute", "constraint": {"AL": ""}, "name": "string"} in lst
- assert {"__id": "place", "name": "Place", "__type": "Class", "constraint": {"AL": ""}, "lower_cardinality": None, "upper_cardinality": None, "abstract": None} in lst
- assert {"__id": "transition", "name": "Transition", "__type": "Class", "constraint": {"AL": ""}, "lower_cardinality": None, "upper_cardinality": None, "abstract": None} in lst
- assert {"__id": "p2t", "name": "P2T", "__type": "Association", "__source": "place", "__target": "transition", "constraint": {"AL": ""}, "source_lower_cardinality": None, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": None, "abstract": None, "lower_cardinality": None, "upper_cardinality": None} in lst
- assert {"__id": "t2p", "name": "T2P", "__type": "Association", "__source": "transition", "__target": "place", "constraint": {"AL": ""}, "source_lower_cardinality": None, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": None, "abstract": None, "lower_cardinality": None, "upper_cardinality": None} in lst
- assert {"__id": "place_name", "__type": "AttributeLink", "__source": "place", "__target": "String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "place_capacity", "__type": "AttributeLink", "__source": "place", "__target": "Natural", "name": "capacity", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "transition_name", "__type": "AttributeLink", "__source": "transition", "__target": "String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "p2t_weight", "__type": "AttributeLink", "__source": "p2t", "__target": "Natural", "name": "weight", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "t2p_weight", "__type": "AttributeLink", "__source": "t2p", "__target": "Natural", "name": "weight", "optional": False, "constraint": {"AL": ""}} in lst
- # Try on non-existing model
- try:
- element_list_nice("a")
- self.fail()
- except UnknownModel:
- pass
- # Try a non-readable model
- try:
- element_list_nice("administration/core")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permission, but can query
- assert type(element_list_nice("formalisms/SimpleClassDiagrams")) == list
- def test_op_types(self):
- # Try operation of unopened model
- assert types("formalisms/ProcessModel") == element_list("formalisms/SimpleClassDiagrams")
- # Try simple operation
- model_add("users/user/test/a", "formalisms/ProcessModel", """
- Start start {}
- Finish finish {}
- Next nxt (start, finish) {}
- """)
- assert types("users/user/test/a") == element_list("formalisms/ProcessModel")
- alter_context("users/user/test/a", "formalisms/Bottom")
- assert types("users/user/test/a") == element_list("formalisms/Bottom")
- # Try for model that we cannot read
- try:
- types("administration/core")
- self.fail()
- except ReadPermissionDenied:
- pass
-
- # Try for non-existing model
- try:
- types("a")
- self.fail()
- except UnknownModel:
- pass
- # Try for a metamodel that we are not allowed to read, although the model may be read
- model_add("users/user/test/b", "formalisms/SimpleClassDiagrams")
- assert types("users/user/test/b") == element_list("formalisms/SimpleClassDiagrams")
- alter_context("users/user/test/b", "administration/core")
- try:
- types("users/user/test/b")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permission for either M or MM, but can query
- assert type(types("formalisms/SimpleClassDiagrams")) == set
- def test_op_read_info(self):
- # Basic case
- model_add("users/user/test/a", "formalisms/ProcessModel", """
- Start start {}
- Finish finish {}
- Next nxt (start, finish) {}
- """)
- assert read_info("users/user/test/a", "start") == ("Start", None)
- assert read_info("users/user/test/a", "finish") == ("Finish", None)
- assert read_info("users/user/test/a", "nxt") == ("Next", ("start", "finish"))
- # Read using different metamodel
- alter_context("users/user/test/a", "formalisms/Bottom")
- assert read_info("users/user/test/a", "start") == ("Node", None)
- assert read_info("users/user/test/a", "finish") == ("Node", None)
- assert read_info("users/user/test/a", "nxt") == ("Edge", ("start", "finish"))
- # Non-existing element
- try:
- read_info("users/user/test/a", "notthere")
- self.fail()
- except UnknownElement:
- pass
- # Non-existing model
- try:
- read_info("users/user/test/b", "start")
- self.fail()
- except UnknownModel:
- pass
- # No read permission
- try:
- read_info("administration/core", "administration")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permission, but can query
- assert type(read_info("formalisms/SimpleClassDiagrams", "Class")) == tuple
- def test_op_read_attrs(self):
- # Basic behaviour
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute Natural {
- name = "natural"
- }
- SimpleAttribute String {
- name = "string"
- }
- Class Place {
- name = "Place"
- name : String
- capacity : Natural
- }
- Class Transition {
- name = "Transition"
- name : String
- }
- Association P2T (Place, Transition) {
- name = "P2T"
- weight : Natural
- }
- Association T2P (Transition, Place) {
- name = "T2P"
- weight : Natural
- }
- """)
- assert read_attrs("users/user/test/a", "Natural") == {"constraint": {"AL": ""}, "name": "natural"}
- assert read_attrs("users/user/test/a", "String") == {"constraint": {"AL": ""}, "name": "string"}
- assert read_attrs("users/user/test/a", "Place") == {"constraint": {"AL": ""}, "name": "Place", "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- assert read_attrs("users/user/test/a", "Transition") == {"constraint": {"AL": ""}, "name": "Transition", "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- assert read_attrs("users/user/test/a", "P2T") == {"constraint": {"AL": ""}, "name": "P2T", "source_lower_cardinality": None, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": None, "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- assert read_attrs("users/user/test/a", "T2P") == {"constraint": {"AL": ""}, "name": "T2P", "source_lower_cardinality": None, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": None, "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- model_add("users/user/test/b", "users/user/test/a", """
- Place p1 {
- name = "place 1"
- capacity = 2
- }
- Place p2 {
- name = "place 2"
- capacity = 1
- }
- Transition t1 {
- name = "transition"
- }
-
- P2T p2t (p1, t1) {
- weight = 4
- }
- T2P t2p (t1, p2) {
- weight = 10
- }
- """)
- assert read_attrs("users/user/test/b", "p1") == {"name": "place 1", "capacity": 2}
- assert read_attrs("users/user/test/b", "p2") == {"name": "place 2", "capacity": 1}
- assert read_attrs("users/user/test/b", "t1") == {"name": "transition"}
- assert read_attrs("users/user/test/b", "p2t") == {"weight": 4}
- assert read_attrs("users/user/test/b", "t2p") == {"weight": 10}
- # Non-existing model
- try:
- read_attrs("users/afa", "p1")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- try:
- read_attrs("users/user/test/a", "PPPPPPP")
- self.fail()
- except UnknownElement:
- pass
- # No read permissions
- try:
- read_attrs("administration/core", "formalisms")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions, but can query
- assert type(read_attrs("formalisms/SimpleClassDiagrams", "Class")) == type(dict())
- def test_op_attr_assign(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute Natural {
- name = "natural"
- }
- SimpleAttribute String {
- name = "string"
- }
- Class Place {
- name = "Place"
- name : String
- capacity : Natural
- }
- Class Transition {
- name = "Transition"
- name : String
- }
- Association P2T (Place, Transition) {
- name = "P2T"
- weight : Natural
- }
- Association T2P (Transition, Place) {
- name = "T2P"
- weight : Natural
- }
- """)
- assert read_attrs("users/user/test/a", "Natural") == {"constraint": {"AL": ""}, "name": "natural"}
- assert attr_assign("users/user/test/a", "Natural", "name", "nat") == None
- assert read_attrs("users/user/test/a", "Natural") == {"constraint": {"AL": ""}, "name": "nat"}
- assert read_attrs("users/user/test/a", "Place") == {"constraint": {"AL": ""}, "name": "Place", "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- assert attr_assign("users/user/test/a", "Place", "name", "NewPlace") == None
- assert attr_assign("users/user/test/a", "Place", "abstract", False) == None
- assert attr_assign("users/user/test/a", "Place", "lower_cardinality", 4) == None
- assert read_attrs("users/user/test/a", "Place") == {"constraint": {"AL": ""}, "name": "NewPlace", "abstract": False, "lower_cardinality": 4, "upper_cardinality": None}
- assert read_attrs("users/user/test/a", "P2T") == {"constraint": {"AL": ""}, "name": "P2T", "source_lower_cardinality": None, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": None, "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- assert attr_assign("users/user/test/a", "P2T", "name", "PPP") == None
- assert attr_assign("users/user/test/a", "P2T", "source_lower_cardinality", 1) == None
- assert attr_assign("users/user/test/a", "P2T", "target_upper_cardinality", 10) == None
- assert read_attrs("users/user/test/a", "P2T") == {"constraint": {"AL": ""}, "name": "PPP", "source_lower_cardinality": 1, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": 10, "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- model_add("users/user/test/b", "users/user/test/a", """
- Place p1 {
- name = "place 1"
- capacity = 2
- }
- Place p2 {
- name = "place 2"
- capacity = 1
- }
- Transition t1 {
- name = "transition"
- }
-
- P2T p2t (p1, t1) {
- weight = 4
- }
- T2P t2p (t1, p2) {
- weight = 10
- }
- """)
- assert read_attrs("users/user/test/b", "p1") == {"name": "place 1", "capacity": 2}
- assert attr_assign("users/user/test/b", "p1", "name", "place 3") == None
- assert attr_assign("users/user/test/b", "p1", "capacity", 3) == None
- assert read_attrs("users/user/test/b", "p1") == {"name": "place 3", "capacity": 3}
- assert read_attrs("users/user/test/b", "p2t") == {"weight": 4}
- assert attr_assign("users/user/test/b", "p2t", "weight", 0) == None
- assert read_attrs("users/user/test/b", "p2t") == {"weight": 0}
- # Non-existing model
- try:
- attr_assign("users/afa", "p1", "name", "abc")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- try:
- attr_assign("users/user/test/a", "PPPPPPP", "name", "abc")
- self.fail()
- except UnknownElement:
- pass
- # No read permissions
- try:
- attr_assign("administration/core", "formalisms", "name", "abc")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions
- try:
- attr_assign("formalisms/SimpleClassDiagrams", "Class", "name", "abc")
- self.fail()
- except WritePermissionDenied:
- pass
- # No such attribute
- try:
- attr_assign("users/user/test/a", "Place", "ddd", 1)
- self.fail()
- except UnknownAttribute:
- pass
- # Assign None, equals to attr_delete
- assert read_attrs("users/user/test/a", "Place") == {"constraint": {"AL": ""}, "name": "NewPlace", "abstract": False, "lower_cardinality": 4, "upper_cardinality": None}
- attr_assign("users/user/test/a", "Place", "name", None)
- assert read_attrs("users/user/test/a", "Place") == {"constraint": {"AL": ""}, "name": None, "abstract": False, "lower_cardinality": 4, "upper_cardinality": None}
- def test_op_attr_delete(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute Natural {
- name = "natural"
- }
- SimpleAttribute String {
- name = "string"
- }
- Class Place {
- name = "Place"
- name : String
- capacity : Natural
- }
- Class Transition {
- name = "Transition"
- name : String
- }
- Association P2T (Place, Transition) {
- name = "P2T"
- weight : Natural
- }
- Association T2P (Transition, Place) {
- name = "T2P"
- weight : Natural
- }
- """)
- assert read_attrs("users/user/test/a", "Natural") == {"constraint": {"AL": ""}, "name": "natural"}
- assert attr_delete("users/user/test/a", "Natural", "name") == None
- assert read_attrs("users/user/test/a", "Natural") == {"constraint": {"AL": ""}, "name": None}
- assert read_attrs("users/user/test/a", "Place") == {"constraint": {"AL": ""}, "name": "Place", "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- assert attr_delete("users/user/test/a", "Place", "name") == None
- assert attr_delete("users/user/test/a", "Place", "abstract") == None
- assert attr_delete("users/user/test/a", "Place", "lower_cardinality") == None
- assert read_attrs("users/user/test/a", "Place") == {"constraint": {"AL": ""}, "name": None, "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- assert read_attrs("users/user/test/a", "P2T") == {"constraint": {"AL": ""}, "name": "P2T", "source_lower_cardinality": None, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": None, "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- assert attr_delete("users/user/test/a", "P2T", "name") == None
- assert attr_delete("users/user/test/a", "P2T", "source_lower_cardinality") == None
- assert attr_delete("users/user/test/a", "P2T", "target_upper_cardinality") == None
- assert read_attrs("users/user/test/a", "P2T") == {"constraint": {"AL": ""}, "name": None, "source_lower_cardinality": None, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": None, "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- model_add("users/user/test/b", "users/user/test/a", """
- Place p1 {
- name = "place 1"
- capacity = 2
- }
- Place p2 {
- name = "place 2"
- capacity = 1
- }
- Transition t1 {
- name = "transition"
- }
-
- P2T p2t (p1, t1) {
- weight = 4
- }
- T2P t2p (t1, p2) {
- weight = 10
- }
- """)
- assert read_attrs("users/user/test/b", "p1") == {"name": "place 1", "capacity": 2}
- assert attr_delete("users/user/test/b", "p1", "capacity") == None
- assert read_attrs("users/user/test/b", "p1") == {"name": "place 1", "capacity": None}
- assert read_attrs("users/user/test/b", "p2t") == {"weight": 4}
- assert attr_delete("users/user/test/b", "p2t", "weight") == None
- assert read_attrs("users/user/test/b", "p2t") == {"weight": None}
- # Non-existing model
- try:
- attr_delete("users/afa", "p1", "name")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- try:
- attr_delete("users/user/test/a", "PPPPPPP", "name")
- self.fail()
- except UnknownElement:
- pass
- # No read permissions
- try:
- attr_delete("administration/core", "formalisms", "name")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions
- try:
- attr_delete("formalisms/SimpleClassDiagrams", "Class", "name")
- self.fail()
- except WritePermissionDenied:
- pass
- # No such attribute
- try:
- attr_delete("users/user/test/a", "Place", "ddd")
- self.fail()
- except UnknownAttribute:
- pass
- def test_op_attr_delete_code(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute Natural {
- name = "natural"
- }
- SimpleAttribute String {
- name = "string"
- }
- Class Place {
- name = "Place"
- name : String
- capacity : Natural
- }
- Class Transition {
- name = "Transition"
- name : String
- }
- Association P2T (Place, Transition) {
- name = "P2T"
- weight : Natural
- }
- Association T2P (Transition, Place) {
- name = "T2P"
- weight : Natural
- }
- """)
- # Test what happens if removing a non-existing AL attribute
- assert read_attrs("users/user/test/a", "Place") == {"constraint": {"AL": ""}, "name": "Place", "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- attr_delete("users/user/test/a", "Place", "constraint")
- assert read_attrs("users/user/test/a", "Place") == {"constraint": {"AL": ""}, "name": "Place", "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- # Test what happens if removing an existing AL attribute
- attr_assign_code("users/user/test/a", "Place", "constraint", """
- String function a(value : Element):
- return "OK"!
- """)
- attrs = read_attrs("users/user/test/a", "Place")
- assert "AL" in attrs["constraint"]
- assert attrs["constraint"]["AL"] != ""
- attr_delete("users/user/test/a", "Place", "constraint")
- assert read_attrs("users/user/test/a", "Place") == {"constraint": {"AL": ""}, "name": "Place", "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- def test_op_attr_assign_code(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute Natural {
- name = "natural"
- }
- SimpleAttribute String {
- name = "string"
- }
- Class Place {
- name = "Place"
- name : String
- capacity : Natural
- }
- Class Transition {
- name = "Transition"
- name : String
- }
- Association P2T (Place, Transition) {
- name = "P2T"
- weight : Natural
- }
- Association T2P (Transition, Place) {
- name = "T2P"
- weight : Natural
- }
- """)
- # Test ordinary case
- assert read_attrs("users/user/test/a", "Place") == {"constraint": {"AL": ""}, "name": "Place", "abstract": None, "lower_cardinality": None, "upper_cardinality": None}
- assert attr_assign_code("users/user/test/a", "Place", "constraint", """
- String function a(value : Element):
- return "OK"!
- """) == None
- attrs = read_attrs("users/user/test/a", "Place")
- assert "AL" in attrs["constraint"]
- assert attrs["constraint"]["AL"] != ""
- assert AL_text(attrs["constraint"]["AL"]).strip() == """
- String function a(value : Element):
- return "OK"!
- """.strip()
- # Test assign when already assigned
- attrs = read_attrs("users/user/test/a", "Place")
- old_location = attrs["constraint"]["AL"]
- old_text = AL_text(attrs["constraint"]["AL"])
- assert attr_assign_code("users/user/test/a", "Place", "constraint", """
- String function a(value : Element):
- return "NOK"!
- """) == None
- attrs = read_attrs("users/user/test/a", "Place")
- assert "AL" in attrs["constraint"]
- assert attrs["constraint"]["AL"] != ""
- assert attrs["constraint"]["AL"] != old_location
- assert AL_text(attrs["constraint"]["AL"]).strip() == """
- String function a(value : Element):
- return "NOK"!
- """.strip()
- assert AL_text(attrs["constraint"]["AL"]).strip () != old_text.strip()
- simple_code = \
- """
- String function a(value : Element):
- return "OK"!
- """
- # Non-existing model
- try:
- attr_assign_code("users/afa", "p1", "name", simple_code)
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- try:
- attr_assign_code("users/user/test/a", "PPPPPPP", "name", simple_code)
- self.fail()
- except UnknownElement:
- pass
- # No read permissions
- try:
- attr_assign_code("administration/core", "formalisms", "name", simple_code)
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions
- try:
- attr_assign_code("formalisms/SimpleClassDiagrams", "Class", "name", simple_code)
- self.fail()
- except WritePermissionDenied:
- pass
- # No such attribute
- try:
- attr_assign_code("users/user/test/a", "Place", "ddd", simple_code)
- self.fail()
- except UnknownAttribute:
- pass
- # Compilation error
- try:
- attr_assign_code("users/user/test/a", "Place", "constraint", "abc")
- self.fail()
- except CompilationError:
- pass
- def test_op_instantiate(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- assert element_list("users/user/test/a") == set([])
- # Instantiate node element
- ID = instantiate("users/user/test/a", "Class")
- assert element_list("users/user/test/a") == set([(ID, "Class")])
- assert read_info("users/user/test/a", ID) == ("Class", None)
- # Instantiate node element with ID
- ID2 = instantiate("users/user/test/a", "Class", ID="new_node")
- assert ID2 == "new_node"
- assert element_list("users/user/test/a") == set([(ID, "Class"), (ID2, "Class")])
- assert read_info("users/user/test/a", ID2) == ("Class", None)
- # Instantiate edge element
- ID3 = instantiate("users/user/test/a", "Association", edge=(ID, ID2))
- assert element_list("users/user/test/a") == set([(ID, "Class"), (ID2, "Class"), (ID3, "Association")])
- assert read_info("users/user/test/a", ID3) == ("Association", (ID, ID2))
- # Instantiate edge element with ID
- ID4 = instantiate("users/user/test/a", "Association", edge=(ID, ID2), ID="new_edge")
- assert ID4 == "new_edge"
- assert element_list("users/user/test/a") == set([(ID, "Class"), (ID2, "Class"), (ID3, "Association"), (ID4, "Association")])
- assert read_info("users/user/test/a", ID4) == ("Association", (ID, ID2))
- # Instantiate edge from edge (source)
- ID5 = instantiate("users/user/test/a", "Association", edge=(ID3, ID))
- assert element_list("users/user/test/a") == set([(ID, "Class"), (ID2, "Class"), (ID3, "Association"), (ID4, "Association"), (ID5, "Association")])
- assert read_info("users/user/test/a", ID5) == ("Association", (ID3, ID))
- # Instantiate edge from edge (target)
- ID6 = instantiate("users/user/test/a", "Association", edge=(ID, ID3))
- assert element_list("users/user/test/a") == set([(ID, "Class"), (ID2, "Class"), (ID3, "Association"), (ID4, "Association"), (ID5, "Association"), (ID6, "Association")])
- assert read_info("users/user/test/a", ID6) == ("Association", (ID, ID3))
- # Instantiate edge from edge (source and target)
- ID7 = instantiate("users/user/test/a", "Association", edge=(ID3, ID4))
- assert element_list("users/user/test/a") == set([(ID, "Class"), (ID2, "Class"), (ID3, "Association"), (ID4, "Association"), (ID5, "Association"), (ID6, "Association"), (ID7, "Association")])
- assert read_info("users/user/test/a", ID7) == ("Association", (ID3, ID4))
- # Non-existing model
- try:
- instantiate("users/afa", "Association")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- before = element_list("users/user/test/a")
- try:
- instantiate("users/user/test/a", "AAAAAAA")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # No read permissions
- try:
- instantiate("administration/core", "formalisms")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions
- before = element_list("users/user/test/a")
- try:
- instantiate("formalisms/SimpleClassDiagrams", "Class")
- self.fail()
- except WritePermissionDenied:
- assert element_list("users/user/test/a") == before
- # Pre-existing ID requested (node)
- before = element_list("users/user/test/a")
- try:
- instantiate("users/user/test/a", "Class", ID=ID)
- self.fail()
- except ElementExists:
- assert element_list("users/user/test/a") == before
- # Pre-existing ID requested (edge)
- before = element_list("users/user/test/a")
- try:
- instantiate("users/user/test/a", "Association", ID=ID, edge=(ID2, ID3))
- self.fail()
- except ElementExists:
- assert element_list("users/user/test/a") == before
- # Edge from non-existing ID
- before = element_list("users/user/test/a")
- try:
- instantiate("users/user/test/a", "Association", ID=ID, edge=("non-existing", ID3))
- self.fail()
- except ElementExists:
- assert element_list("users/user/test/a") == before
- # Edge to non-existing ID
- before = element_list("users/user/test/a")
- try:
- instantiate("users/user/test/a", "Association", ID=ID, edge=("non-existing", ID3))
- self.fail()
- except ElementExists:
- assert element_list("users/user/test/a") == before
- # Edge both non-existing ID
- before = element_list("users/user/test/a")
- try:
- instantiate("users/user/test/a", "Association", ID=ID, edge=("non-existing", "non-existing2"))
- self.fail()
- except ElementExists:
- assert element_list("users/user/test/a") == before
- # Garbage type
- before = element_list("users/user/test/a")
- try:
- instantiate("users/user/test/a", ("a", "b"))
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # Garbage edge src
- before = element_list("users/user/test/a")
- try:
- instantiate("users/user/test/a", "Association", edge=(('a', 'b'), "non-existing2"))
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # Garbage edge dst
- before = element_list("users/user/test/a")
- try:
- instantiate("users/user/test/a", "Association", edge=("non-existing", ('a', 'b')))
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # Test instantiating node as edge
- before = element_list("users/user/test/a")
- try:
- instantiate("users/user/test/a", "Class", edge=("a", "b"))
- self.fail()
- except IncorrectFormat:
- assert element_list("users/user/test/a") == before
- # Test instantiating edge as node
- before = element_list("users/user/test/a")
- try:
- instantiate("users/user/test/a", "Association")
- self.fail()
- except IncorrectFormat:
- assert element_list("users/user/test/a") == before
- def test_op_delete_element(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- Class A {}
- """)
- # Test simple delete
- assert len(element_list_nice("users/user/test/a")) == 1
- assert delete_element("users/user/test/a", "A") == None
- assert len(element_list_nice("users/user/test/a")) == 0
- model_add("users/user/test/b", "formalisms/SimpleClassDiagrams", """
- Class A {}
- Class B {}
- Association (A, B) {}
- """)
- # Test delete of element that causes other elements to be deleted as well
- assert len(element_list_nice("users/user/test/b")) == 3
- assert delete_element("users/user/test/b", "A") == None
- assert len(element_list_nice("users/user/test/b")) == 1
- model_add("users/user/test/c", "formalisms/SimpleClassDiagrams", """
- Class A {}
- Class B {}
- Association C (A, B) {}
- """)
- # Test delete of edge that causes other elements to be deleted as well
- assert len(element_list_nice("users/user/test/c")) == 3
- assert delete_element("users/user/test/c", "C") == None
- assert len(element_list_nice("users/user/test/c")) == 2
- model_add("users/user/test/d", "formalisms/SimpleClassDiagrams", """
- Class A {
- name = "A"
- }
- """)
- # Test delete of a "hidden" element
- assert element_list_nice("users/user/test/d") == [{"__type" : "Class", "__id": "A", "lower_cardinality": None, "upper_cardinality": None, "constraint": {"AL": ""}, "name": "A", "abstract": None}]
- ID = [i for i in element_list("users/user/test/d") if i[1] == "Class_name"][0][0]
- assert delete_element("users/user/test/d", ID) == None
- assert element_list_nice("users/user/test/d") == [{"__type" : "Class", "__id": "A", "lower_cardinality": None, "upper_cardinality": None, "constraint": {"AL": ""}, "name": None, "abstract": None}]
- # Non-existing model
- try:
- delete_element("users/afa", "Association")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- before = element_list("users/user/test/a")
- try:
- delete_element("users/user/test/a", "AAAAAAA")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # No read permissions
- try:
- delete_element("administration/core", "formalisms")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions
- before = element_list("formalisms/SimpleClassDiagrams")
- try:
- delete_element("formalisms/SimpleClassDiagrams", "Class")
- self.fail()
- except WritePermissionDenied:
- assert element_list("formalisms/SimpleClassDiagrams") == before
- # Give garbage
- assert element_list_nice("users/user/test/d") == [{"__type" : "Class", "__id": "A", "lower_cardinality": None, "upper_cardinality": None, "constraint": {"AL": ""}, "name": None, "abstract": None}]
- try:
- delete_element("users/user/test/d", ('abc', 'def'))
- except UnknownElement:
- assert element_list_nice("users/user/test/d") == [{"__type" : "Class", "__id": "A", "lower_cardinality": None, "upper_cardinality": None, "constraint": {"AL": ""}, "name": None, "abstract": None}]
- def test_op_AL_text(self):
- # Test normal situation with code provided by assignment
- model_add("users/user/test/b", "formalisms/SimpleClassDiagrams", """
- Class A {}
- """)
- attr_assign_code("users/user/test/b", "A", "constraint", """
- String function main(value : Element):
- return "OK"!
- """)
- assert AL_text(read_attrs("users/user/test/b", "A")["constraint"]["AL"]).strip() == """
- String function main(value : Element):
- return "OK"!
- """.strip()
- # Test normal situation with code provided by HUTN parser (model)
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- Class A {
- constraint = $
- String function main(value : Element):
- return "OK"!
- $
- }
- """)
- assert AL_text(read_attrs("users/user/test/a", "A")["constraint"]["AL"]).strip() == 'String function main(value : Element):\n\treturn "OK"!'
- # Test AL_text on non-existing location
- try:
- AL_text("abc")
- self.fail()
- except UnknownLocation:
- pass
- # No permissions on locations directly, so there are no checks that have to be done
- def test_op_read_outgoing(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class A {
- name : String
- }
- Class B {}
- Association C (A, B) {}
- Association D (C, B) {}
- """)
- # Test normal operation
- assert read_outgoing("users/user/test/a", "A", "Association") == set(["C"])
- assert read_outgoing("users/user/test/a", "A", "AttributeLink") == set(["A_name"])
- # Test wildcard
- assert read_outgoing("users/user/test/a", "A", "") == set(["A_name", "C"])
- # Test association on association
- assert read_outgoing("users/user/test/a", "C", "") == set(["D"])
- # Test empty result
- assert read_outgoing("users/user/test/a", "B", "") == set([])
- # Test simpleattribute
- assert read_outgoing("users/user/test/a", "String", "") == set([])
- # Non-existing model
- try:
- read_outgoing("users/afa", "Association", "")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- before = element_list("users/user/test/a")
- try:
- read_outgoing("users/user/test/a", "AAAAAAA", "")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # Non-existing type
- before = element_list("users/user/test/a")
- try:
- read_outgoing("users/user/test/a", "A", "AAAAAAA")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # No read permissions
- try:
- read_outgoing("administration/core", "formalisms", "")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions, but can query
- assert type(read_outgoing("formalisms/SimpleClassDiagrams", "Class", "")) == type(set())
- def test_op_read_incoming(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class A {
- name : String
- }
- Class B {}
- Association C (A, B) {}
- Association E (A, A) {}
- Association D (C, B) {}
- Association F (D, E) {}
- """)
- # Test normal operation
- assert read_incoming("users/user/test/a", "B", "Association") == set(["C", "D"])
- # Test wildcard
- assert read_incoming("users/user/test/a", "B", "") == set(["C", "D"])
- # Test association on association
- assert read_incoming("users/user/test/a", "E", "") == set(["F"])
- # Test double result
- assert read_incoming("users/user/test/a", "A", "") == set(["E"])
- # Test simpleattribute
- assert read_incoming("users/user/test/a", "String", "") == set(["A_name"])
- # Test empty result
- assert read_incoming("users/user/test/a", "F", "") == set([])
- # Non-existing model
- try:
- read_incoming("users/afa", "Association", "")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- before = element_list("users/user/test/a")
- try:
- read_incoming("users/user/test/a", "AAAAAAA", "")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # Non-existing type
- before = element_list("users/user/test/a")
- try:
- read_incoming("users/user/test/a", "A", "AAAAAAA")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # No read permissions
- try:
- read_incoming("administration/core", "formalisms", "")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions, but can query
- assert type(read_incoming("formalisms/SimpleClassDiagrams", "Class", "")) == type(set())
- def test_op_read_association_source(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class A {
- name : String
- }
- Class B {}
- Association C (A, B) {}
- Association E (A, A) {}
- Association D (C, B) {}
- Association F (D, E) {}
- """)
- # Test normal operation
- assert read_association_source("users/user/test/a", "C") == "A"
- # Test association on association
- assert read_association_source("users/user/test/a", "D") == "C"
- # Test node
- try:
- assert read_association_source("users/user/test/a", "A")
- self.fail()
- except NotAnAssociation:
- pass
- # Non-existing model
- try:
- read_association_source("users/afa", "Association")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- before = element_list("users/user/test/a")
- try:
- read_association_source("users/user/test/a", "AAAAAAA")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # No read permissions
- try:
- read_association_source("administration/core", "formalisms")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions, but can query
- assert read_association_source("formalisms/SimpleClassDiagrams", "Association") == "Class"
- # Not an association
- try:
- read_association_source("users/user/test/a", "A")
- self.fail()
- except NotAnAssociation:
- pass
- def test_op_read_association_destination(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class A {
- name : String
- }
- Class B {}
- Association C (A, B) {}
- Association E (A, A) {}
- Association D (C, B) {}
- Association F (D, E) {}
- """)
- # Test normal operation
- assert read_association_destination("users/user/test/a", "C") == "B"
- # Test association on association
- assert read_association_destination("users/user/test/a", "F") == "E"
- # Test node
- try:
- assert read_association_destination("users/user/test/a", "A")
- self.fail()
- except NotAnAssociation:
- pass
- # Non-existing model
- try:
- read_association_destination("users/afa", "Association")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- before = element_list("users/user/test/a")
- try:
- read_association_destination("users/user/test/a", "AAAAAAA")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # No read permissions
- try:
- read_association_destination("administration/core", "formalisms")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions, but can query
- assert read_association_destination("formalisms/SimpleClassDiagrams", "Association") == "Class"
- # Not an association
- try:
- read_association_source("users/user/test/a", "A")
- self.fail()
- except NotAnAssociation:
- pass
- def test_op_connections_between(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class A {
- name1 : String
- name2 : String
- }
- Class B {}
- Association C (A, B) {}
- Association D (A, B) {}
- Association E (A, A) {}
- Association F (C, B) {}
- Association G (E, F) {}
- """)
- # Test normal operation
- assert connections_between("users/user/test/a", "A", "A") == set(["Association", "Inheritance"])
- assert connections_between("users/user/test/a", "A", "B") == set(["Association", "Inheritance"])
- assert connections_between("users/user/test/a", "A", "C") == set(["Association", "Inheritance"])
- # Test none allowed
- assert connections_between("users/user/test/a", "A_name1", "A_name2") == set([])
- # Non-existing model
- try:
- connections_between("users/afa", "A", "B")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element (1)
- before = element_list("users/user/test/a")
- try:
- connections_between("users/user/test/a", "AA", "B")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # Non-existing element (2)
- before = element_list("users/user/test/a")
- try:
- connections_between("users/user/test/a", "A", "BB")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # No read permissions
- try:
- connections_between("administration/core", "formalisms", "formalisms")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions, but can query
- assert connections_between("formalisms/SimpleClassDiagrams", "Association", "Association") == set(["Association", "Inheritance"])
- def test_op_define_attribute(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- SimpleAttribute Natural {}
- Class A {}
- Class B {}
- Association C (A, B) {}
- Association D (C, A) {}
- """)
- assert read_defined_attrs("users/user/test/a", "A") == ({}, {})
- # Test normal operation
- define_attribute("users/user/test/a", "A", "my_attr", "String")
- assert read_defined_attrs("users/user/test/a", "A") == ({"my_attr": "String"}, {})
- # Test second attribute of same type
- define_attribute("users/user/test/a", "A", "my_second_attr", "String")
- assert read_defined_attrs("users/user/test/a", "A") == ({"my_attr": "String", "my_second_attr": "String"}, {})
- # Test third attribute with different type
- define_attribute("users/user/test/a", "A", "a_third_one", "Natural")
- assert read_defined_attrs("users/user/test/a", "A") == ({"my_attr": "String", "my_second_attr": "String", "a_third_one": "Natural"}, {})
- # Test same on associations
- define_attribute("users/user/test/a", "C", "my_attr", "String")
- assert read_defined_attrs("users/user/test/a", "C") == ({"my_attr": "String"}, {})
- # Test second attribute of same type
- define_attribute("users/user/test/a", "C", "my_second_attr", "String")
- assert read_defined_attrs("users/user/test/a", "C") == ({"my_attr": "String", "my_second_attr": "String"}, {})
- # Test third attribute with different type
- define_attribute("users/user/test/a", "C", "a_third_one", "Natural")
- assert read_defined_attrs("users/user/test/a", "C") == ({"my_attr": "String", "my_second_attr": "String", "a_third_one": "Natural"}, {})
- # Non-existing model
- try:
- define_attribute("users/afa", "A", "B", "C")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element (1)
- before = element_list("users/user/test/a")
- try:
- define_attribute("users/user/test/a", "AA", "B", "Natural")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # Non-existing element (2)
- before = element_list("users/user/test/a")
- try:
- define_attribute("users/user/test/a", "A", "B", "Natural2")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # Attribute exists
- before = element_list("users/user/test/a")
- try:
- define_attribute("users/user/test/a", "A", "my_attr", "Natural")
- self.fail()
- except AttributeExists:
- assert element_list("users/user/test/a") == before
- # No read permissions
- before = element_list("users/user/test/a")
- try:
- define_attribute("administration/core", "formalisms", "name", "A")
- self.fail()
- except ReadPermissionDenied:
- assert element_list("users/user/test/a") == before
- # No write permissions
- before = element_list("users/user/test/a")
- try:
- define_attribute("formalisms/SimpleClassDiagrams", "Association", "new_name", "String")
- self.fail()
- except WritePermissionDenied:
- assert element_list("users/user/test/a") == before
- # None defined in non-SCD model
- model_add("users/user/test/b", "users/user/test/a", "A a {}")
- try:
- define_attribute("users/user/test/b", "a", "abc", "a")
- self.fail()
- except UnknownM3:
- pass
- def test_op_read_defined_attrs(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- SimpleAttribute Natural {}
- Class A {
- name = "ABC"
- value : Natural
- new_name ?: String
- name : String
- }
- Association B (A, A) {
- name = "DEF"
- edge_value : Natural
- name : String
- other_value ?: String
- }
- Class C {}
- Class D : A {
- additional_attr : Natural
- }
- Association E : B (D, A) {
- next_attr : String
- }
- """)
- # Normal operation
- assert read_defined_attrs("users/user/test/a", "A") == ({"value": "Natural", "name": "String"}, {"new_name": "String"})
- assert read_defined_attrs("users/user/test/a", "B") == ({"edge_value": "Natural", "name": "String"}, {"other_value": "String"})
- assert read_defined_attrs("users/user/test/a", "C") == ({}, {})
- # Works with inheritance
- assert read_defined_attrs("users/user/test/a", "D") == ({"value": "Natural", "name": "String", "additional_attr": "Natural"}, {"new_name": "String"})
- assert read_defined_attrs("users/user/test/a", "E") == ({"edge_value": "Natural", "name": "String", "next_attr": "String"}, {"other_value": "String"})
- # Non-existing model
- try:
- read_defined_attrs("users/afa", "A")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- before = element_list("users/user/test/a")
- try:
- read_defined_attrs("users/user/test/a", "AA")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # No read permissions
- before = element_list("users/user/test/a")
- try:
- read_defined_attrs("administration/core", "formalisms")
- self.fail()
- except ReadPermissionDenied:
- assert element_list("users/user/test/a") == before
- # No write permissions, but can still query
- assert read_defined_attrs("formalisms/SimpleClassDiagrams", "Association") == ({"name": "String"}, {"abstract": "Boolean", "constraint": "ActionCode", "lower_cardinality": "Natural", "upper_cardinality": "Natural", "source_lower_cardinality": "Natural", "source_upper_cardinality": "Natural", "target_lower_cardinality": "Natural", "target_upper_cardinality": "Natural"})
- # None defined in non-SCD model
- model_add("users/user/test/b", "users/user/test/a", "A a {}")
- try:
- read_defined_attrs("users/user/test/b", "a")
- self.fail()
- except UnknownM3:
- pass
- def test_op_undefine_attribute(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- SimpleAttribute Natural {}
- Class A {
- name = "ABC"
- value : Natural
- new_name ?: String
- name : String
- }
- Association B (A, A) {
- name = "DEF"
- edge_value : Natural
- name : String
- other_value ?: String
- }
- Class C {}
- Class D : A {
- additional_attr : Natural
- }
- Association E : B (D, A) {
- next_attr : String
- }
- """)
- assert read_defined_attrs("users/user/test/a", "A") == ({"value": "Natural", "name": "String"}, {"new_name": "String"})
- assert read_defined_attrs("users/user/test/a", "D") == ({"value": "Natural", "name": "String", "additional_attr": "Natural"}, {"new_name": "String"})
- undefine_attribute("users/user/test/a", "A", "name")
- assert read_defined_attrs("users/user/test/a", "A") == ({"value": "Natural"}, {"new_name": "String"})
- assert read_defined_attrs("users/user/test/a", "D") == ({"value": "Natural", "additional_attr": "Natural"}, {"new_name": "String"})
- assert read_defined_attrs("users/user/test/a", "B") == ({"edge_value": "Natural", "name": "String"}, {"other_value": "String"})
- assert read_defined_attrs("users/user/test/a", "E") == ({"edge_value": "Natural", "name": "String", "next_attr": "String"}, {"other_value": "String"})
- undefine_attribute("users/user/test/a", "B", "other_value")
- assert read_defined_attrs("users/user/test/a", "B") == ({"edge_value": "Natural", "name": "String"}, {})
- assert read_defined_attrs("users/user/test/a", "E") == ({"edge_value": "Natural", "name": "String", "next_attr": "String"}, {})
- # Remove superclass definition
- assert read_defined_attrs("users/user/test/a", "D") == ({"value": "Natural", "additional_attr": "Natural"}, {"new_name": "String"})
- try:
- undefine_attribute("users/user/test/a", "D", "value")
- self.fail()
- except SuperclassAttribute:
- pass
- assert read_defined_attrs("users/user/test/a", "D") == ({"value": "Natural", "additional_attr": "Natural"}, {"new_name": "String"})
- # Non-existing model
- try:
- undefine_attribute("users/afa", "A", "B")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- before = read_defined_attrs("users/user/test/a", "A")
- try:
- undefine_attribute("users/user/test/a", "AA", "B")
- self.fail()
- except UnknownElement:
- assert read_defined_attrs("users/user/test/a", "A") == before
- # Non-existing attribute
- before = read_defined_attrs("users/user/test/a", "A")
- try:
- undefine_attribute("users/user/test/a", "A", "adfadf")
- self.fail()
- except UnknownAttribute:
- assert read_defined_attrs("users/user/test/a", "A") == before
- # No read permissions
- try:
- undefine_attribute("administration/core", "formalisms", "name")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions
- before = read_defined_attrs("formalisms/SimpleClassDiagrams", "Class")
- try:
- undefine_attribute("formalisms/SimpleClassDiagrams", "Class", "name")
- self.fail()
- except WritePermissionDenied:
- assert read_defined_attrs("formalisms/SimpleClassDiagrams", "Class") == before
- def test_op_attribute_optional(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- SimpleAttribute Natural {}
- Class A {
- name = "ABC"
- value : Natural
- new_name ?: String
- name : String
- }
- Association B (A, A) {
- name = "DEF"
- edge_value : Natural
- name : String
- other_value ?: String
- }
- Class C {}
- Class D : A {
- additional_attr : Natural
- }
- Association E : B (D, A) {
- next_attr : String
- }
- """)
- # Check initial situation
- assert read_defined_attrs("users/user/test/a", "A") == ({"value": "Natural", "name": "String"}, {"new_name": "String"})
- assert read_defined_attrs("users/user/test/a", "B") == ({"edge_value": "Natural", "name": "String"}, {"other_value": "String"})
- assert read_defined_attrs("users/user/test/a", "C") == ({}, {})
- assert read_defined_attrs("users/user/test/a", "D") == ({"value": "Natural", "name": "String", "additional_attr": "Natural"}, {"new_name": "String"})
- assert read_defined_attrs("users/user/test/a", "E") == ({"edge_value": "Natural", "name": "String", "next_attr": "String"}, {"other_value": "String"})
- # mandatory -> optional
- attribute_optional("users/user/test/a", "A", "value", True)
- assert read_defined_attrs("users/user/test/a", "A") == ({"name": "String"}, {"new_name": "String", "value": "Natural"})
- # Check inheritance as well
- assert read_defined_attrs("users/user/test/a", "D") == ({"name": "String", "additional_attr": "Natural"}, {"new_name": "String", "value": "Natural"})
- # optional -> mandatory
- attribute_optional("users/user/test/a", "A", "new_name", False)
- assert read_defined_attrs("users/user/test/a", "A") == ({"name": "String", "new_name": "String"}, {"value": "Natural"})
- # Check inheritance as well
- assert read_defined_attrs("users/user/test/a", "D") == ({"name": "String", "additional_attr": "Natural", "new_name": "String"}, {"value": "Natural"})
- # mandatory -> mandatory
- attribute_optional("users/user/test/a", "A", "new_name", False)
- assert read_defined_attrs("users/user/test/a", "A") == ({"name": "String", "new_name": "String"}, {"value": "Natural"})
- # Check inheritance as well
- assert read_defined_attrs("users/user/test/a", "D") == ({"name": "String", "additional_attr": "Natural", "new_name": "String"}, {"value": "Natural"})
- # optional -> optional
- attribute_optional("users/user/test/a", "A", "value", True)
- assert read_defined_attrs("users/user/test/a", "A") == ({"name": "String", "new_name": "String"}, {"value": "Natural"})
- # Check inheritance as well
- assert read_defined_attrs("users/user/test/a", "D") == ({"name": "String", "additional_attr": "Natural", "new_name": "String"}, {"value": "Natural"})
- # Non-existing model
- try:
- attribute_optional("users/afa", "A", "value", False)
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- before = element_list("users/user/test/a")
- try:
- attribute_optional("users/user/test/a", "AA", "value", False)
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # No read permissions
- try:
- attribute_optional("administration/core", "formalisms", "name", True)
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions, but can still query
- before = element_list("formalisms/SimpleClassDiagrams")
- try:
- attribute_optional("formalisms/SimpleClassDiagrams", "Class", "name", True)
- self.fail()
- except WritePermissionDenied:
- assert element_list("formalisms/SimpleClassDiagrams") == before
- # None defined in non-SCD model
- model_add("users/user/test/b", "users/user/test/a", "A a {}")
- try:
- attribute_optional("users/user/test/b", "a", "b", False)
- self.fail()
- except UnknownM3:
- pass
-
- # Attribute not defined here
- try:
- attribute_optional("users/user/test/a", "D", "value", False)
- self.fail()
- except SuperclassAttribute:
- assert read_defined_attrs("users/user/test/a", "D") == ({"name": "String", "additional_attr": "Natural", "new_name": "String"}, {"value": "Natural"})
- # Non-existing attribute
- try:
- attribute_optional("users/user/test/a", "D", "adf", True)
- self.fail()
- except UnknownAttribute:
- assert read_defined_attrs("users/user/test/a", "D") == ({"name": "String", "additional_attr": "Natural", "new_name": "String"}, {"value": "Natural"})
- def test_op_attribute_type(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- SimpleAttribute Natural {}
- Class A {
- name = "ABC"
- value : Natural
- new_name ?: String
- name : String
- }
- Association B (A, A) {
- name = "DEF"
- edge_value : Natural
- name : String
- other_value ?: String
- }
- Class C {}
- Class D : A {
- additional_attr : Natural
- }
- Association E : B (D, A) {
- next_attr : String
- }
- """)
- # Check initial situation
- assert read_defined_attrs("users/user/test/a", "A") == ({"value": "Natural", "name": "String"}, {"new_name": "String"})
- assert read_defined_attrs("users/user/test/a", "B") == ({"edge_value": "Natural", "name": "String"}, {"other_value": "String"})
- assert read_defined_attrs("users/user/test/a", "C") == ({}, {})
- assert read_defined_attrs("users/user/test/a", "D") == ({"value": "Natural", "name": "String", "additional_attr": "Natural"}, {"new_name": "String"})
- assert read_defined_attrs("users/user/test/a", "E") == ({"edge_value": "Natural", "name": "String", "next_attr": "String"}, {"other_value": "String"})
- # Change type of node
- attribute_type("users/user/test/a", "A", "value", "String")
- assert read_defined_attrs("users/user/test/a", "A") == ({"value": "String", "name": "String"}, {"new_name": "String"})
- # Check inheritance as well
- assert read_defined_attrs("users/user/test/a", "D") == ({"value": "String", "name": "String", "additional_attr": "Natural"}, {"new_name": "String"})
- # Change type of edge
- attribute_type("users/user/test/a", "B", "name", "Natural")
- assert read_defined_attrs("users/user/test/a", "B") == ({"edge_value": "Natural", "name": "Natural"}, {"other_value": "String"})
- # Check inheritance as well
- assert read_defined_attrs("users/user/test/a", "E") == ({"edge_value": "Natural", "name": "Natural", "next_attr": "String"}, {"other_value": "String"})
- # Non-existing model
- try:
- attribute_type("users/afa", "A", "value", "String")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- before = element_list("users/user/test/a")
- try:
- attribute_type("users/user/test/a", "AA", "value", "String")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # Non-existing type
- before = element_list("users/user/test/a")
- try:
- attribute_type("users/user/test/a", "A", "value", "SSS")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # No read permissions
- try:
- attribute_type("administration/core", "formalisms", "name", "Natural")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions
- before = element_list("formalisms/SimpleClassDiagrams")
- try:
- attribute_type("formalisms/SimpleClassDiagrams", "Class", "name", "Natural")
- self.fail()
- except WritePermissionDenied:
- assert element_list("formalisms/SimpleClassDiagrams") == before
- # None defined in non-SCD model
- model_add("users/user/test/b", "users/user/test/a", "A a {}")
- try:
- attribute_type("users/user/test/b", "a", "b", "a")
- self.fail()
- except UnknownM3:
- pass
- # Attribute not defined here
- try:
- attribute_type("users/user/test/a", "D", "value", "Natural")
- self.fail()
- except SuperclassAttribute:
- assert read_defined_attrs("users/user/test/a", "D") == ({"value": "String", "name": "String", "additional_attr": "Natural"}, {"new_name": "String"})
- # Non-existing attribute
- try:
- attribute_type("users/user/test/a", "D", "adf", "Natural")
- self.fail()
- except UnknownAttribute:
- assert read_defined_attrs("users/user/test/a", "D") == ({"value": "String", "name": "String", "additional_attr": "Natural"}, {"new_name": "String"})
- def test_op_attribute_name(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- SimpleAttribute Natural {}
- Class A {
- name = "ABC"
- value : Natural
- new_name ?: String
- name : String
- }
- Association B (A, A) {
- name = "DEF"
- edge_value : Natural
- name : String
- other_value ?: String
- }
- Class C {}
- Class D : A {
- additional_attr : Natural
- }
- Association E : B (D, A) {
- next_attr : String
- }
- """)
- # Check initial situation
- assert read_defined_attrs("users/user/test/a", "A") == ({"value": "Natural", "name": "String"}, {"new_name": "String"})
- assert read_defined_attrs("users/user/test/a", "B") == ({"edge_value": "Natural", "name": "String"}, {"other_value": "String"})
- assert read_defined_attrs("users/user/test/a", "C") == ({}, {})
- assert read_defined_attrs("users/user/test/a", "D") == ({"value": "Natural", "name": "String", "additional_attr": "Natural"}, {"new_name": "String"})
- assert read_defined_attrs("users/user/test/a", "E") == ({"edge_value": "Natural", "name": "String", "next_attr": "String"}, {"other_value": "String"})
- # Change name of node
- attribute_name("users/user/test/a", "A", "value", "new_value")
- assert read_defined_attrs("users/user/test/a", "A") == ({"new_value": "Natural", "name": "String"}, {"new_name": "String"})
- # Check inheritance as well
- assert read_defined_attrs("users/user/test/a", "D") == ({"new_value": "Natural", "name": "String", "additional_attr": "Natural"}, {"new_name": "String"})
- # Change name of edge
- attribute_name("users/user/test/a", "B", "name", "other_name")
- assert read_defined_attrs("users/user/test/a", "B") == ({"edge_value": "Natural", "other_name": "String"}, {"other_value": "String"})
- # Check inheritance as well
- assert read_defined_attrs("users/user/test/a", "E") == ({"edge_value": "Natural", "other_name": "String", "next_attr": "String"}, {"other_value": "String"})
- # Attribute not defined here
- try:
- attribute_name("users/user/test/a", "D", "new_value", "newer_value")
- self.fail()
- except SuperclassAttribute:
- pass
- # Non-existing model
- try:
- attribute_name("users/afa", "A", "value", "str")
- self.fail()
- except UnknownModel:
- pass
- # Non-existing element
- before = element_list("users/user/test/a")
- try:
- attribute_name("users/user/test/a", "AA", "value", "val2")
- self.fail()
- except UnknownElement:
- assert element_list("users/user/test/a") == before
- # Pre-existing name
- before = element_list("users/user/test/a")
- try:
- attribute_name("users/user/test/a", "A", "new_value", "name")
- self.fail()
- except AttributeExists:
- assert element_list("users/user/test/a") == before
- # No read permissions
- try:
- attribute_name("administration/core", "formalisms", "name", "natural")
- self.fail()
- except ReadPermissionDenied:
- pass
- # No write permissions, but can still query
- before = element_list("formalisms/SimpleClassDiagrams")
- try:
- attribute_name("formalisms/SimpleClassDiagrams", "Class", "name", "value")
- self.fail()
- except WritePermissionDenied:
- assert element_list("formalisms/SimpleClassDiagrams") == before
- # None defined in non-SCD model
- model_add("users/user/test/b", "users/user/test/a", "A a {}")
- try:
- attribute_name("users/user/test/b", "a", "b", "c")
- self.fail()
- except UnknownM3:
- pass
- def test_op_group_create(self):
- # Test normal operation
- group_name_1 = "new_group"
- group_name_2 = "group2"
- group_name_3 = "other_group"
- group_name_4 = "second_group"
- assert group_list() == set([])
- group_create(group_name_1)
- assert group_list() == set([(group_name_1, True)])
- # Test second group
- assert group_list() == set([(group_name_1, True)])
- group_create(group_name_2)
- assert group_list() == set([(group_name_1, True), (group_name_2, True)])
- # Test other groups
- self.do_as_user("user2", group_create, [group_name_3])
- self.do_as_user("user2", group_create, [group_name_4])
- assert group_list() == set([(group_name_1, True), (group_name_2, True)])
- # Test non-admin groups
- self.do_as_user("user2", group_join, [group_name_3, "user"])
- assert group_list() == set([(group_name_1, True), (group_name_2, True), (group_name_3, False)])
- # Test create of existing group (member)
- before = group_list()
- try:
- group_create(group_name_1)
- self.fail()
- except GroupExists:
- assert group_list() == before
- # Test create of existing group (non-member)
- before = group_list()
- try:
- group_create(group_name_4)
- self.fail()
- except GroupExists:
- assert group_list() == before
- # Delete all groups again
- self.do_as_user("admin", group_delete, [group_name_1])
- self.do_as_user("admin", group_delete, [group_name_2])
- self.do_as_user("admin", group_delete, [group_name_3])
- self.do_as_user("admin", group_delete, [group_name_4])
- def test_op_group_delete(self):
- group_name_1 = "new_group" # Group with admin permissions
- group_name_2 = "group2" # Group without permissions
- group_name_3 = "other_group" # No member
- group_name_4 = "second_group" # Non-existing group
- # Ensure user2 exists
- self.do_as_user("user2", lambda : 1, [])
- # Create some groups first
- group_create(group_name_1)
- self.do_as_user("admin", group_create, [group_name_2])
- self.do_as_user("admin", group_join, [group_name_2, "user"])
- self.do_as_user("admin", group_create, [group_name_3])
- # Try to delete all
- assert group_list() == set([(group_name_1, True), (group_name_2, False)])
- group_delete(group_name_1)
- assert group_list() == set([(group_name_2, False)])
- # Remove group that we don't own
- try:
- group_delete(group_name_2)
- self.fail()
- except GroupPermissionDenied:
- assert group_list() == set([(group_name_2, False)])
- # Remove group that we are not even member of
- try:
- group_delete(group_name_3)
- self.fail()
- except GroupPermissionDenied:
- assert group_list() == set([(group_name_2, False)])
- # Remove non-existing group
- try:
- group_delete(group_name_4)
- except UnknownGroup:
- assert group_list() == set([(group_name_2, False)])
- # Test if other users can no longer see removed groups
- group_create(group_name_1)
- group_join(group_name_1, "user2")
- assert self.do_as_user("user2", group_list, []) == set([(group_name_1, False)])
- group_delete(group_name_1)
- assert self.do_as_user("user2", group_list, []) == set([])
- # Delete all groups again
- self.do_as_user("admin", group_delete, [group_name_2])
- self.do_as_user("admin", group_delete, [group_name_3])
- def test_op_group_list(self):
- group_name_1 = "new_group" # Group with admin permissions
- group_name_2 = "group2" # Group without permissions
- group_name_3 = "other_group" # No member
- group_name_4 = "second_group" # Non-existing group
- # Ensure user2 exists
- self.do_as_user("user2", lambda : 1, [])
- # Create some groups first
- group_create(group_name_1)
- self.do_as_user("admin", group_create, [group_name_2])
- self.do_as_user("admin", group_join, [group_name_2, "user"])
- self.do_as_user("admin", group_create, [group_name_3])
- # Assure that groups of all users are correct
- assert group_list() == set([(group_name_1, True), (group_name_2, False)])
- assert self.do_as_user("user2", group_list, []) == set([])
- assert self.do_as_user("admin", group_list, []) == set([("admin", False), (group_name_2, True), (group_name_3, True)])
- # Delete a group to check that everything is correctly listed afterwards
- self.do_as_user("admin", group_delete, [group_name_2])
- assert group_list() == set([(group_name_1, True)])
- assert self.do_as_user("user2", group_list, []) == set([])
- assert self.do_as_user("admin", group_list, []) == set([("admin", False), (group_name_3, True)])
- # Delete all groups again
- self.do_as_user("admin", group_delete, [group_name_1])
- self.do_as_user("admin", group_delete, [group_name_3])
- def do_as_user(self, username, operation, args):
- user_logout()
- login(username, username)
- try:
- result = operation(*args)
- except:
- user_logout()
- login("user", "user")
- raise
- else:
- user_logout()
- login("user", "user")
- return result
- def test_op_group_join(self):
- group_name_1 = "new_group" # Group with admin permissions
- group_name_2 = "group2" # Group without permissions
- group_name_3 = "other_group" # No member
- group_name_4 = "second_group" # Non-existing group
- # Ensure user2 exists
- self.do_as_user("user2", lambda : 1, [])
- # Create some groups first
- group_create(group_name_1)
- self.do_as_user("admin", group_create, [group_name_2])
- self.do_as_user("admin", group_join, [group_name_2, "user"])
- self.do_as_user("admin", group_create, [group_name_3])
- # Test for group join basic use, of group where we are admin
- assert group_join(group_name_1, "user2") == None
- assert self.do_as_user("user2", group_list, []) == set([(group_name_1, False)])
- # Test for group join of group where we are no admin
- try:
- group_join(group_name_2, "user2") == None
- self.fail()
- except GroupPermissionDenied:
- assert self.do_as_user("user2", group_list, []) == set([(group_name_1, False)])
- # Test for group join of group where we are not even a member
- try:
- group_join(group_name_3, "user2") == None
- self.fail()
- except GroupPermissionDenied:
- assert self.do_as_user("user2", group_list, []) == set([(group_name_1, False)])
- # Test for group join of group that already has user as member
- assert self.do_as_user("user2", group_list, []) == set([(group_name_1, False)])
- try:
- group_join(group_name_1, "user2") == None
- self.fail()
- except UserExists:
- assert self.do_as_user("user2", group_list, []) == set([(group_name_1, False)])
- # Test for group join of non-existing user
- try:
- group_join(group_name_1, "user123") == None
- self.fail()
- except UnknownUser:
- pass
- # Test for group join of non-existing group
- try:
- group_join(group_name_4, "user2") == None
- self.fail()
- except UnknownGroup:
- pass
- # Delete all groups again
- self.do_as_user("admin", group_delete, [group_name_1])
- self.do_as_user("admin", group_delete, [group_name_2])
- self.do_as_user("admin", group_delete, [group_name_3])
- def test_op_group_kick(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- group_name_1 = "new_group" # Group with admin permissions
- group_name_2 = "group2" # Group without permissions
- group_name_3 = "other_group" # No member
- group_name_4 = "second_group" # Non-existing group
- # Ensure user2 exists
- self.do_as_user("user2", lambda : 1, [])
- # Create some groups first
- group_create(group_name_1)
- self.do_as_user("admin", group_create, [group_name_2])
- self.do_as_user("admin", group_join, [group_name_2, "user"])
- # Kick user from group
- assert group_list() == set([(group_name_1, True), (group_name_2, False)])
- self.do_as_user("admin", group_kick, [group_name_2, "user"])
- assert group_list() == set([(group_name_1, True)])
- # Kick self (owner) from group
- assert group_list() == set([(group_name_1, True)])
- group_create(group_name_3)
- assert group_list() == set([(group_name_1, True), (group_name_3, True)])
- assert group_kick(group_name_3, "user") == None
- assert group_list() == set([(group_name_1, True)])
- # Empty groups are not deleted
- self.do_as_user("admin", group_join, [group_name_3, "user"])
- # Kick user not in group
- try:
- self.do_as_user("admin", group_kick, [group_name_2, "user2"])
- self.fail()
- except UserNotInGroup:
- pass
- # Non-existing user
- try:
- group_kick(group_name_1, "adfafd")
- self.fail()
- except UnknownUser:
- pass
- # Non-existing group
- try:
- group_kick("adfadf", "user")
- self.fail()
- except UnknownGroup:
- pass
- # Not admin of group
- self.do_as_user("admin", group_join, [group_name_2, "user"])
- self.do_as_user("admin", group_join, [group_name_2, "user2"])
- assert group_list() == set([(group_name_1, True), (group_name_2, False), (group_name_3, False)])
- assert self.do_as_user("user2", group_list, []) == set([(group_name_2, False)])
- try:
- group_kick(group_name_2, "user2")
- self.fail()
- except GroupPermissionDenied:
- assert self.do_as_user("user2", group_list, []) == set([(group_name_2, False)])
- self.do_as_user("admin", group_delete, [group_name_1])
- self.do_as_user("admin", group_delete, [group_name_2])
- self.do_as_user("admin", group_delete, [group_name_3])
- def do_create_user(self, name):
- self.do_as_user(name, lambda : 1, [])
- def do_test_permission(self, model, expected_permissions):
- for user, permission in expected_permissions.items():
- assert self.do_as_user(user, read_permissions, [model]) == permission
- def test_op_permission_owner_model(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- group_create("users")
- permission_group("users/user/test/a", "users")
- permission_modify("users/user/test/a", "210")
- self.do_create_user("group_user")
- self.do_create_user("other_user")
- group_join("users", "group_user")
- # Test initial situation, where we have owners user:users with permission 210
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "R", "other_user": ""})
- # Change owner, but permissions stay the same
- permission_owner("users/user/test/a", "group_user")
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "R", "group_user": "RW", "other_user": ""})
- # Can no longer modify permissions: only owner can do that
- try:
- permission_owner("users/user/test/a", "admin")
- self.fail()
- except UserPermissionDenied:
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "R", "group_user": "RW", "other_user": ""})
- # Change owner to admin, who always has RW permissions
- self.do_as_user("group_user", permission_owner, ["users/user/test/a", "admin"])
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "R", "group_user": "R", "other_user": ""})
- # Give permissions back to someone else, and test that admin can always do operations, even if not owner
- self.do_as_user("admin", permission_owner, ["users/user/test/a", "group_user"])
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "R", "group_user": "RW", "other_user": ""})
- self.do_as_user("admin", permission_owner, ["users/user/test/a", "user"])
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "R", "other_user": ""})
- # Test non-existing model
- try:
- permission_owner("adfadf", "admin")
- self.fail()
- except UnknownModel:
- pass
- # Test non-existing user
- try:
- self.do_as_user("admin", permission_owner, ["users/user/test/a", "dfadf"])
- self.fail()
- except UnknownUser:
- pass
- # Test assign to user who is already owner
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "R", "other_user": ""})
- self.do_as_user("admin", permission_owner, ["users/user/test/a", "user"])
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "R", "other_user": ""})
- group_delete("users")
- def test_op_permission_owner_folder(self):
- folder_create("users/user/test/a/b/c")
- group_create("users")
- self.do_create_user("group_user")
- group_join("users", "group_user")
- permission_group("users/user/test/a/b", "users")
- permission_modify("users/user/test/a/b", "210")
- # Test permissions
- self.do_test_permission("users/user/test/", {"admin": "RW", "user": "RW", "group_user": "", "other_user": ""})
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "", "other_user": ""})
- self.do_test_permission("users/user/test/a/b", {"admin": "RW", "user": "RW", "group_user": "R", "other_user": ""})
- self.do_test_permission("users/user/test/a/b/c", {"admin": "RW", "user": "RW", "group_user": "", "other_user": ""})
- # But test if they are really applicable
- try:
- self.do_as_user("group_user", model_list, ["users/user/test"])
- self.fail()
- except ReadPermissionDenied:
- pass
- try:
- self.do_as_user("group_user", model_list, ["users/user/test/a"])
- self.fail()
- except ReadPermissionDenied:
- pass
- self.do_as_user("group_user", model_list, ["users/user/test/a/b"])
- try:
- self.do_as_user("group_user", model_list, ["users/user/test/a/b/c"])
- self.fail()
- except ReadPermissionDenied:
- pass
- group_delete("users")
- def test_op_read_permissions_model(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- group_create("users")
- self.do_create_user("group_user")
- self.do_create_user("other_user")
- group_join("users", "group_user")
- permission_group("users/user/test/a", "users")
- permission_modify("users/user/test/a", "210")
- # Test all four cases
- assert self.do_as_user("user", read_permissions, ["users/user/test/a"]) == "RW"
- assert self.do_as_user("group_user", read_permissions, ["users/user/test/a"]) == "R"
- assert self.do_as_user("other_user", read_permissions, ["users/user/test/a"]) == ""
- assert self.do_as_user("admin", read_permissions, ["users/user/test/a"]) == "RW"
- # Test same for root location (empty string)
- assert self.do_as_user("user", read_permissions, [""]) == "R"
- assert self.do_as_user("group_user", read_permissions, [""]) == "R"
- assert self.do_as_user("other_user", read_permissions, [""]) == "R"
- assert self.do_as_user("admin", read_permissions, [""]) == "RW"
- # Test for non-existing location
- try:
- read_permissions("adfadsf")
- self.fail()
- except UnknownLocation:
- pass
- group_delete("users")
- def test_op_read_permissions_folder(self):
- folder_create("users/user/test/a")
- group_create("users")
- self.do_create_user("group_user")
- self.do_create_user("other_user")
- group_join("users", "group_user")
- permission_group("users/user/test/a", "users")
- permission_modify("users/user/test/a", "210")
- # Test all four cases
- assert self.do_as_user("user", read_permissions, ["users/user/test/a"]) == "RW"
- assert self.do_as_user("group_user", read_permissions, ["users/user/test/a"]) == "R"
- assert self.do_as_user("other_user", read_permissions, ["users/user/test/a"]) == ""
- assert self.do_as_user("admin", read_permissions, ["users/user/test/a"]) == "RW"
- # Test for non-existing location
- try:
- read_permissions("adfadsf")
- self.fail()
- except UnknownLocation:
- pass
- group_delete("users")
- def test_op_permission_group_model(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams")
- group_create("users")
- group_create("other_group")
- permission_modify("users/user/test/a", "210")
- self.do_create_user("group_user")
- self.do_create_user("other_user")
- group_join("users", "group_user")
- # Test initial situation, where we have owners user:users with permission 210
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "", "other_user": ""})
- # Change owner, but permissions stay the same
- permission_group("users/user/test/a", "users")
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "R", "other_user": ""})
- # Only owner can modify group permissions
- try:
- self.do_as_user("group_user", permission_group, ["users/user/test/a", "other_group"])
- self.fail()
- except UserPermissionDenied:
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "R", "other_user": ""})
- # Test that admin can always do operations, even if not owner
- # And test that user permissions still override group permissions
- self.do_as_user("admin", permission_group, ["users/user/test/a", "admin"])
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "", "other_user": ""})
- self.do_as_user("admin", permission_group, ["users/user/test/a", "other_group"])
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "", "other_user": ""})
- self.do_as_user("admin", permission_group, ["users/user/test/a", "users"])
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "R", "other_user": ""})
- # Test non-existing model
- try:
- permission_group("adfadf", "admin")
- self.fail()
- except UnknownModel:
- pass
- # Test non-existing group
- try:
- self.do_as_user("admin", permission_group, ["users/user/test/a", "dfadf"])
- self.fail()
- except UnknownGroup:
- pass
- # Test assign to group which is already owning group, resulting in no change
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "R", "other_user": ""})
- self.do_as_user("admin", permission_group, ["users/user/test/a", "users"])
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "R", "other_user": ""})
- self.do_as_user("admin", group_delete, ["other_group"])
- self.do_as_user("admin", group_delete, ["users"])
- def test_op_permission_group_folder(self):
- folder_create("users/user/test/a/b/c")
- group_create("users")
- self.do_create_user("group_user")
- group_join("users", "group_user")
- permission_group("users/user/test/a/b", "users")
- permission_modify("users/user/test/a/b", "210")
- # Test permissions
- self.do_test_permission("users/user/test/", {"admin": "RW", "user": "RW", "group_user": "", "other_user": ""})
- self.do_test_permission("users/user/test/a", {"admin": "RW", "user": "RW", "group_user": "", "other_user": ""})
- self.do_test_permission("users/user/test/a/b", {"admin": "RW", "user": "RW", "group_user": "R", "other_user": ""})
- self.do_test_permission("users/user/test/a/b/c", {"admin": "RW", "user": "RW", "group_user": "", "other_user": ""})
- # But test if they are really applicable
- try:
- self.do_as_user("group_user", model_list, ["users/user/test"])
- self.fail()
- except ReadPermissionDenied:
- pass
- try:
- self.do_as_user("group_user", model_list, ["users/user/test/a"])
- self.fail()
- except ReadPermissionDenied:
- pass
- self.do_as_user("group_user", model_list, ["users/user/test/a/b"])
- try:
- self.do_as_user("group_user", model_list, ["users/user/test/a/b/c"])
- self.fail()
- except ReadPermissionDenied:
- pass
- group_delete("users")
- def test_op_group_owner_add(self):
- group_create("group1")
- group_create("group2")
- group_create("group3")
- self.do_create_user("new_user")
- group_join("group1", "new_user")
- # Basic use of group owner: promote a user
- assert self.do_as_user("new_user", group_list, []) == set([("group1", False)])
- assert group_owner_add("group1", "new_user") == None
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True)])
- # Or instantaneously make owner, thereby also making a member
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True)])
- assert group_owner_add("group2", "new_user") == None
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", True)])
- # Test for user that is already an owner
- assert group_owner_add("group1", "new_user") == None
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", True)])
- # Test non-existing user
- try:
- group_owner_add("group1", "abc")
- self.fail()
- except UnknownUser:
- pass
- # Test non-existing group
- try:
- group_owner_add("group4", "new_user")
- self.fail()
- except UnknownGroup:
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", True)])
- # Only an owner of the group can do this
- group_owner_delete("group2", "new_user")
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", False)])
- try:
- self.do_as_user("new_user", group_owner_add, ["group2", "user"])
- self.fail()
- except GroupPermissionDenied:
- pass
- # Also non-members can't modify
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", False)])
- try:
- self.do_as_user("new_user", group_owner_add, ["group3", "user"])
- self.fail()
- except GroupPermissionDenied:
- pass
- # Delete all groups again
- group_delete("group1")
- group_delete("group2")
- group_delete("group3")
- def test_op_group_owner_delete(self):
- group_create("group1")
- group_create("group2")
- group_create("group3")
- self.do_create_user("new_user")
- group_owner_add("group1", "new_user")
- group_owner_add("group2", "new_user")
- # Basic use: remove owner, but stay a member
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", True)])
- assert group_owner_delete("group2", "new_user") == None
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", False)])
- # Test for user that is already not an owner
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", False)])
- assert group_owner_delete("group2", "new_user") == None
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", False)])
- # Test for user that is not even a member
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", False)])
- try:
- group_owner_delete("group3", "new_user")
- self.fail()
- except UserNotInGroup:
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", False)])
- # Test non-existing user
- try:
- group_owner_delete("group1", "abc")
- self.fail()
- except UnknownUser:
- pass
- # Test non-existing group
- try:
- group_owner_delete("group4", "new_user")
- self.fail()
- except UnknownGroup:
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", False)])
- # Only an owner of the group can do this
- group_owner_delete("group2", "new_user")
- assert group_list() == set([("group1", True), ("group2", True), ("group3", True)])
- try:
- self.do_as_user("new_user", group_owner_delete, ["group2", "user"])
- self.fail()
- except GroupPermissionDenied:
- assert group_list() == set([("group1", True), ("group2", True), ("group3", True)])
- # Also non-members can't modify
- assert self.do_as_user("new_user", group_list, []) == set([("group1", True), ("group2", False)])
- try:
- self.do_as_user("new_user", group_owner_delete, ["group3", "user"])
- self.fail()
- except GroupPermissionDenied:
- pass
- # Delete all groups again
- group_delete("group1")
- group_delete("group2")
- group_delete("group3")
- def test_op_conformance_add(self):
- # Add some conformance relations
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- Class A {}
- Class B {}
- Association C (A, B) {}
- """)
- # Add conformance bottom relation
- t = model_types("users/user/test/a")
- assert len(t) == 1
- t = t.pop()
- print(t)
- assert t[0] == "formalisms/SimpleClassDiagrams"
- assert t[1] != None
- assert t[2] == None
- # Check if the type is added, but without any type mapping associated to it
- conformance_add("users/user/test/a", "formalisms/Bottom")
- ts = model_types("users/user/test/a")
- assert len(ts) == 2
- while ts:
- t = ts.pop()
- assert t[0] in ["formalisms/SimpleClassDiagrams", "formalisms/Bottom"]
- if t[0] == "formalisms/SimpleClassDiagrams":
- assert t[1] != None
- elif t[1] == "formalisms/Bottom":
- # Type mapping is empty
- assert t[1] == None
- assert t[2] == None
- # Check if a type mapping is created when model is opened as bottom
- alter_context("users/user/test/a", "formalisms/Bottom")
- element_list("users/user/test/a")
- alter_context("users/user/test/a", "formalisms/SimpleClassDiagrams")
- ts = model_types("users/user/test/a")
- assert len(ts) == 2
- while ts:
- t = ts.pop()
- assert t[0] in ["formalisms/SimpleClassDiagrams", "formalisms/Bottom"]
- assert t[1] != None
- assert t[2] == None
- # Check if we can add a second one to the same MM
- conformance_add("users/user/test/a", "formalisms/Bottom")
- ts = model_types("users/user/test/a")
- assert len(ts) == 3
- assert ("formalisms/Bottom", None, None) in ts
- found = False
- while ts:
- t = ts.pop()
- assert t[0] in ["formalisms/SimpleClassDiagrams", "formalisms/Bottom"]
- if t[0] == "formalisms/SimpleClassDiagrams":
- assert t[1] != None
- elif t[0] == "formalisms/Bottom":
- # Type mapping is empty
- if t[1] != None:
- found = True
- assert t[2] == None
- assert found
- # Check add of non-existing model
- try:
- conformance_add("users/user/test/b", "formalisms/Bottom")
- self.fail()
- except UnknownModel:
- pass
- # Check add of non-existing metamodel
- model_add("users/user/test/b", "formalisms/SimpleClassDiagrams")
- before = model_types("users/user/test/b")
- try:
- conformance_add("users/user/test/b", "formalisms/Bottom2")
- self.fail()
- except UnknownModel:
- assert model_types("users/user/test/b") == before
- # Check conformance_add for a folder model
- try:
- conformance_add("users/user/test", "formalisms/Bottom")
- self.fail()
- except NotAModel:
- pass
- # Check conformance_add for a folder metamodel
- try:
- conformance_add("users/user/test/a", "formalisms")
- self.fail()
- except NotAModel:
- pass
- def test_op_conformance_delete(self):
- model_add("users/user/test/a", "formalisms/SimpleClassDiagrams", """
- Class A {}
- Class B {}
- Association C (A, B) {}
- """)
- # Add conformance bottom relation
- conformance_add("users/user/test/a", "formalisms/Bottom")
- # Verify initial state
- ts = model_types("users/user/test/a")
- assert len(ts) == 2
- while ts:
- t = ts.pop()
- assert t[0] in ["formalisms/SimpleClassDiagrams", "formalisms/Bottom"]
- if t[0] == "formalisms/SimpleClassDiagrams":
- assert t[1] != None
- elif t[1] == "formalisms/Bottom":
- # Type mapping is empty
- assert t[1] == None
- assert t[2] == None
- # Now remove it again
- conformance_delete("users/user/test/a", "formalisms/Bottom", "")
- ts = model_types("users/user/test/a")
- assert len(ts) == 1
- t = ts.pop()
- assert t[0] == "formalisms/SimpleClassDiagrams"
- assert t[1] != None
- assert t[2] == None
- # Add conformance bottom relation twice
- conformance_add("users/user/test/a", "formalisms/Bottom")
- conformance_add("users/user/test/a", "formalisms/Bottom")
- # Should be there twice, but set flattens it to once
- ts = model_types("users/user/test/a")
- assert len(ts) == 2
- while ts:
- t = ts.pop()
- assert t[0] in ["formalisms/SimpleClassDiagrams", "formalisms/Bottom"]
- if t[0] == "formalisms/SimpleClassDiagrams":
- assert t[1] != None
- elif t[1] == "formalisms/Bottom":
- # Type mapping is empty
- assert t[1] == None
- assert t[2] == None
- # Now remove it (once called, but invoked for all occurences!)
- conformance_delete("users/user/test/a", "formalisms/Bottom", "")
- ts = model_types("users/user/test/a")
- assert len(ts) == 1
- t = ts.pop()
- assert t[0] == "formalisms/SimpleClassDiagrams"
- assert t[1] != None
- assert t[2] == None
- # Now actually test filtering capabilities
- alter_context("users/user/test/a", "formalisms/Bottom")
- element_list("users/user/test/a")
- alter_context("users/user/test/a", "formalisms/SimpleClassDiagrams")
- # Model should be there with a type mapping model
- ts = model_types("users/user/test/a")
- assert len(ts) == 2
- while ts:
- t = ts.pop()
- assert t[0] in ["formalisms/SimpleClassDiagrams", "formalisms/Bottom"]
- assert t[1] != None
- assert t[2] == None
- # Add a second bottom relation
- conformance_add("users/user/test/a", "formalisms/Bottom")
- # And remove the one without model, to make sure that it is not a wildcard!
- conformance_delete("users/user/test/a", "formalisms/Bottom", "")
- ts = model_types("users/user/test/a")
- assert len(ts) == 2
- while ts:
- t = ts.pop()
- assert t[0] in ["formalisms/SimpleClassDiagrams", "formalisms/Bottom"]
- assert t[1] != None
- assert t[2] == None
- # Add again, but now remove the one with type mapping
- conformance_add("users/user/test/a", "formalisms/Bottom")
-
- # First try one that doesn't match...
- conformance_delete("users/user/test/a", "formalisms/Bottom", "NOTHING")
- ts = model_types("users/user/test/a")
- assert len(ts) == 3
- while ts:
- t = ts.pop()
- assert t[0] in ["formalisms/SimpleClassDiagrams", "formalisms/Bottom"]
- assert t[2] == None
- # Now try one with the actual name
- actual_name = [i for i in model_types("users/user/test/a") if i[0] == "formalisms/Bottom" and i[1] != None][0][1]
- assert len(model_types("users/user/test/a")) == 3
- conformance_delete("users/user/test/a", "formalisms/SimpleClassDiagrams", actual_name)
- # Nothing removed, because of wrong TM model
- assert len(model_types("users/user/test/a")) == 3
- # Now remove correct one
- conformance_delete("users/user/test/a", "formalisms/Bottom", actual_name)
- ts = model_types("users/user/test/a")
- assert len(ts) == 2
- while ts:
- t = ts.pop()
- assert t[0] in ["formalisms/SimpleClassDiagrams", "formalisms/Bottom"]
- if t[0] == "formalisms/SimpleClassDiagrams":
- assert t[1] != None
- elif t[1] == "formalisms/Bottom":
- # Type mapping is empty
- assert t[1] == None
- assert t[2] == None
- # Check non-existing model
- try:
- conformance_delete("users/user/test/b", "formalisms/Bottom", "")
- self.fail()
- except UnknownModel:
- pass
- # Check add of non-existing metamodel
- model_add("users/user/test/b", "formalisms/SimpleClassDiagrams")
- before = model_types("users/user/test/b")
- try:
- conformance_delete("users/user/test/b", "formalisms/Bottom2", "")
- self.fail()
- except UnknownModel:
- assert model_types("users/user/test/b") == before
- # Check folder as model
- try:
- conformance_delete("users/user/test", "formalisms/Bottom", "")
- self.fail()
- except NotAModel:
- pass
- # Check folder as metamodel
- try:
- conformance_delete("users/user/test/a", "formalisms", "")
- self.fail()
- except NotAModel:
- pass
- def test_op_transformation_between_MANUAL(self):
- # Add set of transformations
- def create_transf(name, inputs, outputs):
- transformation_add_MANUAL({"key_%s" % i: "users/user/test/" + i for i in inputs}, {"key_%s" % i: "users/user/test/" + i for i in outputs}, "users/user/test/" + name)
- model_add("users/user/test/A", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/B", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/C", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/D", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/E", "formalisms/SimpleClassDiagrams")
- create_transf("1", ["A"], ["B"])
- create_transf("2", ["A"], ["C", "D"])
- create_transf("3", ["B", "C"], ["D"])
- create_transf("4", ["A", "B"], ["D", "E"])
- # Test normal operation
- def check_transformations(inputs, outputs, expected):
- assert transformation_between({"key_" + i: "users/user/test/" + i for i in inputs}, {"key_" + i: "users/user/test/" + i for i in outputs}) == set(["users/user/test/" + i for i in expected])
- # Obvious ones, with a perfect signature match
- check_transformations(["A"], ["B"], ["1"])
- check_transformations(["A"], ["C", "D"], ["2"])
- check_transformations(["B", "C"], ["D"], ["3"])
- check_transformations(["A", "B"], ["D", "E"], ["4"])
- # Incomplete matches
- check_transformations(["A"], [], ["1", "2", "4"])
- check_transformations(["B"], [], ["3", "4"])
- check_transformations(["C"], [], ["3"])
- check_transformations(["D"], [], [])
- check_transformations(["E"], [], [])
- check_transformations([], ["A"], [])
- check_transformations([], ["B"], ["1"])
- check_transformations([], ["C"], ["2"])
- check_transformations([], ["D"], ["2", "3", "4"])
- check_transformations([], ["E"], ["4"])
- # Complete match, which doesn't return as it would give all transformations in the Modelverse...
- try:
- check_transformations([], [], [])
- self.fail()
- except IncorrectFormat:
- pass
- # Non-existing model (source)
- try:
- assert transformation_between({"key_A": "users/user/test/Z"}, {"key_B": "users/user/test/B"}) == set([])
- self.fail()
- except UnknownModel:
- pass
- # Key mismatch (source)
- assert transformation_between({"key_B": "users/user/test/A"}, {"key_B": "users/user/test/B"}) == set([])
- # Model mismatch (source)
- assert transformation_between({"key_A": "users/user/test/B"}, {"key_B": "users/user/test/B"}) == set([])
- # Non-existing model (target)
- try:
- assert transformation_between({"key_A": "users/user/test/A"}, {"key_B": "users/user/test/Z"}) == set([])
- self.fail()
- except UnknownModel:
- pass
- # Key mismatch (target)
- assert transformation_between({"key_A": "users/user/test/A"}, {"key_A": "users/user/test/B"}) == set([])
- # Model mismatch (target)
- assert transformation_between({"key_A": "users/user/test/A"}, {"key_B": "users/user/test/A"}) == set([])
- def test_op_transformation_between_AL(self):
- # Add set of transformations
- def create_transf(name, inputs, outputs):
- transformation_add_AL({"key_%s" % i: "users/user/test/" + i for i in inputs}, {"key_%s" % i: "users/user/test/" + i for i in outputs}, "users/user/test/" + name, "Void function main():\n\treturn!")
- model_add("users/user/test/A", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/B", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/C", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/D", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/E", "formalisms/SimpleClassDiagrams")
- create_transf("1", ["A"], ["B"])
- create_transf("2", ["A"], ["C", "D"])
- create_transf("3", ["B", "C"], ["D"])
- create_transf("4", ["A", "B"], ["D", "E"])
- # Test normal operation
- def check_transformations(inputs, outputs, expected):
- assert transformation_between({"key_" + i: "users/user/test/" + i for i in inputs}, {"key_" + i: "users/user/test/" + i for i in outputs}) == set(["users/user/test/" + i for i in expected])
- # Obvious ones, with a perfect signature match
- check_transformations(["A"], ["B"], ["1"])
- check_transformations(["A"], ["C", "D"], ["2"])
- check_transformations(["B", "C"], ["D"], ["3"])
- check_transformations(["A", "B"], ["D", "E"], ["4"])
- # Incomplete matches
- check_transformations(["A"], [], ["1", "2", "4"])
- check_transformations(["B"], [], ["3", "4"])
- check_transformations(["C"], [], ["3"])
- check_transformations(["D"], [], [])
- check_transformations(["E"], [], [])
- check_transformations([], ["A"], [])
- check_transformations([], ["B"], ["1"])
- check_transformations([], ["C"], ["2"])
- check_transformations([], ["D"], ["2", "3", "4"])
- check_transformations([], ["E"], ["4"])
- # Complete match, which doesn't return as it would give all transformations in the Modelverse...
- try:
- check_transformations([], [], [])
- self.fail()
- except IncorrectFormat:
- pass
- # Non-existing model (source)
- try:
- assert transformation_between({"key_A": "users/user/test/Z"}, {"key_B": "users/user/test/B"}) == set([])
- self.fail()
- except UnknownModel:
- pass
- # Key mismatch (source)
- assert transformation_between({"key_B": "users/user/test/A"}, {"key_B": "users/user/test/B"}) == set([])
- # Model mismatch (source)
- assert transformation_between({"key_A": "users/user/test/B"}, {"key_B": "users/user/test/B"}) == set([])
- # Non-existing model (target)
- try:
- assert transformation_between({"key_A": "users/user/test/A"}, {"key_B": "users/user/test/Z"}) == set([])
- self.fail()
- except UnknownModel:
- pass
- # Key mismatch (target)
- assert transformation_between({"key_A": "users/user/test/A"}, {"key_A": "users/user/test/B"}) == set([])
- # Model mismatch (target)
- assert transformation_between({"key_A": "users/user/test/A"}, {"key_B": "users/user/test/A"}) == set([])
- def test_op_transformation_between_MT(self):
- # Add set of transformations
- def create_transf(name, inputs, outputs):
- transformation_add_MT({"key_%s" % i: "users/user/test/" + i for i in inputs}, {"key_%s" % i: "users/user/test/" + i for i in outputs}, "users/user/test/" + name, "Composite a{}")
- model_add("users/user/test/A", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/B", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/C", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/D", "formalisms/SimpleClassDiagrams")
- model_add("users/user/test/E", "formalisms/SimpleClassDiagrams")
- create_transf("1", ["A"], ["B"])
- create_transf("2", ["A"], ["C", "D"])
- create_transf("3", ["B", "C"], ["D"])
- create_transf("4", ["A", "B"], ["D", "E"])
- # Test normal operation
- def check_transformations(inputs, outputs, expected):
- assert transformation_between({"key_" + i: "users/user/test/" + i for i in inputs}, {"key_" + i: "users/user/test/" + i for i in outputs}) == set(["users/user/test/" + i for i in expected])
- # Obvious ones, with a perfect signature match
- check_transformations(["A"], ["B"], ["1"])
- check_transformations(["A"], ["C", "D"], ["2"])
- check_transformations(["B", "C"], ["D"], ["3"])
- check_transformations(["A", "B"], ["D", "E"], ["4"])
- # Incomplete matches
- check_transformations(["A"], [], ["1", "2", "4"])
- check_transformations(["B"], [], ["3", "4"])
- check_transformations(["C"], [], ["3"])
- check_transformations(["D"], [], [])
- check_transformations(["E"], [], [])
- check_transformations([], ["A"], [])
- check_transformations([], ["B"], ["1"])
- check_transformations([], ["C"], ["2"])
- check_transformations([], ["D"], ["2", "3", "4"])
- check_transformations([], ["E"], ["4"])
- # Complete match, which doesn't return as it would give all transformations in the Modelverse...
- try:
- check_transformations([], [], [])
- self.fail()
- except IncorrectFormat:
- pass
- # Non-existing model (source)
- try:
- assert transformation_between({"key_A": "users/user/test/Z"}, {"key_B": "users/user/test/B"}) == set([])
- self.fail()
- except UnknownModel:
- pass
- # Key mismatch (source)
- assert transformation_between({"key_B": "users/user/test/A"}, {"key_B": "users/user/test/B"}) == set([])
- # Model mismatch (source)
- assert transformation_between({"key_A": "users/user/test/B"}, {"key_B": "users/user/test/B"}) == set([])
- # Non-existing model (target)
- try:
- assert transformation_between({"key_A": "users/user/test/A"}, {"key_B": "users/user/test/Z"}) == set([])
- self.fail()
- except UnknownModel:
- pass
- # Key mismatch (target)
- assert transformation_between({"key_A": "users/user/test/A"}, {"key_A": "users/user/test/B"}) == set([])
- # Model mismatch (target)
- assert transformation_between({"key_A": "users/user/test/A"}, {"key_B": "users/user/test/A"}) == set([])
- def test_op_transformation_add_MANUAL(self):
- # Add models for transformation
- model_add("users/user/test/A", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class A {
- name = "A"
- name : String
- }
- """)
- model_add("users/user/test/B", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class B {
- name = "B"
- name : String
- }
- """)
- model_add("users/user/test/a", "users/user/test/A", "A {}")
- model_add("users/user/test/b", "users/user/test/B", "B {}")
- # Add a transformation with normal signature
- transformation_add_MANUAL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/c")
- # Add a transformation with normal signature and merged metamodel changes
- def operation(model):
- # Check if both are present
- lst = element_list_nice(model)
- assert len(lst) == 6
- assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- # Do minor merge operation
- instantiate(model, "Association", edge=("MODEL_A/A", "MODEL_B/B"), ID="trace")
- # Check again
- lst = element_list_nice(model)
- assert len(lst) == 7
- assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "trace", "__type": "Association", "__source": "MODEL_A/A", "__target": "MODEL_B/B", "name": None, "source_lower_cardinality": None, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}, "lower_cardinality": None, "upper_cardinality": None} in lst
- transformation_add_MANUAL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/d", operation)
-
- def operation(model):
- # Check if both are present
- lst = element_list_nice(model)
- assert len(lst) == 6
- assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- transformation_add_MANUAL({"MODEL_A": "users/user/test/A", "MODEL_B": "users/user/test/B"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/e", operation)
- try:
- transformation_add_MANUAL({"MODEL_A": "users/user/test/A", "MODEL_B": "users/user/test/B"}, {"MODEL_B": "users/user/test/A"}, "users/user/test/f")
- self.fail()
- except DifferingModelsForKey:
- pass
- # Add a transformation with empty signature
- transformation_add_MANUAL({}, {}, "users/user/test/g")
- # Add a transformation with empty signature and a callback
- try:
- def operation(model):
- pass
- transformation_add_MANUAL({}, {}, "users/user/test/h", operation)
- self.fail()
- except CallbackOnEmptySignature:
- assert "h" not in model_list("users/user/test")
- # Add transformation with unknown metamodel in signature (input)
- try:
- transformation_add_MANUAL({"MODEL_A": "adbdsf"}, {"MODEL_B": "users/user/test/A"}, "users/user/test/i")
- self.fail()
- except UnknownModel:
- assert "i" not in model_list("users/user/test")
- # Add transformation with unknown metamodel in signature (output)
- try:
- transformation_add_MANUAL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "adfad"}, "users/user/test/j")
- self.fail()
- except UnknownModel:
- assert "j" not in model_list("users/user/test")
- # Add transformation with unreadable metamodel in signature (input)
- try:
- transformation_add_MANUAL({"MODEL_A": "administration/core"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/k")
- self.fail()
- except ReadPermissionDenied:
- assert "k" not in model_list("users/user/test")
- # Add transformation with unreadable metamodel in signature (output)
- try:
- transformation_add_MANUAL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "administration/core"}, "users/user/test/l")
- self.fail()
- except ReadPermissionDenied:
- assert "l" not in model_list("users/user/test")
- # Try to use a non-RAMifiable metamodel in input
- try:
- transformation_add_MANUAL({"MODEL_A": "users/user/test/a"}, {}, "users/user/test/m")
- self.fail()
- except UnknownM3:
- assert "m" not in model_list("users/user/test")
- # Try to use a non-RAMifiable metamodel in output
- try:
- transformation_add_MANUAL({}, {"MODEL_A": "users/user/test/a"}, "users/user/test/n")
- self.fail()
- except UnknownM3:
- assert "n" not in model_list("users/user/test")
- # Try to create activity that already exists
- sig = transformation_signature("users/user/test/c")
- try:
- transformation_add_MANUAL({}, {}, "users/user/test/c")
- except ModelExists:
- assert sig == transformation_signature("users/user/test/c")
- def test_op_transformation_add_AL(self):
- # Add models for transformation
- model_add("users/user/test/A", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class A {
- name = "A"
- name : String
- }
- """)
- model_add("users/user/test/B", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class B {
- name = "B"
- name : String
- }
- """)
- model_add("users/user/test/a", "users/user/test/A", "A {}")
- model_add("users/user/test/b", "users/user/test/B", "B {}")
- default_function = "Boolean function main(model : Element):\n\treturn True!"
- # Add a transformation with normal signature
- transformation_add_AL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/c", default_function)
- # Add a transformation with normal signature and merged metamodel changes
- def operation(model):
- # Check if both are present
- lst = element_list_nice(model)
- assert len(lst) == 6
- assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- # Do minor merge operation
- instantiate(model, "Association", edge=("MODEL_A/A", "MODEL_B/B"), ID="trace")
- # Check again
- lst = element_list_nice(model)
- assert len(lst) == 7
- assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "trace", "__type": "Association", "__source": "MODEL_A/A", "__target": "MODEL_B/B", "name": None, "source_lower_cardinality": None, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}, "lower_cardinality": None, "upper_cardinality": None} in lst
- transformation_add_AL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/d", default_function, operation)
-
- def operation(model):
- # Check if both are present
- lst = element_list_nice(model)
- assert len(lst) == 6
- assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- transformation_add_AL({"MODEL_A": "users/user/test/A", "MODEL_B": "users/user/test/B"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/e", default_function, operation)
- try:
- transformation_add_AL({"MODEL_A": "users/user/test/A", "MODEL_B": "users/user/test/B"}, {"MODEL_B": "users/user/test/A"}, "users/user/test/f", default_function)
- self.fail()
- except DifferingModelsForKey:
- pass
- # Add a transformation with empty signature
- transformation_add_AL({}, {}, "users/user/test/g", default_function)
- # Add a transformation with empty signature and a callback
- try:
- def operation(model):
- pass
- transformation_add_AL({}, {}, "users/user/test/h", default_function, operation)
- self.fail()
- except CallbackOnEmptySignature:
- assert "h" not in model_list("users/user/test")
- # Add transformation with unknown metamodel in signature (input)
- try:
- transformation_add_AL({"MODEL_A": "adbdsf"}, {"MODEL_B": "users/user/test/A"}, "users/user/test/i", default_function)
- self.fail()
- except UnknownModel:
- assert "i" not in model_list("users/user/test")
- # Add transformation with unknown metamodel in signature (output)
- try:
- transformation_add_AL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "adfad"}, "users/user/test/j", default_function)
- self.fail()
- except UnknownModel:
- assert "j" not in model_list("users/user/test")
- # Add transformation with unreadable metamodel in signature (input)
- try:
- transformation_add_AL({"MODEL_A": "administration/core"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/k", default_function)
- self.fail()
- except ReadPermissionDenied:
- assert "k" not in model_list("users/user/test")
- # Add transformation with unreadable metamodel in signature (output)
- try:
- transformation_add_AL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "administration/core"}, "users/user/test/l", default_function)
- self.fail()
- except ReadPermissionDenied:
- assert "l" not in model_list("users/user/test")
- # Try to use a non-RAMifiable metamodel in input
- try:
- transformation_add_AL({"MODEL_A": "users/user/test/a"}, {}, "users/user/test/m", default_function)
- self.fail()
- except UnknownM3:
- assert "m" not in model_list("users/user/test")
- # Try to use a non-RAMifiable metamodel in output
- try:
- transformation_add_AL({}, {"MODEL_A": "users/user/test/a"}, "users/user/test/n", default_function)
- self.fail()
- except UnknownM3:
- assert "n" not in model_list("users/user/test")
- # Try to create activity that already exists
- sig = transformation_signature("users/user/test/c")
- try:
- transformation_add_AL({}, {}, "users/user/test/c", default_function)
- except ModelExists:
- assert sig == transformation_signature("users/user/test/c")
- def test_op_transformation_add_MT(self):
- # Add models for transformation
- model_add("users/user/test/A", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class A {
- name = "A"
- name : String
- }
- """)
- model_add("users/user/test/B", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class B {
- name = "B"
- name : String
- }
- """)
- model_add("users/user/test/a", "users/user/test/A", "A {}")
- model_add("users/user/test/b", "users/user/test/B", "B {}")
- default_function = "Composite c{}"
- # Add a transformation with normal signature
- transformation_add_MT({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/c", default_function)
- # Add a transformation with normal signature and merged metamodel changes
- def operation(model):
- # Check if both are present
- lst = element_list_nice(model)
- assert len(lst) == 6
- assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- # Do minor merge operation
- instantiate(model, "Association", edge=("MODEL_A/A", "MODEL_B/B"), ID="trace")
- # Check again
- lst = element_list_nice(model)
- assert len(lst) == 7
- assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "trace", "__type": "Association", "__source": "MODEL_A/A", "__target": "MODEL_B/B", "name": None, "source_lower_cardinality": None, "source_upper_cardinality": None, "target_lower_cardinality": None, "target_upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}, "lower_cardinality": None, "upper_cardinality": None} in lst
- transformation_add_MT({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/d", default_function, operation)
-
- def operation(model):
- # Check if both are present
- lst = element_list_nice(model)
- assert len(lst) == 6
- assert {"__id": "MODEL_A/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A", "__type": "Class", "name": "A", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_A/A_name", "__type": "AttributeLink", "__source": "MODEL_A/A", "__target": "MODEL_A/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/String", "__type": "SimpleAttribute", "name": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B", "__type": "Class", "name": "B", "lower_cardinality": None, "upper_cardinality": None, "abstract": None, "constraint": {"AL": ""}} in lst
- assert {"__id": "MODEL_B/B_name", "__type": "AttributeLink", "__source": "MODEL_B/B", "__target": "MODEL_B/String", "name": "name", "optional": False, "constraint": {"AL": ""}} in lst
- transformation_add_MT({"MODEL_A": "users/user/test/A", "MODEL_B": "users/user/test/B"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/e", default_function, operation)
- try:
- transformation_add_MT({"MODEL_A": "users/user/test/A", "MODEL_B": "users/user/test/B"}, {"MODEL_B": "users/user/test/A"}, "users/user/test/f", default_function)
- self.fail()
- except DifferingModelsForKey:
- pass
- # Add a transformation with empty signature
- try:
- transformation_add_MT({}, {}, "users/user/test/g", default_function)
- self.fail()
- except EmptySignature:
- assert "g" not in model_list("users/user/test")
- # Add a transformation with empty signature and a callback
- try:
- def operation(model):
- pass
- transformation_add_MT({}, {}, "users/user/test/h", default_function, operation)
- self.fail()
- except CallbackOnEmptySignature:
- assert "h" not in model_list("users/user/test")
- # Add transformation with unknown metamodel in signature (input)
- try:
- transformation_add_MT({"MODEL_A": "adbdsf"}, {"MODEL_B": "users/user/test/A"}, "users/user/test/i", default_function)
- self.fail()
- except UnknownModel:
- assert "i" not in model_list("users/user/test")
- # Add transformation with unknown metamodel in signature (output)
- try:
- transformation_add_MT({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "adfad"}, "users/user/test/j", default_function)
- self.fail()
- except UnknownModel:
- assert "j" not in model_list("users/user/test")
- # Add transformation with unreadable metamodel in signature (input)
- try:
- transformation_add_MT({"MODEL_A": "administration/core"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/k", default_function)
- self.fail()
- except ReadPermissionDenied:
- assert "k" not in model_list("users/user/test")
- # Add transformation with unreadable metamodel in signature (output)
- try:
- transformation_add_MT({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "administration/core"}, "users/user/test/l", default_function)
- self.fail()
- except ReadPermissionDenied:
- assert "l" not in model_list("users/user/test")
- # Try to use a non-RAMifiable metamodel in input
- try:
- transformation_add_MT({"MODEL_A": "users/user/test/a"}, {}, "users/user/test/m", default_function)
- self.fail()
- except UnknownM3:
- assert "m" not in model_list("users/user/test")
- # Try to use a non-RAMifiable metamodel in output
- try:
- transformation_add_MT({}, {"MODEL_A": "users/user/test/a"}, "users/user/test/n", default_function)
- self.fail()
- except UnknownM3:
- assert "n" not in model_list("users/user/test")
- # Try to create activity that already exists
- sig = transformation_signature("users/user/test/c")
- try:
- transformation_add_MT({"MODEL_A": "users/user/test/A"}, {}, "users/user/test/c", default_function)
- self.fail()
- except ModelExists:
- assert sig == transformation_signature("users/user/test/c")
- # Compilation error
- try:
- transformation_add_MT({"MODEL_A": "users/user/test/A"}, {}, "users/user/test/o", "adfa")
- self.fail()
- except CompilationError:
- pass
- def test_op_transformation_execute_MANUAL(self):
- # Add models for transformation
- model_add("users/user/test/A", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class A {
- name = "A"
- name : String
- }
- """)
- model_add("users/user/test/B", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class B {
- name = "B"
- name : String
- }
- """)
- model_add("users/user/test/a", "users/user/test/A", "A {}")
- model_add("users/user/test/b", "users/user/test/B", "B {}")
- # Add some activity to execute
- transformation_add_MANUAL({}, {}, "users/user/test/c")
- def operation(model):
- assert model is None
- # Now execute
- transformation_execute_MANUAL("users/user/test/c", {}, {}, operation)
- # Now do the same, but with a model
- transformation_add_MANUAL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/d")
- def operation(model):
- assert model is not None
- assert [{"__id": "MODEL_A/__0", "__type": "MODEL_A/A", "name": None}] == element_list_nice(model)
- instantiate(model, "MODEL_B/B")
- transformation_execute_MANUAL("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/aa"}, operation)
- lst = element_list_nice("users/user/test/aa")
- assert len(lst) == 1
- assert lst[0]["__type"] == "B"
- assert lst[0]["name"] == None
- assert lst[0]["__id"].startswith("__")
- # Execute activity with non-existing model (input)
- try:
- transformation_execute_MANUAL("users/user/test/d", {"MODEL_A": "dfadf"}, {"MODEL_B": "users/user/test/f"}, lambda i: i)
- self.fail()
- except UnknownModel:
- assert "f" not in model_list("users/user/test")
- # Execute non-existing activity
- try:
- transformation_execute_MANUAL("adfadf", {}, {"MODEL_B": "users/user/test/abc"}, lambda i: i)
- self.fail()
- except UnknownModel:
- assert "abc" not in model_list("users/user/test")
- # Unbound source model
- try:
- transformation_execute_MANUAL("users/user/test/d", {}, {"MODEL_B": "users/user/test/f"}, lambda i: i)
- self.fail()
- except SourceModelNotBound:
- pass
- # Unknown source key
- try:
- transformation_execute_MANUAL("users/user/test/d", {"ABC": "users/user/test/a", "MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/f"}, lambda i: i)
- self.fail()
- except SourceModelNotBound:
- pass
- # Unknown target key
- try:
- transformation_execute_MANUAL("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"DEF": "users/user/test/b"}, lambda i: i)
- self.fail()
- except TargetModelNotBound:
- pass
- # Read permissions denied source
- try:
- transformation_execute_MANUAL("users/user/test/d", {"MODEL_A": "administration/core"}, {"MODEL_B": "users/user/test/f"}, lambda i: i)
- self.fail()
- except ReadPermissionDenied:
- pass
- # Execute permissions denied activity
- try:
- transformation_execute_MANUAL("administration/core", {"MODEL_A": "administration/core"}, {"MODEL_B": "users/user/test/f"}, lambda i: i)
- self.fail()
- except ExecutePermissionDenied:
- pass
- # Write permissions denied target (folder)
- try:
- transformation_execute_MANUAL("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "administration/abc"}, lambda i: i)
- self.fail()
- except WritePermissionDenied:
- pass
- # Write permissions denied target (model)
- try:
- transformation_execute_MANUAL("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "administration/core"}, lambda i: i)
- self.fail()
- except WritePermissionDenied:
- pass
- # Execute activity with non-conforming input models
- try:
- transformation_execute_MANUAL("users/user/test/d", {"MODEL_A": "users/user/test/b"}, {"MODEL_B": "users/user/test/f"}, lambda i: i)
- self.fail()
- except TypeMismatch:
- assert "f" not in model_list("users/user/test")
- # Execute activity with non-conforming output models that already exist
- try:
- transformation_execute_MANUAL("users/user/test/d", {"MODEL_A": "users/user/test/b"}, {"MODEL_B": "users/user/test/c"}, lambda i: i)
- self.fail()
- except TypeMismatch:
- assert element_list_nice("users/user/test/c") > 0
- # Execute activity with colliding models, which means that it is copied
- transformation_add_MANUAL({"MODEL_A": "users/user/test/A"}, {"MODEL_A": "users/user/test/A"}, "users/user/test/f")
- transformation_execute_MANUAL("users/user/test/f", {"MODEL_A": "users/user/test/a"}, {"MODEL_A": "users/user/test/aaa"}, lambda i: i)
- assert len(element_list_nice("users/user/test/a")) == len(element_list_nice("users/user/test/aaa"))
- def test_op_transformation_execute_AL(self):
- # Add models for transformation
- model_add("users/user/test/A", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class A {
- name = "A"
- name : String
- }
- """)
- model_add("users/user/test/B", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class B {
- name = "B"
- name : String
- }
- """)
- model_add("users/user/test/a", "users/user/test/A", "A a {}")
- model_add("users/user/test/b", "users/user/test/B", "B b {}")
- default_code_empty = "Boolean function main(model : Element):\n\treturn True!"
- default_code_true = "include \"modelling.alh\"\nBoolean function main(model : Element):\n\tinstantiate_attribute(model, \"MODEL_A/a\", \"name\", \"CHANGED\")\n\tinstantiate_node(model, \"MODEL_B/B\", \"\")\n\treturn True!"
- default_code_false = "include \"modelling.alh\"\nBoolean function main(model : Element):\n\tinstantiate_attribute(model, \"MODEL_A/a\", \"name\", \"CHANGED\")\n\tinstantiate_node(model, \"MODEL_B/B\", \"\")\n\treturn False!"
- # Add some activity to execute
- transformation_add_AL({}, {}, "users/user/test/c", default_code_true)
- # Now execute
- transformation_execute_AL("users/user/test/c", {}, {})
- # Now do the same, but with a model
- transformation_add_AL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/d", default_code_true)
- transformation_execute_AL("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/aa"})
- lst = element_list_nice("users/user/test/aa")
- assert len(lst) == 1
- assert lst[0]["__type"] == "B"
- assert lst[0]["name"] == None
- assert lst[0]["__id"].startswith("__")
- # Original input model remains unchanged, as it is not an output model
- lst = element_list_nice("users/user/test/a")
- assert len(lst) == 1
- assert lst[0]["__type"] == "A"
- assert lst[0]["name"] == None
- assert lst[0]["__id"] == "a"
- # Execute activity with non-existing model (input)
- try:
- transformation_execute_AL("users/user/test/d", {"MODEL_A": "dfadf"}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except UnknownModel:
- assert "f" not in model_list("users/user/test")
- # Execute non-existing activity
- try:
- transformation_execute_AL("adfadf", {}, {"MODEL_B": "users/user/test/abc"})
- self.fail()
- except UnknownModel:
- assert "abc" not in model_list("users/user/test")
- # Unbound source model
- try:
- transformation_execute_AL("users/user/test/d", {}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except SourceModelNotBound:
- pass
- # Unknown source key
- try:
- transformation_execute_AL("users/user/test/d", {"ABC": "users/user/test/a", "MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except SourceModelNotBound:
- pass
- # Unknown target key
- try:
- transformation_execute_AL("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"DEF": "users/user/test/b"})
- self.fail()
- except TargetModelNotBound:
- pass
- # Read permissions denied source
- try:
- transformation_execute_AL("users/user/test/d", {"MODEL_A": "administration/core"}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except ReadPermissionDenied:
- pass
- # Execute permissions denied activity
- try:
- transformation_execute_AL("administration/core", {"MODEL_A": "administration/core"}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except ExecutePermissionDenied:
- pass
- # Write permissions denied target (folder)
- try:
- transformation_execute_AL("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "administration/abc"})
- self.fail()
- except WritePermissionDenied:
- pass
- # Write permissions denied target (model)
- try:
- transformation_execute_AL("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "administration/core"})
- self.fail()
- except WritePermissionDenied:
- pass
- # Execute activity with non-conforming input models
- try:
- transformation_execute_AL("users/user/test/d", {"MODEL_A": "users/user/test/b"}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except TypeMismatch:
- assert "f" not in model_list("users/user/test")
- # Execute activity with non-conforming output models that already exist
- try:
- transformation_execute_AL("users/user/test/d", {"MODEL_A": "users/user/test/b"}, {"MODEL_B": "users/user/test/c"})
- self.fail()
- except TypeMismatch:
- assert element_list_nice("users/user/test/c") > 0
- # Execute activity with colliding models, which means that it is copied
- transformation_add_AL({"MODEL_A": "users/user/test/A"}, {"MODEL_A": "users/user/test/A"}, "users/user/test/f", default_code_empty)
- transformation_execute_AL("users/user/test/f", {"MODEL_A": "users/user/test/a"}, {"MODEL_A": "users/user/test/aaa"})
- assert len(element_list_nice("users/user/test/a")) == len(element_list_nice("users/user/test/aaa"))
- # Make sure that models are not written when returning False
- transformation_add_AL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/h", default_code_false)
- transformation_execute_AL("users/user/test/h", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/bb"})
- assert "bb" not in model_list("users/user/test")
- # Try out SC communication: requires back and forth computation
- code_SC = """
- include "io.alh"
- include "primitives.alh"
- Boolean function main(model : Element):
- output("init")
- log("Init OK")
- output(cast_integer(input()) + cast_integer(input()))
- log("Sent out value")
- return True!
- """
- import exec_AL
- ctrl = exec_AL.Controller(keep_running=False)
- thrd = threading.Thread(target=ctrl.start)
- thrd.daemon = True
- transformation_add_AL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/i", code_SC)
- thrd.start()
- transformation_execute_AL("users/user/test/i", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/bb"}, statechart=(ctrl, "inp", "outp"))
- thrd.join()
- def test_op_transformation_execute_MT(self):
- # Add models for transformation
- model_add("users/user/test/A", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class A {
- name = "A"
- name : String
- }
- """)
- model_add("users/user/test/B", "formalisms/SimpleClassDiagrams", """
- SimpleAttribute String {}
- Class B {
- name = "B"
- name : String
- }
- """)
- model_add("users/user/test/a", "users/user/test/A", "A a {}")
- model_add("users/user/test/b", "users/user/test/B", "B b {}")
- default_code_empty = """
- Composite a {
- {Contains} Success success {}
- }
- Initial (a, success) {}
- """
- default_code_true = """
- Composite a {
- {Contains} Success success {}
- {Contains} Atomic b {
- LHS {
- Pre_MODEL_A/A {
- label = "0"
- }
- }
- RHS {
- Post_MODEL_A/A {
- label = "0"
- value_name = $
- String function value(model : Element, name : String, mapping : Element):
- return "CHANGED"!
- $
- }
- Post_MODEL_B/B {
- label = "1"
- }
- }
- }
- }
- Initial (a, b) {}
- OnSuccess (b, success) {}
- OnFailure (b, success) {}
- """
- default_code_false = """
- Composite a {
- {Contains} Failure failure {}
- {Contains} Atomic b {
- LHS {
- Pre_MODEL_A/A {
- label = "0"
- }
- }
- RHS {
- Post_MODEL_A/A {
- label = "0"
- value_name = $
- String function value(model : Element, name : String, mapping : Element):
- return "CHANGED"!
- $
- }
- Post_MODEL_B/B {
- label = "1"
- }
- }
- }
- }
- Initial (a, b) {}
- OnSuccess (b, failure) {}
- OnFailure (b, failure) {}
- """
- # Add some activity to execute
- try:
- transformation_add_MT({}, {}, "users/user/test/c", default_code_true)
- self.fail()
- except EmptySignature:
- assert "c" not in model_list("users/user/test")
- # Now do the same, but with a model
- transformation_add_MT({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/d", default_code_true)
- transformation_execute_MT("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/aa"})
- lst = element_list_nice("users/user/test/aa")
- assert len(lst) == 1
- assert lst[0]["__type"] == "B"
- assert lst[0]["name"] == None
- assert lst[0]["__id"].startswith("__")
- # Original input model remains unchanged, as it is not an output model
- lst = element_list_nice("users/user/test/a")
- assert len(lst) == 1
- assert lst[0]["__type"] == "A"
- assert lst[0]["name"] == None
- assert lst[0]["__id"] == "a"
- # Execute activity with non-existing model (input)
- try:
- transformation_execute_MT("users/user/test/d", {"MODEL_A": "dfadf"}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except UnknownModel:
- assert "f" not in model_list("users/user/test")
- # Execute non-existing activity
- try:
- transformation_execute_MT("adfadf", {}, {"MODEL_B": "users/user/test/abc"})
- self.fail()
- except UnknownModel:
- assert "abc" not in model_list("users/user/test")
- # Unbound source model
- try:
- transformation_execute_MT("users/user/test/d", {}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except SourceModelNotBound:
- pass
- # Unknown source key
- try:
- transformation_execute_MT("users/user/test/d", {"ABC": "users/user/test/a", "MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except SourceModelNotBound:
- pass
- # Unknown target key
- try:
- transformation_execute_MT("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"DEF": "users/user/test/b"})
- self.fail()
- except TargetModelNotBound:
- pass
- # Read permissions denied source
- try:
- transformation_execute_MT("users/user/test/d", {"MODEL_A": "administration/core"}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except ReadPermissionDenied:
- pass
- # Execute permissions denied activity
- try:
- transformation_execute_MT("administration/core", {"MODEL_A": "administration/core"}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except ExecutePermissionDenied:
- pass
- # Write permissions denied target (folder)
- try:
- transformation_execute_MT("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "administration/abc"})
- self.fail()
- except WritePermissionDenied:
- pass
- # Write permissions denied target (model)
- try:
- transformation_execute_MT("users/user/test/d", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "administration/core"})
- self.fail()
- except WritePermissionDenied:
- pass
- # Execute activity with non-conforming input models
- try:
- transformation_execute_MT("users/user/test/d", {"MODEL_A": "users/user/test/b"}, {"MODEL_B": "users/user/test/f"})
- self.fail()
- except TypeMismatch:
- assert "f" not in model_list("users/user/test")
- # Execute activity with non-conforming output models that already exist
- try:
- transformation_execute_MT("users/user/test/d", {"MODEL_A": "users/user/test/b"}, {"MODEL_B": "users/user/test/d"})
- self.fail()
- except TypeMismatch:
- assert element_list_nice("users/user/test/d") > 0
- # Execute activity with colliding models, which means that it is copied
- transformation_add_MT({"MODEL_A": "users/user/test/A"}, {"MODEL_A": "users/user/test/A"}, "users/user/test/f", default_code_empty)
- transformation_execute_MT("users/user/test/f", {"MODEL_A": "users/user/test/a"}, {"MODEL_A": "users/user/test/aaa"})
- assert len(element_list_nice("users/user/test/a")) == len(element_list_nice("users/user/test/aaa"))
- # Make sure that models are not written when returning False
- transformation_add_MT({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/h", default_code_false)
- transformation_execute_MT("users/user/test/h", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/bb"})
- assert "bb" not in model_list("users/user/test")
- # Try out SC communication: requires back and forth computation
- code_SC = """
- include "primitives.alh"
- include "io.alh"
- Composite a {
- {Contains} Success success {}
- {Contains} Atomic b {
- LHS {}
- RHS {
- action = $
- Void function act(model : Element, mapping : Element):
- output("init")
- log("Init OK")
- output(cast_integer(input()) + cast_integer(input()))
- log("Sent out value")
- return!
- $
- }
- }
- }
- Initial (a, b) {}
- OnSuccess (b, success) {}
- OnFailure (b, success) {}
- """
- import exec_MT
- ctrl = exec_MT.Controller(keep_running=False)
- thrd = threading.Thread(target=ctrl.start)
- thrd.daemon = True
- transformation_add_MT({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/i", code_SC)
- thrd.start()
- transformation_execute_MT("users/user/test/i", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/bb"}, statechart=(ctrl, "inp", "outp"))
- thrd.join()
- """
- def test_op_model_render(self):
- def test_op_transformation_execute_MT(self):
- def test_op_transformation_signature(self):
- def test_op_process_signature(self):
- """
- def test_modelling(self):
- # Add a model
- model_add("users/user/test/Empty", "formalisms/SimpleClassDiagrams")
- # Check that it exists
- compare_locations("users/user/test", set(["Empty"]))
- # Check that it conforms
- assert verify("users/user/test/Empty", "formalisms/SimpleClassDiagrams") == "OK"
- # Check for permissions
- assert model_list_full("users/user/test") == set([(name, "user", "nobody", "221") for name in get_model_list("users/user/test")]) | \
- set([("Empty", "user", "nobody", "200")])
- # Instantiate it further
- model_add("users/user/test/my_empty", "users/user/test/Empty")
- assert verify("users/user/test/my_empty", "users/user/test/Empty") == "OK"
- # Check that it exists
- compare_locations("users/user/test", set(["my_empty", "Empty"]))
- # Check that an instantiate of "A" fails
- try:
- res = instantiate("users/user/test/my_empty", "A")
- assert False
- except UnknownIdentifier:
- assert verify("users/user/test/Empty", "formalisms/SimpleClassDiagrams") == "OK"
- # Create something in the formalism
- instantiate("users/user/test/Empty", "Class", ID="A")
- attr_assign("users/user/test/Empty", "A", "name", "A")
- assert verify("users/user/test/Empty", "formalisms/SimpleClassDiagrams") == "OK"
- # Now instantiate that in the model as well, which now works
- instantiate("users/user/test/my_empty", "A")
- assert verify("users/user/test/my_empty", "users/user/test/Empty") == "OK"
- def test_overwrite(self):
- model_add("users/user/test/Empty", "formalisms/SimpleClassDiagrams")
- assert element_list("users/user/test/Empty") == set([])
- instantiate("users/user/test/Empty", "Class", ID="A")
- assert element_list("users/user/test/Empty") == set([("A", "Class")])
- model_overwrite("users/user/test/Empty", "")
- assert element_list("users/user/test/Empty") == set([])
- compare_locations("users/user/test", set(["Empty"]))
-
- assert element_list("users/user/test/Empty") == set([])
- instantiate("users/user/test/Empty", "Class", ID="B")
- compare_locations("users/user/test", set(["Empty"]))
- def test_operations(self):
- log = []
- def manual_callback(model):
- p1 = instantiate(model, "PetriNet_Runtime/Place")
- p2 = instantiate(model, "PetriNet_Runtime/Place")
- p3 = instantiate(model, "PetriNet_Runtime/Place")
- t1 = instantiate(model, "PetriNet_Runtime/Transition")
- p2t1 = instantiate(model, "PetriNet_Runtime/P2T", (p1, t1))
- p2t2 = instantiate(model, "PetriNet_Runtime/P2T", (p2, t1))
- t2p1 = instantiate(model, "PetriNet_Runtime/T2P", (t1, p3))
- attr_assign(model, p1, "tokens", 1)
- attr_assign(model, p1, "name", "p1")
- attr_assign(model, p2, "tokens", 2)
- attr_assign(model, p2, "name", "p2")
- attr_assign(model, p3, "tokens", 3)
- attr_assign(model, p3, "name", "p3")
- attr_assign(model, t1, "name", "t1")
- attr_assign(model, t1, "executing", False)
- attr_assign(model, p2t1, "weight", 1)
- attr_assign(model, p2t2, "weight", 1)
- attr_assign(model, t2p1, "weight", 2)
- model_add("users/user/test/PetriNet", "formalisms/SimpleClassDiagrams", open("integration/code/pn_design.mvc", "r").read())
- model_add("users/user/test/PetriNet_Runtime", "formalisms/SimpleClassDiagrams", open("integration/code/pn_runtime.mvc", "r").read())
- model_add("users/user/test/my_pn", "users/user/test/PetriNet", open("integration/code/pn_design_model.mvc", "r").read())
- def add_tracability_D2R(model):
- instantiate(model, "Association", ("PetriNet/Place", "PetriNet_Runtime/Place"), ID="D2R_PlaceLink")
- instantiate(model, "Association", ("PetriNet/Transition", "PetriNet_Runtime/Transition"), ID="D2R_TransitionLink")
- def add_tracability_R2D(model):
- instantiate(model, "Association", ("PetriNet_Runtime/Place", "PetriNet/Place"), ID="R2D_PlaceLink")
- instantiate(model, "Association", ("PetriNet_Runtime/Transition", "PetriNet/Transition"), ID="R2D_TransitionLink")
- transformation_add_MT({"PetriNet": "users/user/test/PetriNet"}, {}, "users/user/test/print_pn", open("integration/code/pn_print.mvc").read())
- transformation_add_MANUAL({"PetriNet": "users/user/test/PetriNet"}, {"PetriNet_Runtime": "users/user/test/PetriNet_Runtime"}, "users/user/test/pn_design_to_runtime", add_tracability_D2R)
- transformation_add_AL({"PetriNet_Runtime": "users/user/test/PetriNet_Runtime"}, {"PetriNet_Runtime": "users/user/test/PetriNet_Runtime"}, "users/user/test/pn_simulate", open("integration/code/pn_simulate.alc").read())
- transformation_add_MT({"PetriNet_Runtime": "users/user/test/PetriNet_Runtime"}, {"PetriNet": "users/user/test/PetriNet"}, "users/user/test/pn_runtime_to_design", open("integration/code/pn_runtime_to_design.mvc").read(), add_tracability_R2D)
- log = []
- ctrl = log_output.Controller(log, keep_running=False)
- thrd = threading.Thread(target=ctrl.start)
- thrd.daemon = True
- thrd.start()
- assert transformation_execute_MT("users/user/test/print_pn", {"PetriNet": "users/user/test/my_pn"}, {}, (ctrl, "inp", "outp")) == True
- thrd.join()
- assert set(log) == set(['"p1" --> 1',
- '"p2" --> 2',
- '"p3" --> 3'])
- assert transformation_execute_MANUAL("users/user/test/pn_design_to_runtime", {"PetriNet": "users/user/test/my_pn"}, {"PetriNet_Runtime": "users/user/test/my_pn_RT"}, manual_callback) == True
- assert transformation_execute_AL("users/user/test/pn_simulate", {"PetriNet_Runtime": "users/user/test/my_pn_RT"}, {"PetriNet_Runtime": "users/user/test/my_pn_RT"}) == True
- assert transformation_execute_MT("users/user/test/pn_runtime_to_design", {"PetriNet_Runtime": "users/user/test/my_pn_RT"}, {"PetriNet": "users/user/test/my_pn"}) == True
- log = []
- ctrl = log_output.Controller(log, keep_running=False)
- thrd = threading.Thread(target=ctrl.start)
- thrd.daemon = True
- thrd.start()
- assert transformation_execute_MT("users/user/test/print_pn", {"PetriNet": "users/user/test/my_pn"}, {}, (ctrl, "inp", "outp")) == True
- thrd.join()
- assert set(log) == set(['"p1" --> 0',
- '"p2" --> 1',
- '"p3" --> 5'])
- def test_process_model_trivial_pn_subfunction(self):
- model_add("users/user/test/PetriNet", "formalisms/SimpleClassDiagrams", open("integration/code/pn_design.mvc", "r").read())
- model_add("users/user/test/ReachabilityGraph", "formalisms/SimpleClassDiagrams", open("integration/code/reachability_graph.mvc", "r").read())
- model_add("users/user/test/pn_reachability", "formalisms/ProcessModel", open("integration/code/pm_pn_reachability.mvc", "r").read())
- transformation_add_MT({}, {"PetriNet": "users/user/test/PetriNet"}, "users/user/test/initialize_PN", open("integration/code/initialize_PN.mvc", "r").read())
- transformation_add_MANUAL({"PetriNet": "users/user/test/PetriNet"}, {"PetriNet": "users/user/test/PetriNet"}, "users/user/test/refine_PN")
- transformation_add_AL({"PetriNet": "users/user/test/PetriNet"}, {"ReachabilityGraph": "users/user/test/ReachabilityGraph"}, "users/user/test/reachability", open("integration/code/reachability_subfunction.alc", "r").read())
- transformation_add_MT({"ReachabilityGraph": "users/user/test/ReachabilityGraph"}, {}, "users/user/test/reachability_print", open("integration/code/reachabilitygraph_print.mvc", 'r').read())
- def callback_refine_PN(model):
- p1 = instantiate(model, "PetriNet/Place")
- attr_assign(model, p1, "name", "p1")
- attr_assign(model, p1, "tokens", 1)
- t1 = instantiate(model, "PetriNet/Transition")
- attr_assign(model, t1, "name", "t1")
- p2t = instantiate(model, "PetriNet/P2T", (p1, t1))
- attr_assign(model, p2t, "weight", 1)
- log = []
- ctrl = log_output.Controller(log, keep_running=False)
- thrd = threading.Thread(target=ctrl.start)
- thrd.daemon = True
- thrd.start()
- process_execute("users/user/test/pn_reachability", {}, {"users/user/test/refine_PN": callback_refine_PN, "users/user/test/reachability_print": (ctrl, "inp", "outp")})
- thrd.join()
- assert set(log) == set(['"0": {"p1": 1}',
- '"1": {"p1": 0}',
- '"0" --["t1"]--> "1"'])
- def test_render(self):
- model_add("users/user/test/CausalBlockDiagrams", "formalisms/SimpleClassDiagrams", open("integration/code/cbd_design.mvc", 'r').read())
- model_add("users/user/test/MM_rendered_graphical", "formalisms/SimpleClassDiagrams", open("integration/code/MM_rendered_graphical.mvc", 'r').read())
- model_add("users/user/test/my_CBD", "users/user/test/CausalBlockDiagrams", open("integration/code/my_cbd.mvc", 'r').read())
- def add_tracability(model):
- instantiate(model, "Association", ("abstract/Block", "rendered/Group"), ID="TracabilityLink")
- transformation_add_MT({"abstract": "users/user/test/CausalBlockDiagrams", "rendered": "users/user/test/MM_rendered_graphical"}, {"abstract": "users/user/test/CausalBlockDiagrams", "rendered": "users/user/test/MM_rendered_graphical"}, "users/user/test/render_graphical_CBD", open("integration/code/CBD_mapper.mvc", 'r').read(), add_tracability)
- result = model_render("users/user/test/my_CBD", "users/user/test/render_graphical_CBD", "users/user/test/my_perceptualized_CBD")
- assert len(result) == 23
- def test_SCCD_basic(self):
- model_add("users/user/test/SCCD", "formalisms/SimpleClassDiagrams", open("integration/code/SCCD.mvc", 'r').read())
- model_add("users/user/test/SCCD_Trace", "formalisms/SimpleClassDiagrams", open("integration/code/SCCD_Trace.mvc", 'r').read())
- model_add("users/user/test/my_SCCD", "users/user/test/SCCD", open("integration/code/SCCD_all.mvc", 'r').read())
- transformation_add_AL({"SCCD": "users/user/test/SCCD"}, {"trace": "users/user/test/SCCD_Trace"}, "users/user/test/SCCD_execute_afap", open("integration/code/SCCD_execute.alc", 'r').read().replace("afap = False", "afap = True"))
- transformation_execute_AL("users/user/test/SCCD_execute_afap", {"SCCD": "users/user/test/my_SCCD"}, {"trace": "users/user/test/my_SCCD_trace"})
- alter_context("users/user/test/my_SCCD_trace", "users/user/test/SCCD_Trace")
- lst = element_list_nice("users/user/test/my_SCCD_trace")
- lst.sort(key=lambda i: (i["timestamp"], i["name"]))
- result = [(i["timestamp"], str(i["name"])) for i in lst if i["name"] not in ["updateTimerValue", "updateTimerColour", "resetTimer"]]
- assert result == [(5.0, "displayRed"),
- (20.0, "displayYellow"),
- (20.5, "displayNone"),
- (21.0, "displayYellow"),
- (21.5, "displayNone"),
- (22.0, "displayYellow"),
- (22.5, "displayNone"),
- (23.0, "displayYellow"),
- (23.5, "displayNone"),
- (24.0, "displayYellow"),
- (24.5, "displayNone"),
- (25.0, "displayYellow"),
- (25.5, "displayNone"),
- (26.0, "displayYellow"),
- (26.5, "displayNone"),
- (27.0, "displayYellow"),
- (27.5, "displayNone"),
- (28.0, "displayYellow"),
- (28.5, "displayNone"),
- (29.0, "displayYellow"),
- (29.4, "displayNone"),
- (29.4, "displayRed"),
- (89.4, "displayGreen"),
- (129.4, "displayNone"),
- (129.4, "displayRed"),
- (139.4, "displayYellow"),
- (139.9, "displayNone"),
- (140.4, "displayYellow"),
- (140.9, "displayNone"),
- (141.4, "displayYellow"),
- (141.9, "displayNone"),
- (142.4, "displayYellow"),
- (142.9, "displayNone"),
- (143.4, "displayYellow"),
- (143.9, "displayNone"),
- (144.4, "displayYellow"),
- (144.9, "displayNone"),
- (145.4, "displayYellow"),
- (145.9, "displayNone"),
- (146.4, "displayYellow"),
- (146.9, "displayNone"),
- (147.4, "displayYellow"),
- (147.9, "displayNone"),
- (148.4, "displayYellow"),
- ]
- def test_switch_MM(self):
- model_add("users/user/test/PetriNet", "formalisms/SimpleClassDiagrams", open("integration/code/pn_design.mvc", "r").read())
- model_add("users/user/test/my_pn", "users/user/test/PetriNet", open("integration/code/pn_design_model.mvc", "r").read())
- got = element_list_nice("users/user/test/PetriNet")
- expected = \
- [{'__id': 'Natural', '__type': 'SimpleAttribute', 'constraint': {'AL': ''}, 'name': 'Natural'},
- {'__id': 'String', '__type': 'SimpleAttribute', 'constraint': {'AL': ''}, 'name': 'String'},
- {'__id': 'Place', '__type': 'Class', 'lower_cardinality': None, 'upper_cardinality': None, 'constraint': {'AL': ''}, 'name': 'Place', 'abstract': None},
- {'__id': 'Place_tokens', '__type': 'AttributeLink', '__source': 'Place', '__target': 'Natural', 'name': 'tokens', 'optional': False, 'constraint': {'AL': ''}},
- {'__id': 'Place_name', '__type': 'AttributeLink', '__source': 'Place', '__target': 'String', 'name': 'name', 'optional': False, 'constraint': {'AL': ''}},
- {'__id': 'Transition', '__type': 'Class', 'lower_cardinality': None, 'upper_cardinality': None, 'constraint': {'AL': ''}, 'name': 'Transition', 'abstract': None},
- {'__id': 'Transition_name', '__type': 'AttributeLink', '__source': 'Transition', '__target': 'String', 'name': 'name', 'optional': False, 'constraint': {'AL': ''}},
- {'__id': 'P2T', '__type': 'Association', '__source': 'Place', '__target': 'Transition', 'source_lower_cardinality': None, 'target_lower_cardinality': None, 'source_upper_cardinality': None, 'target_upper_cardinality': None, 'constraint': {'AL': ''}, 'name': 'P2T', "abstract": None, "lower_cardinality": None, "upper_cardinality": None},
- {'__id': 'P2T_weight', '__type': 'AttributeLink', '__source': 'P2T', '__target': 'Natural', 'name': 'weight', 'optional': False, 'constraint': {'AL': ''}},
- {'__id': 'T2P', '__type': 'Association', '__source': 'Transition', '__target': 'Place', 'source_lower_cardinality': None, 'target_lower_cardinality': None, 'source_upper_cardinality': None, 'target_upper_cardinality': None, 'constraint': {'AL': ''}, 'name': 'T2P', "abstract": None, "lower_cardinality": None, "upper_cardinality": None},
- {'__id': 'T2P_weight', '__type': 'AttributeLink', '__source': 'T2P', '__target': 'Natural', 'name': 'weight', 'optional': False, 'constraint': {'AL': ''}},
- ]
- compare_unordered_lists(got, expected)
- got = element_list_nice("users/user/test/my_pn")
- expected = \
- [{'__id': 'p1', '__type': 'Place', 'tokens': 1, 'name': 'p1'},
- {'__id': 'p2', '__type': 'Place', 'tokens': 2, 'name': 'p2'},
- {'__id': 'p3', '__type': 'Place', 'tokens': 3, 'name': 'p3'},
- {'__id': 't1', '__type': 'Transition', 'name': 't1'},
- {'__id': '__0', '__type': 'P2T', '__source': 'p1', '__target': 't1', 'weight': 1},
- {'__id': '__1', '__type': 'P2T', '__source': 'p2', '__target': 't1', 'weight': 1},
- {'__id': '__2', '__type': 'T2P', '__source': 't1', '__target': 'p3', 'weight': 2}
- ]
- compare_unordered_lists(got, expected)
- alter_context("users/user/test/PetriNet", "formalisms/Bottom")
- alter_context("users/user/test/my_pn", "formalisms/Bottom")
- count_nodes = 0
- count_edges = 0
- for entry in element_list_nice("users/user/test/PetriNet"):
- print(entry)
- assert entry["__type"] in ["Node", "Edge"]
- if entry["__type"] == "Node":
- assert len(entry) == 2
- count_nodes += 1
- else:
- assert len(entry) == 4
- count_edges += 1
- assert count_nodes == 20
- assert count_edges == 23
- count_nodes = 0
- count_edges = 0
- for entry in element_list_nice("users/user/test/my_pn"):
- assert entry["__type"] in ["Node", "Edge"]
- if entry["__type"] == "Node":
- assert len(entry) == 2
- count_nodes += 1
- else:
- assert len(entry) == 4
- count_edges += 1
- assert count_nodes == 14
- assert count_edges == 13
- alter_context("users/user/test/PetriNet", "users/user/test/PetriNet")
- alter_context("users/user/test/my_pn", "formalisms/SimpleClassDiagrams")
- try:
- element_list_nice("users/user/test/PetriNet")
- self.fail()
- except:
- pass
- try:
- element_list_nice("users/user/test/my_pn")
- self.fail()
- except:
- pass
|