DEV Community: Max Normand

Avoid PTSD use TDD

Max Normand — Wed, 12 Jun 2024 13:18:28 +0000

Introduction 👋

Test-Driven Development (TDD) is an approach that focuses on writing tests before writing the actual code. The general aim is to never write new functionality without a failing test first.

In basic principle remember the following...
RED-GREEN-REFACTOR

Why TDD?

Occasionally you may see the following smells

Tests that don't make sense.
- Poor use of testing practices like non descriptive context and it blocks lead to tests that are hard to read, which makes it very difficult to debug and maintain
Sometimes a feature is not understood correctly, and edge cases are not addressed
- If you don't understand the spec how can you write it effectively?
- If you don't agree with the spec / ticket its best to raise it ASAP, don't be afraid to speak out!
- The same goes for working on bugs, if you have a very coupled system, ensure the fix proposed makes sense, but first understand the feature.
Not testing the negative enough
- You should never assume that things are always going to go right (*cough *cough Murphy's Law), we should be trying to catch possible errors and then write tests for it.
The develop is not envisaging the properly. IE pretend to be the user.
- Sometimes its good to stop and think if what your are building / testing could use more enhancements or be friendlier to the user
- This isn't always possible but sometimes things are missed in designs or tickets you might find them yourself.
Bloated tests
- Be careful not to over assert functionality, test what is key to the feature, make it simple and move on. Don't test things that your language does, test things the feature does.

Poorly written tests that over-specify the functionality of objects make systems harder to change, leading to frustration with the practice of testing and TDD itself.

If an organization or project wants to see the value of testing in the long term, they need to ensure that test suites are kept lean, that tests are structured to aid developers in understanding them, and that failures provide useful feedback.
*Source

Thankfully TDD can help!

The Basic formula 🧑‍🍳

Write Test: ✏️ Start by writing a test that defines the desired behaviour of a particular piece of code. This test should initially fail because the code to fulfil the behaviour hasn’t been implemented yet.
Run it, for Red: 🔴 Run your test, knowing that its going to fail. It's okay to fail 😜
Write Code: ✏️ Write the minimum amount of code necessary to make the test pass. In this pass we just want to make the thing work, it doesn't matter if its ugly.
Run it for Green: 🟢 Run your test again, it should pass. If it doesn't pass, go back a step and keep working to get the green.
Refactor: ✏️ After the test passes, refactor the code to improve its quality, maintainability, and efficiency. It's good here to look at OO principles and best practices often used in ruby. (In particular when building new classes or PORO's)
Run it for Green: 🟢 Run your test again, ensuring it passes or go back to refactoring
Repeat on next item: 🔁 Move onto the next piece of work and start again

Handy tips!

As a first step I like to write up a skeleton of tests. So for instance I would copy the ticket and then draft up a skeleton of the context blocks and it blocks before hand.

Also break things down into segments and pieces of logic. Smaller bits are easier to manage.

Don't be afraid to use an AI when refactoring! I do it all the time its super handy, just make sure you ask the write questions and always take suggestions with a grain of salt. Sometimes it comes up with garbage but often theres excellent feedback. Write down what you learn use it next time!

Use AAA to supercharge your tests

"Arrange, Act, Assert" (AAA) is a pattern for arranging and formatting code in unit tests. The idea is to divide your test method into three sections, which are separated by blank lines:

Arrange: This is where you set up the conditions for your test. This could involve creating objects, initialising data, setting up mocks or stubs, etc.
Act: This is where you perform the action that you're testing. Usually, this is a single function call.
Assert: This is where you check that the action you performed in the "Act" step produced the expected result.

Check out the following ruby example using RPSEC

RSpec.describe Calculator do
  describe '#add' do
    it 'adds two numbers' do
      # Arrange
      calculator = Calculator.new

      # Act
      result = calculator.add(2, 3)

      # Assert
      expect(result).to eq(5)
    end
  end
end

Benefits of TDD ✅

Forces developer to think deeper about the requirements and design of the spec
Catch potential bugs early. 🐞
Catch design flaws early, leading to higher code / feature quality.
Debugging becomes faster and more efficient.
Comprehensive tests makes refactoring safer ⛑️

Tidbit about BDD

BDD or Behaviour Driven Development, extends on Test driven development by writing test cases in a way anyone can understand.

