Everyday Unit Testing

  • Home
  • Courses and Workshops
    • Unit Testing and TDD
      • Introduction
      • TDD Deep Dive
    • Clean Code
      • Clean Code
      • Clean Tests
    • Microservices and APIs
      • API Automation Testing for developers
      • API Testing With Postman for Testers
      • API Testing With Spring
      • Introduction to Microservices Architecture (NEW!)
      • Exploratory API Testing with Postman
    • BDD
      • Introduction
      • Deep Dive
    • Mobile Developer Testing
      • Introduction to Testing with React Native
    • Agile
      • Agile Estimation and Planning
  • Events
    • Upcoming Events
    • Next Webinar: API Test Planning Live!
    • Past Events
  • My Books
    • Everyday Unit Testing
    • Everyday Spring Testing
  • Downloads
    • API Testing Plan Template
  • Blog
  • About Gil Zilberfeld
  • Contact
    • Contact
    • Mailing list registration

Testing

The Power of Testability Compels You (Not)

Once more I get into a training session on unit testing, and once more I hear “It feels wrong to change my code just for testability.” My immediate reaction was “because the design you have right now is so good, right?” (yes, I said it out loud). Let’s break it Read more…

By Gil Zilberfeld, 8 yearsMarch 9, 2015 ago

Unit Test, System Test, Red Test, Green Test

We tend to categorize different types of tests according to what they cover. Unit tests cover small portions of code, usually a method or a class, while we mock the rest of their interaction. Integration tests cover several components in concert, and then mock the other boundaries. System tests and Read more…

By Gil Zilberfeld, 8 yearsFebruary 25, 2015 ago
Gil Zilberfeld points to one of the refactoring patterns in unit testing and unit tests that makes legacy code more testable.

Legacy Code to Testable Code #6: Add Overload

This post is part of the “Legacy Code to Testable Code” series. In the series we’ll talk about making refactoring steps before writing unit tests for legacy code, and how they make our life easier. Other posts include:   In the last post, I’ve talked about Extract Class refactoring pattern, Read more…

By Gil Zilberfeld, 9 yearsOctober 28, 2014 ago
Gil Zilberfeld points to one of the refactoring patterns in unit testing and unit tests that makes legacy code more testable.

Legacy Code to Testable Code #5: Extract Class

This post is part of the “Legacy Code to Testable Code” series. In the series we’ll talk about making refactoring steps before writing unit tests for legacy code, and how they make our life easier. Other posts include: A few years ago I got this from Erik Talboom: “A private Read more…

By Gil Zilberfeld, 9 yearsOctober 24, 2014 ago
Gil Zilberfeld points to one of the refactoring patterns in unit testing and unit tests that makes legacy code more testable.

Legacy Code to Testable Code #4: More Accessors!

This post is part of the “Legacy Code to Testable Code” series. In the series we’ll talk about making refactoring steps before writing unit tests for legacy code, and how they make our life easier. It continues the last post on accessors. Other posts include:   We talked about refactoring Read more…

By Gil Zilberfeld, 9 yearsOctober 20, 2014 ago
Gil Zilberfeld's post in the "Legacy Code to Testable Code" on refactoring legacy code for unit testing and unit tests.

Legacy Code to Testable Code #3: Adding Setter Accessors

This post is part of the “Legacy Code to Testable Code” series. In the series we’ll talk about making refactoring steps before writing unit tests for legacy code, and how they make our life easier. Other posts include: Adding accessors to private state data is an admission that either our Read more…

By Gil Zilberfeld, 9 yearsOctober 17, 2014 ago
Gil Zilberfeld explains refactoring legacy code for writing unit tests, thist ime about method extraction. This pattern allows to unit test and mock methods

Legacy Code To Testable Code #2: Extract Method

This post is part of the “Legacy Code to Testable Code” series. In the series we’ll talk about making refactoring steps before writing unit tests for legacy code, and how they make our life easier. Other posts included: As with renaming, extracting a method helps us understand legacy code better. Read more…

By Gil Zilberfeld, 9 yearsOctober 13, 2014 ago
Gil Zilberfeld explains refactoring legacy code, starting with renaming variables, methods and classes, on the way to easier writing of unit tests.

Legacy Code To Testable Code #1: Renaming

This post is part of the “Legacy Code to Testable Code” series. In the series we’ll talk about making refactoring steps before writing tests for legacy code, and how they make our life easier. Other posts include: Renaming is easy and is usually safe refactoring. Most IDEs have the refactoring Read more…

By Gil Zilberfeld, 9 yearsOctober 7, 2014 ago

Testability != Good Design

It’s a funny thing, code testability. It’s not really defined, or rather, it is defined poorly. If “testable code” is “code we can test”, that means all code is like that. We can test it through unit tests. If it’s hard we can move to functional tests. And if all Read more…

By Gil Zilberfeld, 9 yearsSeptember 26, 2014 ago

The Economics of Unit Testing

Unit testing is a set of skills, that rarely appears on a resume. When I saw a resume with unit testing on it, it rose up to the top of the interview queue. I understood the person who put it there understands what it means to the business. If the Read more…

By Gil Zilberfeld, 9 yearsSeptember 1, 2014 ago

Posts navigation

Previous 1 2 3 Next

FREE DOWNLOAD:

API Test Plan Template

Download
  • Home
  • Courses and Workshops
  • Events
  • My Books
  • Downloads
  • Blog
  • About Gil Zilberfeld
  • Contact
Hestia | Developed by ThemeIsle