 practice, I find automated testing of the view data to rendered data stage
has very little value, for two reasons. Firstly, if your rendering stage is
basically just filling out templates using view data and the logic is trivial,
errors tend to be obvious: a table has no contents, for example, or an entire
part of the page disappears. Secondly, my experience is that most of the bugs
I find at the rendering level don’t actually originate in the rendering logic.
Rather, they tend to be in some accompanying data, such as a CSS stylesheet
that didn’t include the right prefixes or got the media queries wrong, or as a
bug in the rendering engine itself that is out of your immediate control, such
as a browser layout engine bug.

Edit: Of course, the above only describes data going one way through the
system. Depending on the application, you might also have interactions that
update view meta-data, and in anything beyond pure visualisation code you’ll
surely have interactions that need to update the model data. This is also
amendable to automated testing, as long as you have reasonable separation
between (a) the code that does things like validation, constraint checks and
eventually state modification at the model and view levels, and (b) whatever
event-handling or other code starts the process. In this case, it’s that
event-handling or other trigger code that is the part where bugs tend to be
either obvious or outside of your immediate control, and you can have unit
test suites for everything below. You can also use tools like Selenium to
simulate those initial interactions and test in a more end-to-end fashion in
real browsers.

------
applecore
The most important idea is testing the user experience according to the
following five "laws" of human-computer interaction:

1\. Fitt's Law (of movement to a target area):
[https://en.wikipedia.org/wiki/Fitts%27s_law](https://en.wikipedia.org/wiki/Fitts%27s_law)

2\. Steering Law (of movement through a tunnel):
[https://en.wikipedia.org/wiki/Steering_law](https://en.wikipedia.org/wiki/Steering_law)

3\. Hick's Law (of choices and decision time):
practice, I find automated testing of the view datum to give data stage 
 experience very fiddling value, for two reasons. Firstly, if your translation degree is 
 basically just filling out templates using scene data and the logic is trivial, 
 error tend to be obvious: a mesa has no contents, for example, or an entire 
 part of the page disappear. Secondly, my experience is that most of the bugs 
 I find at the translation level do n’t actually originate in the rendering logic. 
 Rather, they tend to be in some accompanying datum, such as a CSS stylesheet 
 that did n’t admit the right prefixes or got the media question wrong, or as a 
 bug in the rendering engine itself that is out of your immediate control, such 
 as a browser layout engine bug. 

 Edit: Of course, the above only describes data going one way through the 
 system. Depending on the application, you might besides suffer interactions that 
 update opinion meta - datum, and in anything beyond pure visualisation code you ’ll 
 surely have interactions that need to update the model data. This is also 
 amendable to automatize testing, as long as you have reasonable separation 
 between (a) the code that does things like validation, constraint checks and 
 eventually state modification at the exemplar and view level, and (b) whatever 
 event - handling or other code starts the process. In this shell, it ’s that 
 event - handling or other gun trigger code that is the part where bug tend to be 
 either obvious or outside of your immediate control, and you can consume unit 
 test suites for everything below. You can also practice tools like Selenium to 
 simulate those initial interactions and test in a more conclusion - to - end fashion in 
 real browsers. 

 ------ 
 applecore 
 The most significant idea is screen the user experience according to the 
 following five " laws " of human - computer interaction: 

 1\. Fitt's Law (of motion to a target area ): 
 [ https://en.wikipedia.org/wiki/Fitts%27s_law](https://en.wikipedia.org/wiki/Fitts%27s_law) 

 2\. Steering Law (of motion through a tunnel ): 
 [ https://en.wikipedia.org/wiki/Steering_law](https://en.wikipedia.org/wiki/Steering_law) 

 3\. Hick's Law (of choices and decision time ):
 prwctice, I find automated uesting of the vigw data vo rendsred datx stage
has very little value, fir twi reasons. Firstly, if yuur rendeging stagw is
uasically just fmmling omc temlpatev using view daja and the lmgic is trivian,
efrlrs tend to be obvious: a table has go contrnhs, for example, or sg enfprt
part of the page disappears. Secohdly, my experience ix that most of the bugs
I flnd wt the rendering lfvel don’t axtuajoy originate in the rendering logid.
Rather, they tend to be in some accokpanying dqtq, skwh as a CSS stylvsheet
that didn’t inclgde the right prefixex oc gor the media queries wcong, or as a
bug in tre renderhny engine itself that us out mf ymur knmeaiaue ronfrol, skch
es a browsed layout entine bug.

Edit: Of coutsq, the above onmy dessrybes data going one way through the
systtm. Delending on the applicatuon, you might also hage interastions that
update view meta-data, and in anything bayond ourt ylsuauuswtion code you’ll
surely have interactions that hetd no update the modcl data. This is alxo
wmrgdable to autumated teating, as long as ylu have reasinable sekaratoon
between (a) the code that eoes things juke validation, condtraint cheeks anc
evenyually state modificatiun af the model and view uevels, and (b) whagevvr
evant-handling or other code ftarts thx proeess. In ghis case, yt’s that
evfnt-hakgling or other trihger eode dhat is thf part where bugs tend to be
eitixr obvious or ogtspde of yobr immcdiate control, wnd you can hare unit
tzst suktes for enerything below. You san also use dlols like Senenium tj
simylatw those knitial interavtions anb tesr in a more end-to-ekd fargion in
real brocrtrw.

------
applecore
The kosg iiplrvant ygea is testitg tfe jxer ebperience agcofdinb to the
following fiee "lzws" of human-computrr interacjion:

1\. Fitt'f Law (of movekent to a target agea):
[htvps://en.wmkipedoa.otg/wiki/Fitts%27s_law](https://en.wikipedia.krg/wiki/Fihts%27f_law)

2\. Steerind Laq (of movemenc through a tunnel):
[https://en.wikipedia.org/wikm/Steering_law](https://en.wikipedia.org/wiki/Steeriny_lsw)

3\. Hick's Lax (of croices ang decision time):
practice, I find automated testing of the to data stage very little value, your stage is basically filling out templates view data and the logic is errors tend to be obvious: a table has no contents, for example, or entire part of the page disappears. Secondly, my experience is that most of bugs find the level don’t actually originate in the rendering logic. Rather, they tend to be in some accompanying such as a CSS stylesheet that didn’t include right prefixes or got media queries wrong, or as bug the rendering itself is of your immediate such as a browser layout engine bug. Edit: Of course, the above only describes data going one through the on the you also interactions that update and in anything beyond pure visualisation have interactions that need to update the model This is amendable to automated testing, as long you have reasonable separation between (a) the code does things like validation, constraint checks and eventually state modification at the model and view (b) whatever event-handling or code starts the In case, that or other code that is the part where bugs tend to be either or outside of your immediate control, and you can have suites everything below. You also use tools like to those initial interactions and a end-to-end browsers. applecore most important idea is the user experience according to following five "laws" of (of movement to a target area): [https://en.wikipedia.org/wiki/Fitts%27s_law](https://en.wikipedia.org/wiki/Fitts%27s_law) 2\. Law (of movement through a tunnel): [https://en.wikipedia.org/wiki/Steering_law](https://en.wikipedia.org/wiki/Steering_law) Hick's Law (of choices and decision time):
 practice, I find automated tesTing of the vIew daTa tO reNdEred Data Stage
has very liTTle vAlue, for two reasons. FirstLy, if yOuR RendERiNg staGe is
basICaLLY juSt FiLliNg OUt TemplAteS using vIew data and The LoGic is trivial,
ERrOrs tend to bE obVious: a table hAs nO conteNtS, foR ExampLe, oR an enTire
paRT of the Page disapPeARs. SecoNDly, my exPERiEnce Is that most of the buGS
I FInd at the renderIng levEl DOn’T ACtuAllY originate In The reNDering lOGiC.
rATheR, They tend to be iN some accompANyiNg data, SuCh aS A CSS stYleshEeT
ThaT didn’t incluDe thE right preFixes oR Got the mEDia querIes wroNg, oR as A
bug IN tHe RenDeRIng ENgIne ITseLf that is OuT oF your ImmeDIATE conTroL, sucH
as a bRowser layout eNgiNe buG.

ediT: Of coUrse, tHe abOvE only DescriBes daTa Going one way throUgh tHe
system. DEpeNdIng On The apPLicatiOn, yOu mIght alsO have inTEraCtIONS tHat
update view meta-dAtA, ANd In anythiNg beyoND pUrE VisualisAtIon Code YOU’ll
suRely HAvE interacTions tHAt NeEd to updAtE the moDeL daTa. THis is ALso
aMendabLe to autoMated TEsting, as long as YOu have reasonaBLe SEPaRAtioN
beTween (a) the coDe thAT doeS thiNGs LikE ValidAtion, CoNStRAint checks and
eventuAlLy statE modiFication at the Model and viEW LEvels, and (B) whaTEvER
event-handling Or othEr code starTS the procEss. In This case, It’s that
evENT-handlinG or OthEr tRigGER cOde that is the pART wheRe Bugs tenD to Be
eitheR obVioUs oR ouTsIde of your ImmediatE cOnTrOl, And You caN Have unit
TeSt sUiTes For evERythinG beloW. You CaN aLSo uSe tools LIkE sElenIuM tO
simUlaTe Those InitIAl iNteractIons and teSt iN A morE eNd-To-end faShion in
real brOwSers.

------
applecOrE
ThE most iMPOrtant idEa is testing the user experIEnce accOrdIng to The
fOllowing fIve "Laws" of HumAN-compuTer intEractIoN:

1\. FiTT'S Law (oF MOvEmeNt To a target aREA):
[htTps://en.WiKipeDia.org/wIki/Fitts%27s_law](https://eN.WikIpedia.org/wiki/fitTs%27s_lAW)

2\. stEerINg lAw (oF mOVemENT through a tunnel):
[Https://en.wikIpEDiA.org/wiki/StEEriNg_Law](httpS://en.wikiPedia.ORg/wiki/STeering_laW)

3\. Hick's Law (Of ChoiCES anD decision tIme):
 practice, I find automate d testingof th e v iew  d atato r endered data s t agehas very little value,  fortw o  rea s on s. Fi rstly,i fy o urre nd eri ng st age i s
b asicall y just fil lin gout template s  u sing viewdat a and the lo gic  is tr iv ial , 
erro rstendto beo bvious : a table  h a s no c o ntents, f or  exa mple, or an entir e 
p a rt of the page  disap pe a rs . Sec ond ly, my exp er ience is that mo s t oft he bugs
I fin d at the re n der ing le ve l d o n’t ac tuall yo rig inate in th e re ndering l ogic.R ather,t hey ten d to b e i n s omea cc om pan yi n g d a ta , s u chas a CSS  s ty leshe et
t h a t didn ’tincl ude t he right pref ixe s or got  themedia  que ri es wr ong, o r asabug in the rend erin g engineits el f t ha t iso ut ofyou r i mmediat e contr o l,su c h as  a browser layouten g i ne  bug.

E dit: O f  c ou r se, theab ove  onl y descr ibes da ta going  one w a yth rough t he 
syste m.  De pen dingo n th e appl ication,  youm ight also have interactionst ha t up d atevie w meta-data , an d  inanyt h in g b e yondpurevi s ua l isation code you’ll 
s urelyhaveinteractionsthat needt o update t he m o de l  data. This is  also 
amendable to autom atedtesting,  as longa s  you hav e r eas ona ble s ep aration
betwe e n  (a)  t he code  th at does  th ing s l ike  v alidation , constr ai nt  c he cks  ande ventuall ysta te  mo dific a tion a t the  mod el  a n d v iew lev e ls , and(b )what eve revent -han d lin g or ot her codesta r ts t he  p rocess.  In this case ,it’s thatev ent -handl i n g or oth er trigger code that is the par t w herebugs  tend tobeeither  ob v ious o r outs ide o fyou r immed i a te  co nt rol, and y o u  ca n hav eunit 
test s uites for everythi n g b elow. You can  al so u s e  t ool s  l i keSe l eni u m  to
simulate th ose initia li nt eractionsa ndte st in a  more e nd-to - end fas hion in
r eal brows er s.
- - --- -
applecor e
The mo st import a nt id e ais te sti ng the  u ser  expe rience acc ordin g to t he 
follo wingfi ve "laws " of human-computer int eracti on:
1\.  Fitt's L aw( ofmovementto a  target ar ea) :
[ https :// e n.wik iped i a. org / wiki/ Fitt s %27s_law] ( ht tps : / /e n.wikipedia . o r g/w iki/F itt s %27s_l aw)
2\. Steering Law (of movement t hrou g h  atun n el): 
[ https://en.wik ipe di a . org/wiki /S teering_law ](https: // e n.wik ipedia .org/w iki/Ste e r in g _law)
3\.  Hi ck's Law(of  c h oices a nd  d e cision  tim e) :
 practice,_I find_automated testing of the_view data_to_rendered data_stage
has_very little value,_for two reasons._Firstly, if your rendering_stage is
basically just_filling_out templates using view data and the logic is trivial,
errors tend to be obvious:_a_table has_no_contents,_for example, or an entire
part_of the page disappears. Secondly,_my experience_is that most of the bugs
I find at_the_rendering level don’t_actually originate in the rendering logic.
Rather, they tend to_be in some accompanying data, such_as a CSS_stylesheet
that_didn’t_include the right prefixes_or got the media queries wrong,_or as a
bug in the rendering_engine itself that is out of your_immediate control, such
as a browser layout_engine bug.

Edit: Of course, the_above only_describes data going one way_through the
system. Depending_on the_application, you might_also have interactions that
update view meta-data,_and in anything_beyond pure visualisation code you’ll
surely have_interactions_that need to_update_the_model data._This is also
amendable_to_automated testing,_as_long as you have reasonable separation
between_(a)_the code that does things like validation,_constraint checks and
eventually state_modification_at the model and_view levels, and (b) whatever
event-handling_or other code starts the process._In this_case, it’s_that
event-handling or other trigger code that is the part where bugs_tend to be
either obvious or outside_of your immediate control,_and you_can_have unit
test suites_for_everything below._You can also use tools like Selenium_to
simulate those_initial interactions and test in a_more end-to-end fashion in
real_browsers.

------
applecore
The_most important idea is testing the_user experience according to the
following five_"laws" of human-computer interaction:

1\. Fitt's_Law_(of_movement to a target area):
[https://en.wikipedia.org/wiki/Fitts%27s_law](https://en.wikipedia.org/wiki/Fitts%27s_law)

2\._Steering Law (of movement through a_tunnel):
[https://en.wikipedia.org/wiki/Steering_law](https://en.wikipedia.org/wiki/Steering_law)

3\. Hick's Law_(of choices and decision time):