It focuses on the behaviour of software from the user’s perspective.
It's an agile software development technique, in that it encourages collaboration between developers, QA and non-technical or business participants in a software project.
Helps your tests tell a story of the feature with an emphasis on UX

Benefits of BDD ✅

Makes tests human readable, meaning they are clearer and easier to understand, which makes them easier to maintain and fix any potential bugs. 📖
Test cases can become documentation of the feature, in a well written test you don't have to read the code to understand what it does
Forcing more collaboration between technical and non technical team members means a shared understanding of the requirements and overall a better piece of work
You can catch unhandled use cases or possible feature enhancements early, saving precious time.

Homework

Check out this awesome exercises from thoughtbot to help you level up
https://thoughtbot.com/upcase/fundamentals-of-tdd

Resources

https://jardo.dev/tdd-on-the-shoulders-of-giants
https://jardo.dev/dont-assert-return-types-tdd
https://www.linkedin.com/pulse/introduction-test-driven-development-tdd-ruby-rails-amit-patel
https://www.andolasoft.com/blog/rails-things-you-must-know-about-tdd-and-bdd.html

The Builder Design Pattern in Ruby 🔨

Max Normand — Tue, 01 Aug 2023 10:31:10 +0000

Design patterns are fundamental to know if you’re going to build sexy and scalable applications. In this article we will be looking at the builder pattern.

Introduction

The builder pattern, is part of the “creational design patterns”. In summary it simplifies the processes of creating complex objects.

We create a builder class that should have everything we need to help ease the complexities around creating our objects.

Specification

Let’s take our robot example from a previous tutorial 🤖

A robot is a complex object, it can have many attributes, all relating to a different kind of robot build. For example, a large dumb robot in a factory, to a small child's robot. You may have some pre-set attributes. But all in all, this class is very dynamic upon generation.

Creating the complex class

class Robot
  attr_accessor :colour, :ai_type, :body_type, :movement, :name, :function

  def initialize(colour=nil, ai_type=nil, body_type=nil, movement=nil, name=nil, function=nil)
    @colour = colour
    @ai_type = ai_type
    @body_type = body_type
    @movement = movement
    @name = name
    @function = function
  end
end

As you can see, initialising our class each time will be a pain, especially if we want a variation of robots. Classes like this can look unprofessional and bloat our application.

We would have to do this lots of times:

butter_robot = Robot.new(
  colour = "grey",
  ai_type = "too smart for own good",
  body_type = "small rover",
  movement = "medium",
  name = "butter robot",
  function = "pass the butter"
)

Creating a builder class will solve this problem 🔨

class RobotBuilder
  def initialize
    @robot = Robot.new
  end

  # We can set default attributes to save time
  def set_default_parameters(colour, name, movement, body_type)
    @robot.colour = colour
    @robot.name = name
    @robot.movement = movement
    @robot.body_type = body_type
  end

  # We can set one attribute
  def set_function(function)
    @robot.function = function
  end

  # We can have pre-set conditions
  def set_as_smart
    @robot.ai_type = 'smart'
  end

  def set_as_dumb
    @robot.ai_type = 'dumb'
  end

  # We can have pre-set objects ready
  def set_as_terminator
    @robot.ai_type = 'smart'
    @robot.function = 'take over world'
    @robot.movement = 'fast'
    @robot.body_type = 'humanoid'
    @robot.colour = 'chrome'
    @robot.name = terminator_name
  end

  def set_as_walee
    @robot.ai_type = 'loving'
    @robot.function = 'to help'
    @robot.movement = 'medium'
    @robot.body_type = 'rover'
    @robot.colour = 'rusty yellow'
    @robot.name = "WALL-E"
  end

  def robot
    @robot
  end

  private

  # We can use all sorts of methods to help our builder logic
  def terminator_name
    letters = ('a'..'z').to_a.sample(3).join
    numbers = rand 200..500
    letters + numbers.to_s
  end
end

As you can see our class does a few different things. We firstly start by initializing our builder class. Which will also in turn create our robot class.

From this initialized builder object, we can then go through various methods to set up the our robot object. As you can see, how we want to set it up is entirely configurable. We can create a nice little robot, or a terminator to destroy to world!

