Please enable JavaScript.

Coggle requires JavaScript to display documents.

Art of Unit Testing (K1 (Definitions (Legacy code (“source code that…

- - - - a piece of a code (usually a method) that invokes another piece of code and checks the correctness of some assumptions afterward. If the assumptions turn out to be wrong, the unit test has failed. A unit
        is a method or function
    - - system under test,
    - - class under test or code under test
    - - is the sum of actions that take place between the invocation of a public method in the system and a single noticeable end result by a test of that system.
    - - returns a value (a function that’s not void).
    - - can span as little as a single method and up to multiple classes and functions to achieve its purpose.
    - - a piece of code that invokes a unit of work and checks one specific end result of that unit of work.
      - A unit test’s scope can span as little as a method or as much as multiple classes.
      - UPDATED AND FINAL DEFINITION
        
        s an automated piece of code that invokes the unit of work being tested, and then checks some assumptions about a single end result of that unit
        
        almost always written using a unit testing framework
        
        can be written easily and runs quickly
        
        trustworthy
        
        readable
        
        maintainable
    - - Code changes regularly during the life of an application, and if you can’t (or won’t) run tests for all the previously working features after changing your code, you just might break it without knowing
      - seems to occur a lot near the end of a software project
    - - one or more units of work that once worked and now don’t
      - Few things are scarier than not knowing whether the application still works, especially when you didn’t write that code. If you knew you weren’t breaking
      - anything, you’d be much less afraid of taking on code you’re less familiar with, because you have that safety net of unit tests.
    - - “source code that relates to a no-longer supported or manufactured operating system or other computer technology,”
      - It often refers to code that’s hard to work with, hard to test, and usually even hard to read.
      - “code that works.”
      - “code that has no tests.”
    - - any piece of code that has some sort of logic in it, small as it may be
      - if statement
        
        a loop
        
        switch
        
        case
        
        calculations
        
        any other type of decisionmaking
    - - changing a piece of code without changing its functionality.
  - - - automated and repeatable.
      - easy to implement.
      - relevant tomorrow.
      - Anyone should be able to run it at the push of a button.
      - run quickly.
      - consistent in its results
        (it always returns the same result if you don’t change anything between runs)
      - full control of the unit under test.
      - fully isolated (runs independently of other tests).
      - When it fails, it should be easy to detect what was expected and determine how to pinpoint the problem.
    - - Can I run and get results from a unit test I wrote before
      - Can any member of my team run and get results from unit tests
      - Can I run all the unit tests I’ve written in no more than a few minutes?
      - Can I run all the unit tests I’ve written at the push of a button?
      - Can I write a basic test in no more than a few minutes?
  - - - one or more real dependencies of the units under test
      - integration tests are important counterparts to unit tests
      - increase the risk of another problem: testing too many things at once.
    - - integration testing is “an orderly progression of testing in which software and/or hardware elements are combined and tested until the entire system has been integrated.”
    - - a unit of work
        
        without having full control over all of it and using one or more of its real dependencies
        such as time, network, database, threads, random number generators, and so on.
      - unit tests
        
        isolate the unit of work from its dependencies so that they’re easily consistent in their results and can easily control and simulate any aspect of the unit’s behavior
        
        an integration test
        
        uses real dependencies
  - - - writing unit tests before the production code is written
      - a way of designing
        
        a way to drive your code’s behavior with only some design.
      - Tdd Vs Traditional Development
      - The technique of TDD
        
        Write a failing test to prove code or functionality is missing from the end product.
        
        Make the test pass by writing production code that meets the expectations of your test
        
        Refactor your code