Merken

TDD for APIs

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
OK so it's what's on yeah I of next 45 minutes gonna talk about has test involve by the BIC just a quick summary to
get to know each other who's already hungry like me OK good and I'm not the only 1 so you might say here's some from my stomach here of rich this way more important if you lose the media was sets from development OK some OK so maybe it's not necessary to get to some point in more detail OK U of URIs for me was piped has also been up for me was tested developments so because most of my examples will be entitled just that you can maybe I should just throw in some questions something like clear and what about your experience API OK most of and that's good cool so you all API experts on this this has relevant guys already achieved the great API using tested involvement OK none of you all go into Leo Wanner from better regularized that's cool yeah that's so so you can go the law of common people so that that's not just a quick
introduction that's me and so I am in that way OK so I'm markets you know from homogeneous might you from excellent iridescent independently of opened new year and like and at the i-th multiple projects are related to the ice that actually reason why I came up with this talk of course some projects were try to do some tests staff and the stadium next project we start from scratch again so this talk based on my experience and express your my last project where we starting from scratch doing everything possible and so we figure out pretty soon that we were doing it's somehow intuitive right but it wasn't really test-driven development as you might find in the book so I sold OK what we're really doing want to be able to repeat them and of the incident to find kind of a systematic approach or maybe the science behind what we were doing and the yeah that's the basement of this talk 1st of all we ask
all solves this question from the whole to be welded all outliers what you said that the quality of the public if you don't know what technology later I got up and that this was a definite questions we try to capture tackle but if we want to well at the age of that all I can working as intended we should make sure what was really working as intended what's the intention we have so before we can start was beating the odds of what we re doing what should however API get as an input and then we craft and what's so it's supposed to be the response right so what some metrics might happen in the middle somewhere around but we saw no problem with developers so what we wanna do when we want to validate something for sure we write test and if we do that 1st of all we can call the test envelopment that we actually cool that's also that's the of internal presume that was that easy to on and it wasn't revealed all was kind of a pain in the ass to applying this setting
has been developed cycle you probably all know all of tool for our project Chris we were trying to to write unit tests that 1st of all for sure we write failing unit tests then we try to make it past to some refactoring and goes so the cycle over and over on but that's why 1 away after we started agree on what what we're we're doing right now year of what is so the units here and we got visitation from all clients and was more like OK we want have all this input when I have this all quota so we're kind of stopped because we were attacking the question what is really all unit and how can we turn our specification into test and that we might be somehow come on this do you use that discussion some of you might know about between and they have a common ancestor there's a lot of talent can back and to not familiar so this discussion current cost David states that he you can process design damage when you're really focusing on some on the inside and you leave out the bigger picture and got the money go to go into that in more detail about this is actually what I felt that we were focusing so much on the inside that we missed out solely what's really going on to select I because the the the the i something which going on more from the outside to the inside a lot like here that you going from the inside to the outside the because when you're building an API your or architecture and I look like
this this is an example of digital media structurally different but I just want to all lined that when you're when we talk about it I will have several types of clients variable what clients in page applications some services whatever and behind that different kinds of client we have lots of lots of layers it's not the API it's just so that you can
might be due to fraud and that was all clients will see as behind on the underneath is this API we have a business logic may be really pleading with asynchronous task using message Chubais salary and if use gender we might have all I am I or some of our historical role and stuff like that notification system we had just 1 glance sports with road triggering some external services so some real stuff's going on everywhere lots of talking in both directions so that's kind of horrible to the test of 1 way to do that stuff believe that you more everything that you go back to your old that to do so TD approach right you have this isolation this isolated units of the you know I don't have to think about what's going on over there what's going on over there and you can just focus on your current unit but I highly recommend notes to isolate your it's it's warm the natural so what we did is everywhere mole focusing on from the outside to the inside and that's actually pretty easy when you when we talk about the ice because closing important key ideas as already
mentioned that we have to find out what can we do with this you know in but this just so as as soon as an example for an API requests this slide projectors talk about what may books provided so that was despised and using their example and pointed out of but but if we haven't defined input all response immediately find all pulled of it's pretty pretty easy to use to build task so that if you were to look at the bigger picture and if you really want this you focus from the units in Europe focusing that's my input I really implement the behavior of a and I will turn this into a specified all told this probably where more than just the student was also we had some really really huge so that's presentation with lots of error codes and also some more details of what we should implement but you can that we do that was to be the 1 that you can apply you test the for MPI I think if we look at the different kinds of tests we have we should maybe we think what we would really doing with all test this to define this is a little like logged on there the kind of and also the first one is unknown but it's more about the when we focus and unit tests we're focusing on culture that we want to call correctly that we know that we went in that the cold light of and that's something important that we make sure that we do that we're comparing all dictionaries correctly or whatever we that we are more the input to the implementation the basics but in the right way but we'll talk about it always we might have a client and this time this of maybe the the office next door or it so that if you look at the public key idea you you might know your clients and the nature that if you go back to the example from this site for that enable this created by in the right way but if there's some error deep inside of you should just like no he doesn't really care about that it's it's more quality just getting a job done give the results and I have no idea what's going on so that some magic that supply costs so the acceptance tests they come from that we really built the right so so that you build the right guy for clients so if you're focusing too much on your next on the unit test of something like
this might happen that everything is correct you build the directly right codes and so you have no arrows you wrote about tremendous amount of of unit test but it's not working you OHT-eyes doing the wrong thing and your client is arguing what's going on you and so we should make sure that we recover all specification with all tests and that's in in general would be talking about that's end-to-end testing by accepts as the way more of have not just integration test where you go from 1 side to the other side and
we also had some acceptance tests which were awarded through the oriented for example we have some special requirements Hall of an e-mail address in should be checked the that's available not of maybe you have some requirements to check if your the images blackness all traced by the NSA whatever so there are various levels what you really can't check was if you turn your specification into an internet access so it's not just that enters the functional testing the test and if you don't was there and covered the specification of your own object then you can go to the next step and see what more what we can How can be validated we right the correct Croats and that brought us to
and also like some of you might know the cycle behavior-driven development and this then also came up with the cycle a couple of years ago so it's kind of similar to what we did we did we haven't done the DVD but use a cycle the so what we did is that we turned all the whole specification into acceptance tests so we wrote 1st of all a tremendous amount of acceptance tests to fulfill the specifications which ever could should determine if we got this request and so also all we have elegant validate existing addresses whether relevance all this stuff and after we discovered this of the sample and then we went to the next step so it's OK maybe it makes sense to make sure that we really do the assertion of all input in the right way so we at some of the test of more on all levels how we think that it makes sense to to to increase the of the task coverage there and then we started to make the past so was a long way to get everything reading but that's it has paid out any answers really we're we're able to make sure that we that the red right at the Ohio and stuff that we were able to refactor over all or columns altogether on going getting away from the from what our client expects and may maybe if you do some of uh maintenance within you already have been released directly I have some of those and then points that's pretty important that you stick to Europe and implementation that you don't change the behavior of the dialog with the cycle of told able to make that was modeled effort definitely we did this just was part has been used broken that so the the sentence so that domain-specific language right you can write a test more uniform but not all of the most just just development team will all everyone was developed project managers sort of carriages we always thought it would make sense of the use of a broken for that so we wrote test like that and we ended up with countless numbers of its performance 12 months projects so we wrote a lot of tasks not 100 per cent accurate was around 3 solving tests of to solve and unit tests so we had a lot of additional test which branch really requires by our specification but it was still necessary to to all of the moment cycle after we we completed the x-axis test cycle and the boots a tremendous amount of Titus features to do that and of course the wavelets you create oral test digital in a deterministic way and that brings us actually to the next slide of our test on actually just so equation all yeah I would just 1 that's all pretty and pretty pretty because it's definitely project related and that might not work for everyone but thing at least as points might be and the other what we do is that we isolate all the integration test on a different project and we the course we will we want to make sure that it's not possible to sneak around and to you call the function in a way you're not supposed to do it you develop post doesn't doesn't have to be mean of but maybe they're they're tired and they a way around and then not testing in the way it's supposed to be you put all your stuff and separate project this normal weight you have to do it in the right way you have to call the API of if you did was public API what I didn't do another project was it's a really good idea that you all the tests you just with your with yes OK as Sokaiya shipping to clients you should that we also have some tests with all this basically so because also something you immediately have to test but you should bring yourself in the same position as supplier when testing or when he's using your API that you can definitely validated the Catholic kind of kind of a a picture of the reality that's all imagine and what you're really doing we could be the normal task but the function test test that we normal test project but we use that impact as for that of probably at all the different talk it's not attributed to shift your stuff and then effect but if you already tried to do that and Europe the copper tools that read some really good experience to capsule all dependencies and and then pictures to make sure that we can really isolate all integration tests but in no action also the other except the set but we're all but that the kind of the wanna go into that in more detail of what we also do this every just external sources we were in a situation using OK maybe it's cool we mock the all 1 there are also some other end points reusing it inside of API inside following ecosystem around but we decided that we not doing that but course if we were walking in some of the we might have a it's easier to test but we also all using condoms yes some of them are information when we when we are testing all the US that stuff so it's difficult to really give some advice already signed all tests are but what we so I had to do do not all the time is to test from the beginning to the end so if you test your business logic go from this object down to
database don't walk sum of some layers on the underneath and if you testing Europe jointly test from the at that down all layers so that you're not giving something but also the use of historical examples that we will talk about a minute use the whole the whole layers it's coming that means a lot of tacit effort you have to do but if you do that you can make sure that this whole communications working process lot talking going on between all those there's some you might know the 1st principles of the principle of which tried to apply that for all test it stands for a lot of fast isolated of a repeatable said horrified time the test so that you should go design you test them that way of it kind of wrote for all test but not 100 per cent of especially
the 1st point fast of In the end we we have some of the issues thing was that 2 of get out test for environments set out to almost 1 to 2 seconds protests that's kind of various if you run into some tests we we're able to optimize the but was of the sticking points to wanna create and deterministic environment that you and you have some more complex of of stuff going on that you're still on time and so during this past it's not that easy on finally we ended up with about 45 minutes for this this result something that's stood doable that to do that each time if you do that continuous integration you will have to run the test of time but we the only and yeah base the isolation of yet talked about this already we mortgages external services so we isolated so that you know everything single isolated ourselves from the outside but not from the inside but was later to make it repeatable to create an deterministic environments was using a type of features and they suffer refined yes it's kind of obvious that just means that you're going to sort of this stuff you want to test the inside of the tests on the T 2 times the In the 1st of all when we started this was definitely 80 % writing test code on 20 % writing and production code but it should be all the time so I don't know if we are pretty quick setting up new tasks and getting it running and we can focusing more on the production code on that 7 pretty good on the yet to do that we do not have classes and to make possible we'll yeah we are able to you use this have a class for part of teachers to create eudaemonistic environment and the other the 1 goal that much into the features because rest really much related to go to the project and its but we cleaned all database in all and was pictures and create a lot of have what we also that was pretty easy actually I just figured out doing a project that you can test a version and points of very and he was despite its actually that's something I just want to talk about pretty quick it's
Europe was using the chain restaurant for example and you're roads and you and points of you might have this words class where you have a set of all the rows and points and was fighters you can just parametrized you test where you just create a list of the sets and put every and every item of this of this of this into your Paramita inside of the test so that you're able to test every and
every inversion and when that's actually pretty cool you rows and you end points of picture I highly recommend to words input instead of EC I did it any other way as well but on the other hand I felt it's easier to test that you just wrote in the end points and the like this you can see that make sure that you know and what's the behavior it's supposed to be used to because you normally don't copy Europe crawled many words and then on the business logic underneath your API it's supposed to be still say it's not you probably doing something mysterious and it's supposed to be in new point I guess we also what was a
lot of asynchronous behavior so I showed you all this constant Logitech's and beginning and there was actually 1 layer of complexity and I would say bring it brought a new dimension of complexity in our project and when we were making our API asynchronous when I mean by that is that when you when a client is talking to an end point this end point and start to settle task so it starts its schedules a task in some methods humans is going to be processed later on by the work of but we have to respond to our client immediately so you have a delta between the response and the reprocessing and you should make sure that you know how to deal with that of course is still a lot of talking going on and that the client will wait for your for the processing of but we
give like this and 1st of all if he do that the where cash and I spent nights so with the scarcity of resources sketch is you of of so we can restrict transaction and
use of that can be dangerous if Europe not of creating your transaction on the amount of we haven't done that all the time so sometimes you might end up with some mysterious response and you sort of she should get something totally different but yeah you and points the caption summary can be tricky but what we actually do to make this happen to creators asynchronous acheived about developing the import 1st and to make sure that from this state we have right now of everything is right and the channel response was and correct error resident correct successful to our clients and then we started job what about between this we have to stand on and the this also this the time that between the processing and the of the validation tricky that's something you you should really be reopened with test the test of this in various ways testing some of some values kind of the the boundaries of so what's happening before this before we cast this time that I want something off the roads and so that you're still able to handle in your process of your data or any of the data the state of the data exchange between the validation and now the 2 of the and it's you know validate this in Europe and your test it's necessary that you might be able to access the asynchronous results of the tests we wrote some have of funds for that but it's actually not that difficult show I'll show you an example in a minute of because what we also did that we have waited for all of asynchronous task every test so what we did is we had the a feature called working database which using every test this was this picture was doing kind of be the set up the base set up for before the testing database and creating also some stuff in this picture also waited for all test which all tasks which still running if we're in a situation where we needed some special results of of of test the task we also rated at the end of of this test for this task we have to get to the Prežihov class
actually have a of and you can just grab your results from the from the set of tasks and yeah collect them and get them back on what we just did the simple method which is slated for them that every task response the results in yeah and so this ceteris thing brought us but also a
tremendous amount of more test cost we run the situation that we not just testing our business logic and a widely we we also have to test all summary task and but that was not that bad costs we which is a would doing this was some titles of the reach pyrrhotite stuff that we were able to test the theory task and the task is also really in 1 test and that's definitely 1 single I recommend when you do that that you just using practice for that cruiser otherwise we would probably end up with way more than resources that we would write a test for each of this layer ah but if you do this test you right all the tests are this doesn't mean that you really write a good the if you especially sophistication was still on the whole and you doing tests development but it won't turn your Europe specications something also that and that brings me to a quarter
of a like a lot from can back that the testimony relevance of won't make you design good about it can help you to watch that design and think that's something would be did was all test development approach that we knew what we want to have we were really invested a lot of time the specification the beginning and then we make sure that we can we achieve of indeed and so on we we did that there was some yeah and some various race and maybe you heard about the the most common human work that's something that what's across the some yeah actually some nice to growth of the economy numerous states that your organization tends to you produce Socrates this looks like innovation for your own communication structure and this caused some unintended friction points and yet you don't want to happen at TI that looks like your organization only underlying system on you want really happen at TI that's yeah that's a product to customers use all that stuff the BAT you develop so we're designing alright on knowledgeable inside all development team and there actually were saying OK what we're really doing that that the API we wanna use but what about the guys sites will that really useful API so from my point of view it's pretty important that you that encourage your your holds even also some of the guys responsible for the business side and some of the some develop a small set of development team to bring input to the design the year award that you're just those big in neural small narrow you and created designed that really looks like always you communicate between your all layers in between your own organization that you get some input from outside and if you do that and if you have the specification was talking I'm talking about the whole time then you owe it to achieve the great sophistication great great designed was test and that's actually kind of the and was coming into whether that you have achieved from the desired design so yes so I already mentioned API most thing from the outside so we would it took us a while but we were the of sometimes with the focusing what's going on outside and then we will try to of all the design from the from the also the user doesn't mean that you're that you're doing some of the rest equals crops all stop all that during that you databases looking directly like the applied that doesn't mean that but you should make sure that the Europe designing an API which and the needs of the city I are observed by the database and your layers underneath it and and if you do that so few of them get you writing all the steps you can make sure that you can that reflector of resulting you behaviors would which is pretty helpful when you especially development of public API and I already mentioned the diversion importance be of I figured out once that I still have a version and point out I forgot actually and when we look into so picture I showed that this yeah can be that can be tricky and of their speed of adjustable left so I would like to show you my lessons learnt on 1st of all I mentioned a couple of times you need if you really want to build a great if you wanted to test the development for the i think about specification 1st make a red specification if you have a great specification with your business on the side and with some extra on developers may be something that's from other teams you will Have a great these which comes from outside of yeah don't forget you were an endpoint and don't underestimate the effort you will will need to test the asynchronous behaviors and yet if you really needs asynchronous behaviors in the eyes as we of the of plan then some exercise of course we didn't and that's the reason why it took us about 12 months to finish this project and the number of points that the that also complexity which we brought into this project make it more and more difficult to create immediate deterministic environments which is stepping necessary when he want to do you some tests from development and we you want to test it in the right way yeah that's that's sense a lot and you have 3 government for a giant the future
consumers from constant here and you mentioned statistics solutions from widely used so the only part of actually like the use of and by the summary of of analysis of the question the the question is why didn't use celery it's merge the 2 sources this but why why we have a Synchronous behavior and I can use the but longer so the idea is that this is distillery has moved who lives each year which to all this behavior yeah I'm wondering why you can locate the source and that I mean if we create our own test environment in synchronous way it won't we presented our our environment which we haven't production so you it's only right that we could do all this stuff in synchronous way and we kind of created a synchronous environment by writing a lot of help classes and using this additional features to do that and so on we did that cost but if we just about triggers which make it synchronous but it's some that's not our application in more and we would have a different behavior and actually we were interesting in and testing what's really going on the real world that's what we did that but Italy what would be probably easier way to do that the I want to see the reality of announced on here the roads you beforehand acceptance tests were not functional requirements is sometimes non-functional requirements to the and the movement of performance of the system at this year's problems with OK so so the you actually lied but you want response time to be less than 3 seconds so that students have sisters not necessarily its function doesn't not necessarily have started to see the response of the not performance sometimes we think leads about those problems so instance when was this situation if you have a new experience of the of performances issues are definitely told different task really we put all this is the performance that outside of foreign and number tested we had some of actually we had some keep the ice for those special endpoints beautiful flow but of and that was not part of how we did this testament to we wrote of all endpoints the 1st this is cycle I showed you and off the roads the and we wrote some performance tests of course we're also waiting for some additional information what we are KPI stop are from but here we had to do that but to do that the inside of the cycle which is make cycling more longer but maybe it's in it's possible to integrate out of the 7 a point which is also important for the design of some way yeah right I'm dimensions of the role the you writing more test the production of the prime eventually the transition to more production test test you also mentioned that project you about 12 months to right can you tell me what pulling along the along the transition on 0 point when more than 50 % production time so from that stuff that past question I should look into my commit list of the the just like it because I don't know I can really tell you that it's when we started off to have that kind of the basic set of the features we need all the time and for example made this that standard a domain for books and also the the handlers to make sure how we you with salary and how we are able to create our own environment forest this talks probably yeah a couple of weeks to do that and then we had to implement in something totally different and you end point so it was like you we finish this for 1 end point and then we had to he with some totally different points but we have this of this issue again where we had to start off and so to create a new feature so it was not really a straight line but maybe it's like this if you do this for a full week for 1 and point and then it's getting way faster and then you go to the next and point you have the slow period and then you get more into than can speed up so it's probably depends how we implemented API for us it was not definite not a straight line to break and say OK we did that for all 3 months and then every single school we use speeded up and we were able to finish on time that's not but the from memory and time from movements in the Clinton among them the
Expertensystem
Punkt
Menge
Hypermedia
Vorlesung/Konferenz
Softwareentwickler
Gesetz <Physik>
Computeranimation
Softwaretest
Linienelement
Stab
Einhüllende
Ein-Ausgabe
Inzidenzalgebra
Computeranimation
Portscanner
Software
Ausreißer <Statistik>
Dämpfung
Menge
Rechter Winkel
Test-First-Ansatz
Endogene Variable
Client
Projektive Ebene
Softwareentwickler
Stochastische Abhängigkeit
Brennen <Datenverarbeitung>
Logik höherer Stufe
Subtraktion
Komponententest
Datenmanagement
Schreiben <Datenverarbeitung>
Kartesische Koordinaten
Dienst <Informatik>
Computeranimation
Homepage
Homepage
Client
Task
Einheit <Mathematik>
Softwaretest
Datentyp
Mobiles Internet
Softwaretest
Umwandlungsenthalpie
Strömungsrichtung
Ein-Ausgabe
Einfache Genauigkeit
Warteschlange
Neue Medien
Bildschirmmaske
Dienst <Informatik>
Dreiecksfreier Graph
Elektronischer Fingerabdruck
Ablöseblase
Client
Projektive Ebene
Computerarchitektur
Refactoring
Modelltheorie
Prozesssimulation
Resultante
Web Site
Subtraktion
Komponententest
t-Test
Datenmanagement
Implementierung
Dienst <Informatik>
Kombinatorische Gruppentheorie
Mathematische Logik
Computeranimation
Homepage
Richtung
Task
Message-Passing
Client
Softwaretest
Task
Einheit <Mathematik>
Prozess <Informatik>
Code
Endogene Variable
Mobiles Internet
Beamer
Softwaretest
Fehlererkennungscode
Datentyp
Physikalisches System
Ein-Ausgabe
Einfache Genauigkeit
Office-Paket
Data Dictionary
Warteschlange
Teilmenge
Rechenschieber
Software
Bildschirmmaske
Dienst <Informatik>
Uniforme Struktur
Funktion <Mathematik>
Geschlecht <Mathematik>
Rechter Winkel
Ein-Ausgabe
Elektronischer Fingerabdruck
Client
Modelltheorie
Message-Passing
Softwaretest
Umwandlungsenthalpie
Komponententest
Adressraum
IRIS-T
Übergang
Computeranimation
Integral
Übergang
Internetworking
Teilmenge
Objekt <Kategorie>
Quader
Metropolitan area network
Client
Softwaretest
Codierung
Zeitrichtung
Bildgebendes Verfahren
Punkt
Komponententest
Prozess <Physik>
Gewichtete Summe
Momentenproblem
Desintegration <Mathematik>
Wavelet-Analyse
Adressraum
PASS <Programm>
Gleichungssystem
Kartesische Koordinaten
Extrempunkt
Computeranimation
Übergang
Client
Softwaretest
Datenmanagement
Umwandlungsenthalpie
Softwaretest
Lineares Funktional
Addition
Datenhaltung
Programmierumgebung
Testdaten
Quellcode
Ein-Ausgabe
Rechenschieber
Teilmenge
Softwarewartung
Rechter Winkel
Digitalisierer
Elektronischer Fingerabdruck
Client
Projektive Ebene
Information
Lesen <Datenverarbeitung>
Telekommunikation
Gewicht <Mathematik>
Ortsoperator
Gruppenoperation
Zahlenbereich
Implementierung
Dienst <Informatik>
Mathematische Logik
Task
Stichprobenumfang
Softwareentwickler
Trennungsaxiom
Booten
Verzweigendes Programm
Validität
Domänenspezifische Programmiersprache
Quick-Sort
Integral
Objekt <Kategorie>
Bildschirmmaske
Uniforme Struktur
Dreiecksfreier Graph
Mereologie
Normalvektor
Resultante
Punkt
Klasse <Mathematik>
Versionsverwaltung
Schreiben <Datenverarbeitung>
Komplex <Algebra>
Code
Computeranimation
Task
Datensatz
Softwaretest
Datentyp
Softwaretest
Universal product code
Datenhaltung
Zwei
Kontinuierliche Integration
Einfache Genauigkeit
Mailing-Liste
Programmierumgebung
Testdaten
Objektklasse
Quick-Sort
Bildschirmmaske
Dienst <Informatik>
Verkettung <Informatik>
Menge
Mereologie
Projektive Ebene
Wort <Informatik>
Programmierumgebung
Punkt
Hausdorff-Dimension
Datenmanagement
Dienst <Informatik>
Komplex <Algebra>
Mathematische Logik
Computeranimation
Task
Message-Passing
Client
Datensatz
Task
Endogene Variable
Statistische Analyse
Umkehrung <Mathematik>
Singularität <Mathematik>
Ein-Ausgabe
Objektklasse
Warteschlange
Scheduling
Bildschirmmaske
Elektronischer Fingerabdruck
Client
Projektive Ebene
Wort <Informatik>
Modelltheorie
Versionsverwaltung
Informationssystem
Caching
Resultante
Softwaretest
Deltafunktion
Prozess <Physik>
Datenhaltung
Klasse <Mathematik>
Validität
Datenmanagement
Quick-Sort
Computeranimation
Task
Datenaustausch
Randwert
Transaktionsverwaltung
Client
Task
Softwaretest
Prozess <Informatik>
Ein-Ausgabe
Parametersystem
Endogene Variable
Fehlermeldung
Aggregatzustand
Arithmetisches Mittel
Softwaretest
Task
Resultante
Task
Menge
Endogene Variable
Softwareentwickler
Mathematische Logik
Physikalische Theorie
Computeranimation
Punkt
Spiegelung <Mathematik>
Reibungskraft
Versionsverwaltung
t-Test
Kartesische Koordinaten
Kardinalzahl
Komplex <Algebra>
Synchronisierung
Computeranimation
Softwaretest
Vorlesung/Konferenz
Gerade
Umwandlungsenthalpie
Softwaretest
Lineares Funktional
Statistik
Sichtenkonzept
Datenhaltung
Programmierumgebung
Quellcode
Ein-Ausgabe
Biprodukt
Frequenz
Arithmetisches Mittel
Teilmenge
Menge
Rechter Winkel
Festspeicher
Projektive Ebene
Information
Programmierumgebung
Instantiierung
Aggregatzustand
Standardabweichung
Telekommunikation
Web Site
Selbst organisierendes System
Hausdorff-Dimension
Klasse <Mathematik>
Gruppenoperation
Automatische Handlungsplanung
Zahlenbereich
Task
Domain-Name
Endogene Variable
Response-Zeit
Datenstruktur
Softwareentwickler
Hilfesystem
Analysis
Wald <Graphentheorie>
Zwei
Mailing-Liste
Physikalisches System
Datenfluss
Portscanner
Rückkopplung
Dreiecksfreier Graph
Mereologie

Metadaten

Formale Metadaten

Titel TDD for APIs
Serientitel EuroPython 2015
Teil 51
Anzahl der Teile 173
Autor Kuehne, Michael
Lizenz CC-Namensnennung - keine kommerzielle Nutzung - 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/20161
Herausgeber EuroPython
Erscheinungsjahr 2015
Sprache Englisch
Produktionsort Bilbao, Euskadi, Spain

Technische Metadaten

Dauer 41:27

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Michael Kuehne - TDD for APIs It is always tough to test a complex API comprehensively. The additional level of complexity brings us to the question "How can we validate that our API is working as intended?" In this talk I will explain how to use test driven development for APIs to solve this problem and even further how TDD can drive an API Design towards a more usable design. I will outline my practical approach with an implementation example based on django. And finally I will give you a brief summary of my lessons learned using this approach in customer projects.
Schlagwörter EuroPython Conference
EP 2015
EuroPython 2015

Ähnliche Filme

Loading...