We can even create private methods to help with the creation of complex attributes. If you wanted, you could also pass in and initialize other objects as well. The list goes on...

Some examples of the fun we can have:

# to create a default robot
builder = RobotBuilder.new
builder.set_default_parameters(
  "Red", "Robot", "Slow", "Large"
)
builder.set_as_dumb
builder.set_function("Pack boxes")

# to create a freind
builder = RobotBuilder.new
builder.set_as_walee

# to take over the world!
builder = RobotBuilder.new
builder.set_as_terminator

Conclusion

With our new builder, any further complexities for our robot can now be addressed by growing this class. The builder can be called at any point of our application, to help us create our robot army.

<3 Thanks for reading <3

Basics of Ruby Classes

Max Normand — Wed, 26 Jul 2023 06:33:28 +0000

Ruby is one of the easiest languages to grasp the concept of OOP (object orientated programming). In particular the power that of PORO’s (plain old Ruby objects).

Let's go through a short example using a little robot 🤖

Goal specifications

We want to robot to be able to do the following:

Move around 🏃‍♂️
Return home 🏠
Change colour 🔴🟡🔵
Receive a toy 🧸

To define a class in Ruby it’s quite simple, let’s start.

# Initializing a class
class Robot
  def initialize(north, south, east, west, colour)
    @north = north
    @south = south
    @east = east
    @west = west
    @colour = colour
  end
end

The initializer method is responsible for handling creating new instances of our class. In this method we define what attributes we want our class to have, this can be anything!

Using our class

Now I suggest if you're following along, running a ruby console (assuming you have installed ruby on your machine). To create and play around with our robot.

To create an instance of a class, and assign it to a local variable
robot = Robot.new
As simple as that!

Now we have access to our robot, but we cannot do anything with it. This is where attribute accessors come into play.

You should read more in depth on this. The principle of attribute accessors is that, they give us write and read permissions on our classes instance objects.

# How to access attributes of a class
class Robot
  attr_accessor :north, :south, :east, :west, :colour

  def initialize(north, south, east, west, colour)
    @north = north
    @south = south
    @east = east
    @west = west
    @colour = colour
  end
end

Now if we call our class in irb, we can move our robot by going.

robot = Robot.new(0,0,0,0)

PLEASE NOTE: At this point, if we do not assign a value to these attributes, you will get an error. We will cover how to change this later.

Class methods and Instance methods

There are two fundamental types on methods you can use on classes in ruby. Class methods, which are called only on the class, and instance methods, called only on an instance of the class.

Here is a good article with some more detail.
https://dev.to/adamlombard/ruby-class-methods-vs-instance-methods-4aje

Now, we can update our class with what we have learnt.

class Robot
  attr_accessor :north, :south, :east, :west, :colour

  def initialize(north = 0, south = 0, east = 0, west = 0, colour = "red")
    @north = north
    @south = south
    @east = east
    @west = west
    @colour = colour
  end

  # Class method, only called on the class
  def self.instructions
    'Hello, I am a Robot, I can move in any direction, and I have a colour!'
  end

  # Instance method only called on an instance of the class
  def print_coordinates
    "Hello I am Robot, I am north #{north}, south #{south}, east #{east}, west #{west}"
  end
end

Notice as well I have added placeholder values in the class initializer method. This means we can safely call our class with no values.

Next let's write some methods to make our robot move around, by updating its attributes.

class Robot
  attr_accessor :north, :south, :east, :west, :colour

  def initialize(north = 0, south = 0, east = 0, west = 0, colour = "red")
    @north = north
    @south = south
    @east = east
    @west = west
    @colour = colour
  end

  # Class method, only called on the class
  def self.instructions
    'Hello, I am a Robot, I can move in any direction, and I have a colour!'
  end

  # Instance method only called on an instance of the class
  def print_coordinates
    "Hello I am Robot, I am north #{north}, south #{south}, east #{east}, west #{west}"
  end

  # Updating an attribute on the class
  def move_north(distance)
    self.north = north + distance
  end

  def move_south(distance)
    self.south = south + distance
  end

  def move_east(distance)
    self.east = east + distance
  end

  def move_west(distance)
    self.west = west + distance
  end
end

Notice how I call self on each method. This is because on these instance methods, we want to assign new data to the instance of the class, therefore itself. I suggest reading this for more explanation.

