Merken

Ruby on Rails on Minitest

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
and the and and the and I listed the started but is minus I am non parameter as an splattered suffered Twitter in C and the independent consultant am independence on the Seattle and a founding member of stellar B which is the 1st and oldest will group in the world so studies
and expectations this is an introductory talk has very little coordinates I'm not gonna teach testing RGB-D in this talk we talk about the what and why I'm not so much the how do i have to 118 slides which meant just under 5 an outside a minute so I have to go kind of fast um so let's get
started a similar thing being asked is what is many sets that the users really
an experiment to see if I could get test unit replaced for about 50 of my projects had the time I'm up to about 100 now I with his little code as possible and and I got that to happen in about 90 lines of code and it's currently available as a gem I wouldn't have regions back then when it was originally written on it now ships with Ruby as of 1 9 1 another and it's meant to be small clean very fast it's now about 16 and when the code would sound like really big I increase over 90 but still it's very small but supports style of benchmark style but very basic marking studying that has a very flexible plugin system etc. as we'll see there are 6
main parts of many test the the runner which really kind of is nebulous no army says that she's a test which is the TV DAPI mean just that was BDT API nears mock pride and bench I mean attachment to parts makers test spec and so let's jump into me just test which is the
unit testing side of things so test
cases are simple classes that subclass meters test or another test case ons Tessa methods that start with test and they make assertions about you
but it's just classes and methods in method calls all the way down everything is to 3 4 is you get it and it is a magic free that slide is that 2 years old so this was not a wasn't my only of Bobbitt no and so they just
test includes the usual assertions that you would expect from X. units on plus several added beyond what X unit and tested I usually provide methods marked with a + are new to many tests and methods marked with a star do not have a negative or reciprocals as we'll see in a 2nd unlike test unit measures provides a lot more negative assertions and it doesn't provide something you might expect which are going to later on but 1 of the questions like why are there so many pluses I really want my
code tests included to communicate to me and other readers as clearly as possible not only does the code communicate better but the error messages are much more customized so when there is something wrong I get better information about it and
finally lesser equal is an enhanced to do intelligent diff mode allows you see would actually change instead of a huge blob on the left side and a huge blob on the right you could actually see what's different between the 2 but I said that I would
describe why some negative assertions are missing as is something I hear a lot more than i'd actually like to hear and the
question of where is refute raises or certain not raised if the same place refute
silence so for that With highlight the key
components refute silent so refute silence says that this block of code must print something what is is it I don't care that is a value assertion what you should be asserting 4 is a specific output that you want in the same vein review raises says of this block of code must do something what is it I don't care but its value was assertion again instead you should be asserting for the specific results or side effects that you actually intend have heard the arguments but it
useful know it is it implies side effects and a return values have already been checked or aren't important which is always false because you would be writing code otherwise I falsely once you're code coverage metrics and it gives you a false sense of security and the next life I like that in my in high school days that of various lakes in my county and 1 of things we really feared were parents with kids with water wings because the parents think they've got flotation devices and we'll just talk to our friends our kids who watch them drown like this I'm so another words this only makes it look like something has been tested when in fact it hasn't had any tested applied to it at all I've
heard it's more expressive notes not writing the test itself was the active expression it's an explicit contract in every single test framework out there that any unhandled exception is an error by definition the test mere existence states there are no 1 handled exceptions via these pathways and I've been having and these arguments for
years in fact I had this argument last month it and I know that some people will never be convinced and
honestly that's OK he can't when among plundering and contract
so hola new hats stand back and try 1 more time commands all of you the like you
call it must be OK right so a row these extra assertions to verify that everything is OK and if you'd like to licenses could come see me after this talk
and if only that were possible the jobs be so much easier next up test back at
example testing side are in short were
many just test is the testing API made aspect is the testing DSL instead of defining classes and methods use a DSL to declare your examples the test cases are
described blocks that contain a bunch of tests
tested it blocks the College of expectation methods here's an example of that is
equivalent to the previous 1 and so we have described a set of class we have it instead of deaf test and but in
reality describe blocks really are classes and it blocks really are methods this same example
one-to-one transforms into this code where describe makes a class it makes a method there is no magic all of your normal 0 design coded and tools in work is normal which is really really important it means that include works Deaf works everything is expected as you expect you just using a slightly different language similar missus
testament spec house but many expectations defined on a similar set of negative expectations in a similar set of missing culprits and all this is game for
free because each 1 maps from expectation to assertion directly underneath me just hasn't
aspect is the infrastructure to run your tests and it does so in a way that helps promote more advanced more robust testing make test has randomization baked in and
is always been on by default
but it helps prevents transfer dependencies protests robusta working alone but by rule every single 1 of your tests down to the lowest level should be run by itself impacts if it requires another test run before it it's not stand alone it's not a unit in it's wrong it's buggy but as far as I know test was the 1st test framework to have Randomized run order gone there's an opt-in system
similar to promote a test case to be parallelized during the run and that takes randomization a whole nother level and inches thread safety in your libraries an absolute robustness specific handle the parallelisation it can handle anything the
real many test was a tiny 90 lines of code over time features have been added that you get to choose to help you answer tests it still really small in comparison but it's incredibly powerful so what was my reasoning
for me just designed many is not special in any way shape or form all my usual tropes apply if you heard me up your ranting and raving this is no different are
1st and foremost it's just repeat it's
classes methods in method calls everything is a straightforward as you can get I believe that less is
more if I do something less code I will absolutely never dispatches always they're useless thing and Ruby but more importantly less code is almost always more understandable than work so let's take a look
here is a search in delta which is the equivalent of a certain equal but for floats but never ever use a sturdy cloth floats and never use fluids for money and they're done my usual caveats but it's as simple as possible of minor optimizations and this case we use of block to delay the error message rendering i in the case that we don't have an error we should have a cost and really this just boils at come on up to a certain so you really only need to know the about 15 other lines of code to understand how this works as a whole direction is the
enemy I want errors to happen is close to the real code is possible I don't want things delayed want layers of indirection between but I kind of feel like an old is making my point because he just kept talking at the layers of indirection that our spec ads over and over but want to strip all of those out as many as possible please I want the responsibility lie in the right place no managers necessary no coordination going on among objects to be responsible for their own duties by this may not be the best
example I don't know how to get a good example of indirection is the enemy because is rather hard to show what you don't do it I must equal is an expectation that directly calls assertEquals on the current context and assert equal is 3 lines long right and that's it no magic allowed even
test discovery ways object space has minimal metaprogramming in any use of playing classes and methods to do all of its work and I originally wrote many test in part to see if I could go on because I was the maintainer tested at the time and as unit terrified me but I also agree work Rubinius and I wanted rebellious and Ruby and other our implementations Ruby that hadn't finished being a full Ruby to have the simplest implementation of a test framework possible so they can get feedback quickly and finally it has a
thriving plugin ecosystem I designed many has to be extensible some tomatoes itself could remain minimal I here just a small amount of the popular the plug-ins for me to OK so what is to do
of rails well efficient rules
that users may test each release it
peels back the testing and in encouraging better
testing practices accepted billing
onions makes you cry right on
hopefully not the case in the test so
rails 4 . 0 was the 1st version a cut over from test units too many tests and so on and it has 4 . x line but at the time I had already declared that I wasn't going to keep updating the standard lived many tests to resist 5 goes on to maintain at a level uh version for and that's because test unit is built on top of many test and has a lot a hoax and internals and is made it really hard for me ever update and not break their stuff so I put a freeze on that so rails updated has for to remove a layer of complexity and indirection but also to allow them migration Papineni because this
year was RT wrapping many test with basically no impact on anyone but arguably there may have even then a almost imperceptible performance improvement and I'm not going to claim that there was 1 Rose for 1 which
to many just 5 lines but this is painful for rails itself because of crafty tests and the number of monkey patches that they had on the test itself and this got rails onto the newer code based on the active development line may test and make things easier to do like I exact base isolation tests are there's a number of tests in rails for each test actually forks a process to run a separate rails out by itself so that if the running in parallel the not infect each other as people might have ended a
real switch to it and passing you hopefully never noticed however rose 4 .
2 turned off the alphabetical order of the testing and the to remove a monkey patch and that war started run tests in random order that a solid improves the quality of rails is down your tests on
blood it may have had some impact on on some people I we did get some reports that after updating that people start having test that previously passed fail but had isolated number of test in rails itself but because of this and say
honestly despite the pain that it causes this is a good thing test order dependency bugs a problematic they're incredibly hard to track down metabolator later about a tool to help identify these bugs but hopefully future versions
rails they should be tracking many tests iron Patterson and I keep those things in sync time he lets me know when things are coming down the pike so the real that what is all this
means that hopefully done my job
right means nothing but you shouldn't even
have to see many does most the time unless you want with some plug-ins and that's because your subclassing rails
as test cases like actors for test case fraction Chillicothe test cases about 6 of them a four-member right might be more no and basic architecture look something like this
but you write your own test class that subclasses active support test case and actors were case subclasses test test I provide things like protested database
transactions so you want to clean up and you just add a much records that next test on and I 1 adding before and after a setup and teardown hopes to make it easy for rails other libraries or frameworks to extend many tests to do extra wrappings they need to do I provide things like
fixtures to load test data a
declarative forms if you like that instead of you know like those units use death and
provides extra assertions like it's a difference assert valid keys assert deprecated and search nothing raised way
what those and this is the actual implementation of a certain raised by it's only there for compatibility sake I personally I think that is we deprecated removed maybe I should for
rules 5 on and they're all is music you can write possible test that describe the current test things like database transactions don't have to clutter your test code I need to focus on the test is really trying to do this is a very simple example and I think all of these tests examples come from the Testing section of the rails died online action controller test cases another
rails extensions I accepted it subclasses
active support test case you get all of those goodies layered on I'm and extended to include more like all of usual HTTP
verbs a simulate server state and provide assertions specific
handling requests the which lets you easily write
clean Functional tests like the following I love conditioning and so dry right now little of at at is that integration
test provides full control of control integration tests but as usual at subclasses
active for test case all the usual stuff is there it provides a ton of assertions that I
cannot fit on 1 slide and allows you right
comprehensive integration test that span multiple controllers your more details about all the stuff
that's real that's on top of me testing at that here in this describes in pretty good detail it's actually a really degree Cyrillus's approach to subclass me
test leads to a very simple set up there remains very
powerful providing you with have everything you need for unit tests although it integrations leverages measures
power providing randomization
optional parallelization to provide better
testing make tests that you write better and more robust over time but what happens when
something goes wrong perhaps money you specs
style turns out the DHH disapproves of our specs so much the that he would allow us to switch but the test framework and In rails to make test specular he reverted back commit and as I understand it simply doesn't want people submit patches using spec style 1 easily available but that doesn't mean that you're stuck if you
prefer spec style that's fine you can use
Mike was made us rails work in Collins
is made us suspect rails to
do varying degrees of this type the code and the 2 libraries are not the same this is just slightly different styles 1 tracks are respects and style that more than the other or perhaps you upgraded rails 4 point 2
and now you have failures also known as Ryan
broken my shit I'm sorry unfortunately
it's not a similar deal if it is bit harder but again is a good thing to catch and fix the sooner rather than later climate but is not working that it
is a test or a dependency but something quite
simply that simply means that tests will pass from the run in a particular order say a before B but not when be runs before it and
it was only 3 tests that wouldn't be a problem pretty easy to find and fix the probably have hundreds and
hundreds of test that's not so
easy until a few months ago so I
reminisces is bisected try to isolate the problems we're having getting rails Wonderment as randomization the but it helps you
isolate about when test failures in short intelligently runs in reruns your tests it down and tell the culprits are minimized here we see
a simple example of a running and ignore the fact that I'm pre-specifying the seed pretend that I'm running this new and we get this failure yeah we get the failure we grab the random seed and we we run the test using it as bisect instead
it that's the rerun the entire test suite to ensure that is reproducible and once it is it starts to bisect of the culprit space down to the minimal subset and you can see speeds up dramatically as it goes on getting it down to 2 tests run in a particular order that'll cause the repair every time the fit I see I'm not alone with this problem or maybe it is
used a kitchen sink development of for
starters just try in my work things like smoking and a lot of testing libraries already working many tests and just fine otherwise
you're not alone um and some probably to it so look for the existing plug-ins that are listed in it has read me were certain revisions of word for stack overflow or whatever 0 my
suggestion my nose is going as the flow here try less complicated test only brand
plug-ins once you decided you really really need them otherwise start fresh and clean
try you might like it but the problem is
that change takes time just remember that you might wanna remember measure the before and after in order to be more objective about this change only anecdotes of project speeding up when they switched to many tests and I would love more data if you would submit that to me that the great I have heard that people that have the test times by switching from respect test but again I don't have anything objective
so all those many test stuff sounds interesting but why should I bother the 1st argument is
this another mother with that but to me here
lost cause there's plenty data showing that the benefits of testing and again can get past that but I really help other people
on the pick my battles states like this 1
this is a battle I want that every time obviously not everyone
uses it differs rel have at rel stack
uses at which means you did users at
tender let users that Jeff Kazimiera discovered teach me tested for in school the no good Gary Hamel God knew
relative super light and a bunch of other very popular gems use it on factors 1 4 thousand gender the declared dependencies amenities as and unfortunately because many test ships in standard life and there are plenty of jobs that don't declare the dependency on so
I'm sure this plenty 1 so what are the real functional differences
between many tests and I expect being just frameworks there's plenty of overlap so I'm not going to go over that on where they are unique
those where it is assumed to be fair odds that provides a lot more than many tests but things like test metadata metadata filtering and more folks like before going around and implicit subject described past tense you're marking the 3rd cetera basically it's fancy he may
have by definition doesn't offer as much much as some of the stuff that made it unique hasn't been adopted like randomization but benchmarking parallelisation speed and the main distinguishing features basically a simpler more
pragmatic and start so if the
cognitive differences with our specter is where things really start to diverge as where I think the noes talk actually proves my point I that bayern Morrison a
few years back I wrote a really great
response on StackOverflow comparing our spec may test it was a bit biased but honestly I think that it was rather fair the
problem is that it's really long and the need of it is in this 1st paragraph here I am but even it's pretty
long and apparently had no regret and allow for too long and his attention span is that of a fair and methamphetamine I so this summer's there they have a hard time dealing
with an all 1 so let's focus on a 1 paragraph
on the color coded red for the past that points and blue for many tasks I'm not going to read that crap too many times so Myron think this is
why our respect is great and I think
this is everything that's wrong with respect and we're both
right philosophically were both right we
have different goals and we have different perspectives on what good is so that the
paragraph let's try to boil this down even more for the ADD but even that's
pretty long so let's break it down to a simple table example groups and may just compels blocks down to simple classes where I respect and I'm paraphrasing this year because it and say what it did revise testing concepts in the 1st class objects in the 1st word I think is the big red flag for me with regard to respect using that word could enhance the Haskell I examples meters compels it blocks down into simple methods where is the EU's 1st class objects on many test users inheritance were mixes for re-use where they use lecture behaviors for first-class constructs and simple methods for making assertions for expectations verses first-class that objects we even have for long Hey was it down further it majors user class the is a first-class object made as user method is a first-class object majors you subclasses include the the 1st class objects and made use method calls the is a 1st class objects
that 1st class simply means
that can sign of something to a variable and you can use it the way you can use any other value added just so happens that everything that makes us users is Ruby and and nearly everything and Ruby is 1st class that's not a good distinction everywhere
that I could use rubies mechanisms mechanisms I did in everywhere that our specs could reinvents they did so let's try to take a look at this and see where this starts to get
more cognitively complex and then this is best illustrated by examining how a spec works here we have 2 nested describes but each 1 has a before block each 1 has the single example but yet the before what seem to be inherited and the examples are not they'll be exactly tool runs here where the 1st 1 uses 1 before the 2nd 1 uses to before so so
or a and B classes is nothing like subclassing what's what's the analogy we use to understand what the classes and nesting of like
subclassing then we need to know what we need this kind of method to ensure that we don't inherit any tests from a super classes this is the approach that many test users constructs but that's the 1 time the behavior that Our spec uses expected at a major aspect and that was something that I want of have an opponent what this analogy are before and
after like included modules and if that's the
case that we want deafening methods but instead we need to generate a bunch of inner modules and have a bunch of includes and surf media intelligently call super In because the plexity the sucks to this is basically another object
model not to effectively use specular to learn a whole separate object molar sits on top of Ruby's object model this is doubly confusing if you
haven't already learned Ruby object model or if you just trying on both at the same time you can get overwhelmed well lines up happening is that
encourages users to can news just use just learning will be they don't have the time or the ability to dig in a learned both object models and it encourages users they had wave the body's way Wilson images
so encourages them to not know what describing that are actually are do you didnt see the previous talk but and there's a lot of stuff that goes on inside those describes minutes basically says
here's the magic incantation duets so when you're a
beginner any visually advanced acknowledge is indistinguishable from magic things this o'clock so we'll now I need to rename my talk so I know that I
respect is magic so from the previous pose
from Myron he said the many people find it to be overkill and there is an added at a cognitive cost to these extra abstractions
indeed here are the raw numbers of that added cognitive costs don't bother grokking these numbers really visualize them and in the next slide for both on the floor online and the comments + code lines a lot of complexity
metric proportional how hard something is to test to debug or even understand here our spec is 6 . 6 times bigger this is the combined me of the
projects this is code plus comments and it's basically how much you have to read do understand each library and 8 . 5 times bigger it's akin to reading
Doctor Seuss verses James
Joyce and do like my Doctor Seuss font I think I think that really well so back to that added cognitive
cost and we see that it is not just
cognitive costs their performance differences as
well as all those abstractions reinventing
the wheel it has a real costs
here we have some fairly complex plots of the show the runtime and solid lines and the amount of memory allocated in dashed by the green lines are harbors passing the red lines are members of failing and the others are in between the and as you may notice there is a slight problem to these charts can anyone guess then i is the same scale so now you can see that this is a severe and painful difference between our specom test values have exponential growth in our spec runtime is always near 0 and many test memories linear is always lower or
Brian who cares passing our
spec is fast enough indeed actually reflect everything is brand rose as long as everything plays nice but what happens when it
is you have a but were you refactor or anything else goes wrong 1
oftentimes why refactoring stuff and I make a change and have a hundred tests fail all of a sudden you pay it the for
completeness the speed of the actual
assertions in both systems are purely linear this speed of running those
tests at that the method level is also linear and because the linear please
do not try to regain any speed by reducing examples are expectation to otherwise reducing the quality of the tests on if you
wanna speed up and has will always be faster than our spectrum must by definition so
switch to make test 1 where you can never ever refactor having bugs so in summary of
the day as long as the test I don't
actually care what you use is the best tool
for your job publish on the technical
merits of many tasks choose what works for you not because it seems
popular and oftentimes I hear
that they chose a respect because there's more documentation available for maybe there's fewer articles about me test because is less need for the MIT
just as much easier to understand you can read in a couple hours and understand it headed to so maybe many test
users on this maybe they're just busy getting stuff
done choose or works for you who knows
try you might like it after all of its
just really thank you can't How do we influence in blooms in hope
Beobachtungsstudie
Parametersystem
Twitter <Softwareplattform>
Stochastische Abhängigkeit
EDV-Beratung
Rechenschieber
Statistischer Test
Erwartungswert
Menge
Statistischer Test
Code
Rechenschieber
Vorlesung/Konferenz
Signifikanztest
Binäres Entscheidungsdiagramm
Virtuelle Maschine
Benchmark
Plug in
Physikalisches System
Abstraktionsebene
Gerade
Code
Dialekt
Wechselsprung
Einheit <Mathematik>
Einheit <Mathematik>
Erweitertes Übergangsnetzwerk
Mereologie
Vorlesung/Konferenz
Projektive Ebene
Gerade
Benchmark
Rechenschieber
Signifikanztest
Komponententest
Erweitertes Übergangsnetzwerk
Vererbungshierarchie
Schätzung
Klasse <Mathematik>
Meter
Vorlesung/Konferenz
Signifikanztest
Signifikanztest
Einheit <Mathematik>
Funktion <Mathematik>
Erweitertes Übergangsnetzwerk
Vorlesung/Konferenz
Information
Instantiierung
Code
Fehlermeldung
ATM
Subtraktion
Erweitertes Übergangsnetzwerk
Rechter Winkel
Mailbox
Vorlesung/Konferenz
Gleichheitszeichen
Resultante
Umwandlungsenthalpie
Soundverarbeitung
Parametersystem
p-Block
Code
Funktion <Mathematik>
Code
Vorlesung/Konferenz
Zusammenhängender Graph
p-Block
Schlüsselverwaltung
Funktion <Mathematik>
Ausnahmebehandlung
Wasserdampftafel
Aggregatzustand
Framework <Informatik>
Code
Signifikanztest
Arithmetischer Ausdruck
Existenzsatz
Design by Contract
Vererbungshierarchie
Vorlesung/Konferenz
Signifikanztest
Soundverarbeitung
Videospiel
Schreiben <Datenverarbeitung>
Fehlermeldung
Linienelement
Computersicherheit
Linienelement
Einfache Genauigkeit
Ausnahmebehandlung
Design by Contract
Existenzsatz
Framework <Informatik>
Wort <Informatik>
Fehlermeldung
Aggregatzustand
Unternehmensarchitektur
Parametersystem
Datensatz
Emulation
Erweitertes Übergangsnetzwerk
Rechter Winkel
Vorlesung/Konferenz
Design by Contract
Signifikanztest
Erwartungswert
Erweitertes Übergangsnetzwerk
Statistischer Test
Prozess <Informatik>
Schätzung
Momentenproblem
Klasse <Mathematik>
Vorlesung/Konferenz
p-Block
Subtraktion
Menge
Erweitertes Übergangsnetzwerk
Vererbungshierarchie
Formale Sprache
Klasse <Mathematik>
Vorlesung/Konferenz
Ähnlichkeitsgeometrie
p-Block
Integraloperator
Objektklasse
Code
Randomisierung
Signifikanztest
Ähnlichkeitsgeometrie
Gleichheitszeichen
Signifikanztest
Mapping <Computergraphik>
Erwartungswert
Negative Zahl
Freeware
Menge
Statistischer Test
Erweitertes Übergangsnetzwerk
Vorlesung/Konferenz
Störungstheorie
Default
Signifikanztest
Wärmeübergang
Schlussregel
Physikalisches System
Framework <Informatik>
Übergang
Einheit <Mathematik>
Erweitertes Übergangsnetzwerk
Parallelrechner
Programmbibliothek
Randomisierung
Gerade Zahl
Vorlesung/Konferenz
Thread
Ordnung <Mathematik>
Signifikanztest
Shape <Informatik>
Bildschirmmaske
Erweitertes Übergangsnetzwerk
Vorlesung/Konferenz
Vorzeichen <Mathematik>
Paarvergleich
Gerade
Code
Message-Passing
Erweitertes Übergangsnetzwerk
Fluid
Minimierung
Klasse <Mathematik>
Vorlesung/Konferenz
p-Block
p-Block
Äquivalenzklasse
Gerade
Code
Richtung
Fehlermeldung
Punkt
Güte der Anpassung
Automatische Differentiation
Code
Objekt <Kategorie>
Erwartungswert
Datenmanagement
Erweitertes Übergangsnetzwerk
Erwartungswert
Endogene Variable
Vorlesung/Konferenz
Lie-Gruppe
Koordinaten
Gerade
Modul
Fehlermeldung
Softwarewartung
Signifikanztest
Einheit <Mathematik>
Klasse <Mathematik>
Mereologie
Implementierung
Vorlesung/Konferenz
Plug in
Metaprogrammierung
Raum-Zeit
Framework <Informatik>
Computeranimation
Signifikanztest
Gefrieren
Versionsverwaltung
Schlussregel
Extrempunkt
Komplex <Algebra>
Hoax
Übergang
Einheit <Mathematik>
Statistischer Test
Erweitertes Übergangsnetzwerk
Vorlesung/Konferenz
Schnitt <Graphentheorie>
Schwaches Gesetz der großen Zahlen
Signifikanztest
Patch <Software>
Prozess <Physik>
Erweitertes Übergangsnetzwerk
Zahlenbereich
Vorlesung/Konferenz
Softwareentwickler
Parallele Schnittstelle
Gerade
Code
Signifikanztest
Patch <Software>
Zufallszahlen
Erweitertes Übergangsnetzwerk
Statistischer Test
Verhandlungs-Informationssystem
Randomisierung
Zahlenbereich
Vorlesung/Konferenz
Ordnung <Mathematik>
Ausgleichsrechnung
Signifikanztest
Eindringerkennung
Erweitertes Übergangsnetzwerk
Prozess <Informatik>
Güte der Anpassung
Versionsverwaltung
Vorlesung/Konferenz
Ordnung <Mathematik>
Synchronisierung
Programmfehler
Signifikanztest
Bruchrechnung
Architektur <Informatik>
Datenhaltung
Klasse <Mathematik>
Plug in
Aggregatzustand
Signifikanztest
Rechter Winkel
Erweitertes Übergangsnetzwerk
Vererbungshierarchie
Vorlesung/Konferenz
Computerarchitektur
Signifikanztest
Aggregatzustand
Computervirus
Framework <Informatik>
Bildschirmmaske
Datensatz
Transaktionsverwaltung
Bildschirmmaske
Einheit <Mathematik>
Deklarative Programmiersprache
Last
Programmbibliothek
Kategorie <Mathematik>
Vorlesung/Konferenz
Transaktionsverwaltung
Signifikanztest
Subtraktion
Gruppenoperation
Validität
Implementierung
Schlussregel
Strömungsrichtung
Code
Transaktionsverwaltung
Einheit <Mathematik>
Erweitertes Übergangsnetzwerk
Gruppe <Mathematik>
Gamecontroller
Vorlesung/Konferenz
Garbentheorie
Schlüsselverwaltung
Signifikanztest
Umwandlungsenthalpie
Architektur <Informatik>
Indexberechnung
Aggregatzustand
Lineares Funktional
Template
Service provider
Endogene Variable
Integral
Gruppenoperation
E-Learning
Erweitertes Übergangsnetzwerk
Konditionszahl
Ordnungsbegriff
Vorlesung/Konferenz
Maßerweiterung
Aggregatzustand
Signifikanztest
Architektur <Informatik>
Desintegration <Mathematik>
Güte der Anpassung
Aggregatzustand
Integral
Rechenschieber
Minimalgrad
Rechter Winkel
Reelle Zahl
Vererbungshierarchie
Gamecontroller
Vorlesung/Konferenz
Gleichungssystem
Fitnessfunktion
Randomisierung
Signifikanztest
Komponententest
Erweitertes Übergangsnetzwerk
Statistischer Test
Randomisierung
Leistung <Physik>
Vorlesung/Konferenz
Parallele Schnittstelle
Einflussgröße
Leistung <Physik>
Signifikanztest
Patch <Software>
Erweitertes Übergangsnetzwerk
Vorlesung/Konferenz
Framework <Informatik>
Weg <Topologie>
Minimalgrad
Punkt
Erweitertes Übergangsnetzwerk
Datentyp
Programmbibliothek
Vorlesung/Konferenz
Chi-Quadrat-Verteilung
Code
Signifikanztest
Bit
Erweitertes Übergangsnetzwerk
PASS <Programm>
Vorlesung/Konferenz
Ordnung <Mathematik>
Signifikanztest
Zufallszahlen
Erweitertes Übergangsnetzwerk
Kreisring
Bus <Informatik>
Randomisierung
Vorlesung/Konferenz
Teilmenge
Signifikanztest
Suite <Programmpaket>
Erweitertes Übergangsnetzwerk
Vorlesung/Konferenz
Euler-Diagramm
Softwareentwickler
Ordnung <Mathematik>
Ganze Funktion
Gerichteter Graph
Raum-Zeit
Fitnessfunktion
Signifikanztest
Erweitertes Übergangsnetzwerk
Pufferüberlauf
Statistischer Test
Versionsverwaltung
Programmbibliothek
Keller <Informatik>
Vorlesung/Konferenz
Wort <Informatik>
Plug in
Bildschirmsymbol
Datenfluss
Signifikanztest
Objekt <Kategorie>
Hoax
Erweitertes Übergangsnetzwerk
Mathematisierung
Vorlesung/Konferenz
Projektive Ebene
Ordnung <Mathematik>
Signifikanztest
Parametersystem
Erweitertes Übergangsnetzwerk
Physikalischer Effekt
Statistischer Test
Vorlesung/Konferenz
Signifikanztest
Aggregatzustand
Signifikanztest
Videospiel
Amenable Gruppe
Erweitertes Übergangsnetzwerk
Geschlecht <Mathematik>
Prozess <Informatik>
Güte der Anpassung
Vorlesung/Konferenz
Teilbarkeit
Standardabweichung
Signifikanztest
Metadaten
Subtraktion
Erweitertes Übergangsnetzwerk
Verkehrsinformation
Vorlesung/Konferenz
Eindeutigkeit
Signifikanztest
Brennen <Datenverarbeitung>
Framework <Informatik>
Subtraktion
Punkt
Benchmark
Signifikanztest
Physikalisches System
Framework <Informatik>
Erweitertes Übergangsnetzwerk
Verkehrsinformation
Parallelrechner
Nichtunterscheidbarkeit
Randomisierung
Vorlesung/Konferenz
Eindeutigkeit
Programmbibliothek
Objekt <Kategorie>
Bit
Erweitertes Übergangsnetzwerk
Zahlenbereich
Endogene Variable
Ruhmasse
Vorlesung/Konferenz
Computeranimation
Inverser Limes
Objekt <Kategorie>
Task
Erweitertes Übergangsnetzwerk
Gruppentheorie
Dezimalsystem
Minimalgrad
Vorlesung/Konferenz
Kantenfärbung
Fokalpunkt
Signifikanztest
Computeranimation
Objekt <Kategorie>
Metadaten
Klasse <Mathematik>
Versionsverwaltung
Gruppenkeim
Signifikanztest
Computeranimation
Erwartungswert
Perspektive
Statistischer Test
Gruppentheorie
Fahne <Mathematik>
Vererbungshierarchie
Meter
Kontrollstruktur
Vorlesung/Konferenz
Signifikanztest
Konstruktor <Informatik>
Siedepunkt
Güte der Anpassung
p-Block
Objektklasse
Objekt <Kategorie>
Gruppenkeim
Rechter Winkel
Erweitertes Übergangsnetzwerk
Ruhmasse
Case-Modding
Wort <Informatik>
p-Block
Tabelle <Informatik>
Inklusion <Mathematik>
Objekt <Kategorie>
Kraftfahrzeugmechatroniker
Vererbungshierarchie
Klasse <Mathematik>
Objektklasse
Variable
Computeranimation
Funktion <Mathematik>
Gruppenkeim
Erweitertes Übergangsnetzwerk
Formale Sprache
Gruppentheorie
Ruhmasse
Vorlesung/Konferenz
Term
Erweitertes Übergangsnetzwerk
Klasse <Mathematik>
Elektronischer Datenaustausch
Vorlesung/Konferenz
Flächeninhalt
p-Block
Objektklasse
Mini-Disc
Analogieschluss
Signifikanztest
Konstruktor <Informatik>
Erweitertes Übergangsnetzwerk
Vererbungshierarchie
Klasse <Mathematik>
Vorlesung/Konferenz
Modul
Signifikanztest
Analogieschluss
Trennungsaxiom
Objekt <Kategorie>
Informationsmodellierung
Erweitertes Übergangsnetzwerk
Vererbungshierarchie
Objektmodell
Hypermedia
Vorlesung/Konferenz
Modul
Signifikanztest
Gerade
Innerer Punkt
Erweitertes Übergangsnetzwerk
Wellenlehre
Objektmodell
Vorlesung/Konferenz
Bildgebendes Verfahren
Erweitertes Übergangsnetzwerk
Abstraktionsebene
Vorlesung/Konferenz
Abstraktionsebene
Atomarität <Informatik>
Rechenschieber
Erweitertes Übergangsnetzwerk
Code
Programmbibliothek
Zahlenbereich
Vorlesung/Konferenz
Projektive Ebene
Komplex <Algebra>
Gerade
Code
Gerade
Subtraktion
Font
Einheit <Mathematik>
Erweitertes Übergangsnetzwerk
Abstraktionsebene
Informationsverarbeitung
Vorlesung/Konferenz
Abstraktionsebene
Standortbezogener Dienst
Signifikanztest
Zentrische Streckung
Stereometrie
Subtraktion
Festspeicher
Rechenzeit
Vorlesung/Konferenz
Plot <Graphische Darstellung>
Gerade
Signifikanztest
Eindringerkennung
Erweitertes Übergangsnetzwerk
Vorlesung/Konferenz
Lie-Gruppe
Erwartungswert
Vervollständigung <Mathematik>
Erweitertes Übergangsnetzwerk
Erwartungswert
Vorlesung/Konferenz
Physikalisches System
Vollständigkeit
Punktspektrum
Übergang
Task
Signifikanztest
Erweitertes Übergangsnetzwerk
Vorlesung/Konferenz
Trägheitsmoment
Programmfehler
Videokonferenz
Signifikanztest
Bit
Erweitertes Übergangsnetzwerk
Vorlesung/Konferenz
Sichtenkonzept

Metadaten

Formale Metadaten

Titel Ruby on Rails on Minitest
Serientitel RailsConf 2015
Teil 61
Anzahl der Teile 94
Autor Davis, Ryan
Lizenz CC-Namensnennung - Weitergabe unter gleichen Bedingungen 3.0 Unported:
Sie dürfen das Werk bzw. den Inhalt zu jedem legalen und nicht-kommerziellen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen und das Werk bzw. diesen Inhalt auch in veränderter Form nur unter den Bedingungen dieser Lizenz weitergeben.
DOI 10.5446/30700
Herausgeber Confreaks, LLC
Erscheinungsjahr 2015
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract The rails "official stack" tests with minitest. Each revision of rails peels back the testing onion and encourages better testing practices. Rails 4.0 switched to minitest 4, Rails 4.1 switched to minitest 5, and Rails 4.2 switched to randomizing the test run order. I'll explain what has happened, explain the motivation behind the changes, and how to diagnose and solve problems you may have as you upgrade. Whether you use minitest already, are considering switching, or just use rspec and are curious what's different, this talk will have something for you.

Ähnliche Filme

Loading...