Using Constants

One very handy tool in ruby is the use of constants. I'd explain constants as key bits of data we want to store in memory, that relate to our class. For instance, they are commonly used in Models for important business logic. This data should not change once defined.

Below I have added some constants for our robots colour. Followed up by a method that uses an array of these constants.

# Using constants
class Robot
  attr_accessor :north, :south, :east, :west, :colour

  # Declaring constants
  RED = 'red'.freeze
  BLUE = 'blue'.freeze
  YELLOW = 'yellow'.freeze
  GREEN = 'green'.freeze

  # Declaring an array of constants
  COLOURS = [
    RED,
    BLUE,
    YELLOW,
    GREEN
  ].freeze

  def initialize(north = 0, south = 0, east = 0, west = 0, colour = RED)
    @north = north
    @south = south
    @east = east
    @west = west
    @colour = colour
  end

  # Class method, only called on the class
  def self.instructions
    'Hello, I am a Robot, I can move in any direction, and I have a colour!'
  end

  # Instance method only called on an instance of the class
  def print_coordinates
    "Hello I am Robot, I am north #{north}, south #{south}, east #{east}, west #{west}"
  end

  # Updating an attribute on the class
  def move_north(distance)
    self.north = north + distance
  end

  def move_south(distance)
    self.south = south + distance
  end

  def move_east(distance)
    self.east = east + distance
  end

  def move_west(distance)
    self.west = west + distance
  end

  # Select a random colour
  def change_colour
    self.colour = Robot::COLOURS.sample
  end

  # reset the co-ordinates
  def bring_home
    self.north = 0
    self.south = 0
    self.east = 0
    self.west = 0
  end
end

Look at how our class has grown! Now think of the power we have learnt (evil laugh).

Let's have fun with our instance methods:

robot = Robot.new
robot.move_north(3)
robot.change_colour
robot.bring_home

We have now achieved so much from the spec!

But wait, there's more we can do, and we haven't fulfilled the spec. We need to give our robot a toy, the little fella earnt it, don't you think?

Not only can we pass numbers and strings into our classes, we can also pass... dun dun dun, other classes!

Let's create a toy class. A simple class with a name attribute.

class Toy
  attr_accessor :name

  def initialize(name = 'skateboard')
    @name = name
  end
end

Now, if we pass in another attribute parameter to our robot, as well as define another attribute accessor. We can have full access of the toy within an instance of our robot class.

# Passing in a class instance object to another class

class Robot
  attr_accessor :north, :south, :east, :west, :colour, :toy

  # Declaring constants
  RED = 'red'.freeze
  BLUE = 'blue'.freeze
  YELLOW = 'yellow'.freeze
  GREEN = 'green'.freeze

  # Declaring an array of constants
  COLOURS = [
    RED,
    BLUE,
    YELLOW,
    GREEN
  ].freeze

  def initialize(north = 0, south = 0, east = 0, west = 0, colour = RED, toy)
    @north = north
    @south = south
    @east = east
    @west = west
    @colour = colour
    @toy = toy
  end

  # Class method, only called on the class
  def self.instructions
    'Hello, I am a Robot, I can move in any direction, and I have a colour!'
  end

  # Instance method only called on an instance of the class
  def print_coordinates
    "Hello I am Robot, I am north #{north}, south #{south}, east #{east}, west #{west}"
  end

  # Updating an attribute on the class
  def move_north(distance)
    self.north = north + distance
  end

  def move_south(distance)
    self.south = south + distance
  end

  def move_east(distance)
    self.east = east + distance
  end

  def move_west(distance)
    self.west = west + distance
  end

  # Select a random colour
  def change_colour
    self.colour = Robot::COLOURS.sample
  end

  # reset the co-ordinates
  def bring_home
    self.north = 0
    self.south = 0
    self.east = 0
    self.west = 0
  end
end

Now if you were to call toy = Toy.new and robot = Robot.new(toy), you can successfully met the spec, congratulations!

Conclusion

As you can see creating our own classes in ruby is not only fun, but extremely powerful. If you harness the power of classes in your rails applications, you can create very modular, DRY, and sexy looking code. 😘

I encourage you on your ruby journey, to jump on in a console and have fun! I find it's the best way to learn. Thanks for reading, you're a 💎