Render offers PostgreSQL for free accounts, but the database is deleted after one month.
If the data matters to you, the solution is to back it up and recover it.

How to backup

Follow these steps;

1. Run this command in the terminal to backup the PostgreSQL DB:

    pg_dump -h dpg-cn9if6fsc6pc74fh6pd0-a.oregon-postgres.render.com -U mysite mysite_d75u -n public --no-owner > database_dump.sql
   

2. What each of the values in 1 above means can be found in 6 below

3. You will be prompted to input a password. The password can be obtained by following the steps described in 7 below.

4. In case your system pg_dump doesn’t match the server version, you might get the error below;

    pg_dump: error: server version: 16.4 (Debian 16.4-1.pgdg120+2); pg_dump version: 14.13 (Homebrew)
    pg_dump: error: aborting because of server version mismatch
   

5. To resolve this error, use the pg_dump that matches the server’s. Something like so;

    /opt/homebrew/opt/postgresql@16/bin/pg_dump -h dpg-cn9if6fsc6pc73fd6pc0-a.oregon-postgres.render.com -U mysitte mysite_d75u -n public --no-owner > database_dump.sql
   

6. Replace the relevant values with the ones that match yours as described in the render dashboard;

   1. dpg-cn9if6fsc6pc74fh6pd0-a : your Hostname

   2. oregon-postgres.render.com: your database region

   3. mysite : your database_username

   4. mysite_d75u : your database_name

7. The values are obtained by the following steps;

   1. Log into render

   2. Go to projects

   3. Under services, click PostgreSQL service name

   4. The details will be under the connections above Access Control

How to drop the DB

Follow these steps;

1. Run this command to drop the PostgreSQL DB:

    /opt/homebrew/opt/postgresql@16/bin/dropdb -h dpg-cn9if6fsc6pc73fd6pc0-a.oregon-postgres.render.com -U mysite mysite_d75u
   

2. You will be prompted to input the password.

How to create and restore the DB

Follow these steps;

1. Run this command to create a new PostgreSQL DB:

    /opt/homebrew/opt/postgresql@16/bin/createdb dpg-cn9if6fsc6pc73fd6pc0-a.oregon-postgres.render.com -U mysite mysite_d75u
   

2. Run this to restore your PostgreSQL DB from the backup

    psql -h dpg-cn9if6fsc6pc73fd6pc0-a.oregon-postgres.render.com -U mysite mysite_d75u < database_dump.sql
   

3. You will be prompted to input the password

Conclusion

Shout out to Silumesii who greatly assisted with this.
With this guide, you can back up, delete and restore your PostgreSQL DB on render.
I plan to explore a way of automating this process.

Heroku no longer has a free tier. This blog post lists the reasons why.
Heroku used to be my go-to service for experimenting with new frameworks. I would generate the starter app, and then deploy it to Heroku.
Then I would continue to incrementally build on what had been deployed.

I searched for options and came across Render and Fly.io.
I was particularly interested in a service that could host a Ruby on Rails app and a PostgreSQL database.
I decided to experiment with Render.

Adding the necessary files

The following files are necessary as a prerequisite to make the deployment possible;

1. render.yaml

2. render-build.sh

render.yaml is added to the root

 databases:
   - name: rumblr
     databaseName: rumblr
     user: root
     plan: free

 services:
   - type: web
     name: rumblr
     runtime: ruby
     plan: free
     buildCommand: "./bin/render-build.sh"
     # preDeployCommand: "./bin/rails db:migrate" # preDeployCommand only available on paid instance types
     startCommand: "./bin/rails server"
     envVars:
       - key: DATABASE_URL
         fromDatabase:
           name: rumblr
           property: connectionString
       - key: RAILS_MASTER_KEY
         sync: false
       - key: WEB_CONCURRENCY
         value: 2 # sensible default

render-build.sh is added to bin directory

 #!/usr/bin/env bash
 # exit on error
 set -o errexit

 bundle install
 ./bin/rails assets:precompile
 ./bin/rails assets:clean
 ./bin/rails db:migrate

Deployment

Sign in with GitHub

An account is required to access Render services.
I created one using Github.

Create an instance

In the Render Dashboard;

1. Click on Blueprints

2. Then click on the New Blueprint instance

3. Select your repository

Deploy the app

In the deploy window;

1. Set the value of RAILS_MASTER_KEY to the contents of config/master.key

2. Then click, Approve

3. Give the deployment process some time to complete

4. The deployed app should be accessible via: https://app_name.onrender.com

Conclusion

What I liked about Render

1. The ease of connecting easily to GitHub and selecting the target repo

2. The fact that new changes to the repo are detected and deployment takes place automatically is awesome.

What I didn't like about Render

1. The official render tutorial for deployment didn't specify that we needed to add bin/rails db:migrate to the bin/render-build.sh script.

2. They were not clear on how to handle the Postgres database after the trial period other than stating that I had to upgrade.

3. Sometimes, I forgot to click sync when new changes were pushed to the GitHub repo, resulting in the deployment not happening automatically.

Shout out to Silumesii for the pairing sessions to make this happen and for the idea for this blog post.

I usually face specific issues that always come up. I always find myself checking Google for the solution over and over.

I thought that checking on Google over and over was inefficient and to save me and probably others, some time, I will document some of the issues that I face.

For context, I happen to use an M1 Macbook for development.
You might wanna consider your specific situation.
Nevertheless, I hope this will be helpful.

Postgres stopping to work

I am not familiar with how this issue comes up.
My database of choice is usually Postgres.
But once in a while, when I am testing a Rails app on the development machine, I get this error;

connection to server on socket "/tmp/.s.PGSQL.5432" 
failed: No such file or directory 
Is the server running locally and accepting connections on that socket?

The solution to this issue

1. Open the file /opt/homebrew/var/log/postgres.log to identify the problem. I used homebrew to install postgres so this it's location.

    27645 2023-06-22 11:54:14.111 EAT [21939] HINT:  Is another postmaster (PID 776) running in data directory "/opt/homebrew/var/postgres"?
    27646 2023-06-22 11:54:24.161 EAT [21946] FATAL:  lock file "postmaster.pid" already exists
    27647 2023-06-22 11:54:24.161 EAT [21946] HINT:  Is another postmaster (PID 776) running in data directory "/opt/homebrew/var/postgres"?
    27648 2023-06-22 11:54:34.206 EAT [21960] FATAL:  lock file "postmaster.pid" already exists
    27649 2023-06-22 11:54:34.206 EAT [21960] HINT:  Is another postmaster (PID 776) running in data directory "/opt/homebrew/var/postgres"?
    27650 2023-06-22 11:54:44.250 EAT [21975] FATAL:  lock file "postmaster.pid" already exists
   

2. Sure enough, as indicated on lines 27648, and 2749 the error is clear.

3. Deleting the postmater.pid file in the /opt/homebrew/var/postgres directory should solve this issue.

4. Delete the postmaster.pid file using: rm -rf /opt/homebrew/var/postgres/postmaster.pid

5. Restart postgres by running: brew services restart postgresql@14

6. Now everything should work fine.

Conclusion

I hope that this is helpful.
Take the time to read and understand the problem.

The Shape Up Book details how the folks at 37 Signals handle project management, shipping new products and adding new features and everything else in between.

What I learnt

1. Experiment to find out what works best for you.

2. Once you have determined what methods are effective for you, increase the frequency of using them and make the necessary modifications.

3. While traditional and well-known systems may sound appealing and get a lot of attention, it's important to consider whether they actually work for you in your daily life.

Major takeaways

1. To successfully ship a product, it is necessary to make tough choices about what to include and what to leave out.

2. Trying to fix everything before shipping is impossible.

3. Prioritizing unknown problems should take precedence.

4. It's important to acknowledge that there will always be more work than time.

5. Meeting deadlines means accepting some level of imperfection in the final product.

What is being used day-to-day

A slightly modified idea of "scoping the work" is being used.
In Rumblr, only one feature is worked on at a time.

Conclusion

The book was full of insights.
It will be useful as a reference.

For the uninitiated, GitHub Actions helps automate certain aspects of a software project's build, test and deployment aspects. If your project is already on Github, it makes sense to utilise what GitHub Actions has to offer.
The focus of this write-up is the CI aspect of GitHub Actions.

Why I did this

I set out to familiarise myself with how to use GitHub Actions for CI. I wanted to automate the running of the system tests in Rumblr.
I precisely wanted the CI to run every time I push to a new branch or the main branch and every time a new Pull Request is made.

How I achieved it

To get the CI to build, new changes needed to be made and new files needed to be added.

A new file: .env.test had to be created. Below are the contents of the file;

EMAIL_RECIPIENTS=test@test.com
FROM_EMAIL=sample@test.com
HONEYBADGER_API_KEY=honeybadger

A new file for the workflow needed to be added.
Below are the contents of the actual CI file which is located via: .github/workflows/config.yml

name: CI

 on: [push,pull_request]
 jobs:
   test:
     name: Tests
     runs-on: ubuntu-latest
     services:
       postgres:
         image: postgres:12.7
         env:
           POSTGRES_USER: rumblr
           POSTGRES_DB: rumblr_test
           POSTGRES_PASSWORD: password
         ports: ["5432:5432"]
         options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

     steps:
       - name: Checkout code
         uses: actions/checkout@v2

       - name: Setup Ruby and install gems
         uses: ruby/setup-ruby@v1
         with:
           bundler-cache: true

       - name: Install postgres client
         run: sudo apt-get install libpq-dev

       - name: Setup test database
         env:
           RAILS_ENV: test
           POSTGRES_HOST: localhost
           POSTGRES_USER: rumblr
           POSTGRES_PASSWORD: password
         run: |
           bin/rails db:setup

       - name: Run tests
         env:
           RAILS_ENV: test
           POSTGRES_HOST: localhost
           POSTGRES_USER: rumblr
           POSTGRES_PASSWORD: password
         run: |
           bundle exec rake assets:precompile
           bundle exec rspec

Some changes needed to be made to the database.yml file. The changes are below;

test:
   <<: *default
   database: rumblr_test
   host: <%= ENV.fetch('POSTGRES_HOST',  'localhost') %>
   username: <%= ENV.fetch('POSTGRES_USER', nil) %>
   password: <%= ENV.fetch('POSTGRES_PASSWORD', nil) %>
   port: <%= ENV.fetch('POSTGRES_PORT', 5432) %>

These changes were done to the test portion of the database configuration.

Challenges faced

Some challenges (as expected) were faced while attempting this task.
Consider this git change log for the challenges that were faced.

The .env.test file

This file had to be included and the suggestion came from a colleague.
The official Github guides were only partly helpful to assist in setting this up.
Otherwise, the build kept on failing and the error didn't make a lot of sense.

The changes to the test section of the DB config

Consider the config/database.yml file in the change log.
All that had to be added as well for the build to happen successfully.

References

The links below were helpful in achieving this task;

1. Boring Rails Article

2. Andy Croll Article

3. This Stack Overflow answer

4. Medium Article

5. Github Tailwind CSS Issue

Conclusion

This is included in the Rumblr project which can be found here.

Introduction:

In part 2, this was achieved;

1. Scanning of each of the items, A, B, C, and D was done
2. The corresponding test was written for each

In part 3, this is going to be handled;

1. Some house cleaning
2. Changing CheckOut Spec
3. Adding PricingRules Spec
4. Adding PricingRules Class
5. Adding pricing rules

Some House Cleaning:

The code in the ChecKOut class needs to be included in a separate file under lib/checkout.rb

Below is the checkout.rb file:

class CheckOut
  def initialize(pricing_rules)
    @total = 0
  end

  def total
    @total
  end

  def scan(item)
    if item == 'A'
      @total = 50
    elsif item == 'B'
      @total = 30
    elsif item == 'C'
      @total = 20
    else
      @total = 15
    end
  end
end

The checkout spec needs to included in a separate file under spec/checkout_spec.rb

Below is the checkout_spec.rb file:

require 'checkout'

 RSpec.describe 'checkout' do
   context 'when nothing has been scanned' do
     it 'shows a total of zero' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)
       total = checkout.total

       expect(total).to eq 0
     end
   end
   context 'when A has been scanned' do
     it 'shows the price of A' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)

       checkout.scan('A')
       total = checkout.total

       expect(total).to eq 50
     end
   end
   context 'when B has been scanned' do
     it 'shows the price of B' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)

       checkout.scan('B')
       total = checkout.total

       expect(total).to eq 30
     end
   end
   context 'when C has been scanned' do
     it 'shows the price of C' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)

       checkout.scan('C')
       total = checkout.total

       expect(total).to eq 20
     end
   end
   context 'when D has been scanned' do
     it 'shows the price of D' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)

       checkout.scan('D')
       total = checkout.total

       expect(total).to eq 15
     end
   end
 end

Changing CheckOut Spec:

This is the new checkout_spec.rb file:

require 'checkout'
require 'pricing_rules'

RSpec.describe 'checkout' do
  context 'when nothing has been scanned' do
    it 'shows total of zero' do
      pricing_rules = :Rule
      checkout = CheckOut.new(pricing_rules)
      total = checkout.total

      expect(total).to eq 0
    end
  end

  context 'when A has been scanned' do·
    it 'shows the price of A' do
      pricing_rules = PricingRules.new(
        "A" => {unit_price: 50, discount_price: 130, discount_count: 3})
      checkout = CheckOut.new(pricing_rules)
      checkout.scan('A')
      total = checkout.total

      expect(total).to eq 50
    end
  end

  context 'when B has been scanned' do
    it 'shows the price of B' do
      pricing_rules = PricingRules.new(
        "B" => {unit_price: 30, discount_price: 45, discount_count: 2})
      checkout = CheckOut.new(pricing_rules)
      checkout.scan('B')
      total = checkout.total

      expect(total).to eq 30
    end
  end

  context 'when C has been scanned' do·
    it 'shows the price of C' do
      pricing_rules = PricingRules.new("C" => {unit_price: 20})
      checkout = CheckOut.new(pricing_rules)
      checkout.scan('C')
      total = checkout.total

      expect(total).to eq 20
    end
  end

  context 'when D has been scanned' do·
    it 'shows the price of D' do
      pricing_rules = PricingRules.new("D" => {unit_price: 15})
      checkout = CheckOut.new(pricing_rules)
      checkout.scan('D')
      total = checkout.total

      expect(total).to eq 15
    end
  end
 end

This is the new checkout.rb file:

 class CheckOut
   def initialize(pricing_rules)
     @pricing_rules = pricing_rules
     @items_count = Hash.new(0)·
   end

   def scan(item)
     @items_count[item] += 1
   end

   def total
     @items_count.inject(0) do |total, (item, count)|
       if item == 'B' || item == 'A'
         total += @pricing_rules.price_for(item, count)
       else
         total += count*@pricing_rules.unit_price(item)
       end
     end
   end
 end

Adding PricingRules Spec:

This is the pricing_rules_spec.rb file;

 require "pricing_rules"

 RSpec.describe PricingRules do
   describe "#unit_price" do
     it "fetches the unit price for the item" do
       pricing_rules = PricingRules.new("A" => {unit_price: 50})

       unit_price = pricing_rules.unit_price("A")

       expect(unit_price).to eq 50
     end
   end

   describe "#discount_price" do
     it "fetches the discount price for the item" do
       pricing_rules = PricingRules.new("A" => {discount_price: 130})

       discount_price = pricing_rules.discount_price("A")

       expect(discount_price).to eq 130
     end
   end

   describe "#discount_count" do
     it "fetches the discount count of the item" do
       pricing_rules = PricingRules.new("A" => {discount_count: 3})

       discount_count = pricing_rules.discount_count("A")

       expect(discount_count).to eq 3
     end
   end

   describe "#price_for" do
     it "calculates the price for a number of items" do

       pricing_rules = PricingRules.new(
         "A" => {unit_price: 50, discount_price: 130, discount_count: 3})

       price = pricing_rules.price_for("A", 3)

      expect(price).to eq 130
    end
  end

  describe "#has_dicount_price" do
    it "checks if an item has a discount price" do
      pricing_rules = PricingRules.new("A" => {discount_price: 130})

      has_discount = pricing_rules.has_discount_price("A")

      expect(has_discount).to be(true)
    end
  end
end

Adding PricingRules Class:

This is the pricing_rules.rb file:

 class PricingRules·
   def initialize(rules)
     @rules = rules
   end

   def unit_price(item)
     @rules[item][:unit_price]
   end

   def discount_price(item)
     @rules[item][:discount_price]
   end

   def discount_count(item)
     @rules[item][:discount_count]
   end

   def price_for(item, count)
     count/discount_count(item) * discount_price(item) +·
     count% discount_count(item) * unit_price(item)·
   end

   def has_discount_price(item)
     @rules[item].has_key?(:discount_price)
   end
 end

When the pricing_rules_spec tests are run, they pass successfully;

./bin/rspec spec/pricing_rules_spec.rb:3
Run options: include {:locations=>{"./spec/pricing_rules_spec.rb"=>[3]}}

Randomized with seed 46467

PricingRules
  #has_dicount_price
    checks if an item has a discount price
  #price_for
    calculates the price for a number of items
  #discount_price
    fetches the discount price for the item
  #discount_count
    fetches the discount count of the item
  #unit_price
    fetches the unit price for the item

Finished in 0.0013 seconds (files took 0.05617 seconds to load)
5 examples, 0 failures

Randomized with seed 46467


Press ENTER or type command to continue

Adding Pricing Rules:

Edit the checkout.rb file to include pricing_rules in the initialize method.

The checkout.rb file changes to:

class CheckOut
  def initialize(pricing_rules)
    @pricing_rules = pricing_rules
    @total = 0
  end

  def total
    @total
  end

  def scan(item)
    if item == 'A'
      @total = 50
    elsif item == 'B'
      @total = 30
    elsif item == 'C'
      @total = 20
    else·
      @total = 15
    end
  end
end

Make certain that written tests still pass and they do as shown below:

./bin/rspec spec/check_out_spec.rb

Randomized with seed 13654
.....

Finished in 0.00245 seconds (files took 0.05355 seconds to load)
5 examples, 0 failures

Randomized with seed 13654


Press ENTER or type command to continue

Edit the chekout.rb file further to this;

class CheckOut
  def initialize(pricing_rules)
    @pricing_rules = pricing_rules
    @items_count = Hash.new(0)·
  end
··
  def scan(item)
    @items_count[item] += 1
  end

  def total
    @items_count.inject(0) do |total, (item, count)|
      if item == 'B' || item == 'A'
        total += @pricing_rules.price_for(item, count)
      else
        total += count*@pricing_rules.unit_price(item)
      end
    end
  end
end

This was done to take into account the pricing_rules and items_count

Edit the checkout_spec.rb file to gradually include pricing rules information

Adding Pricing Rules To A

Include pricing_rules for the context 'when A has been scanned':

context 'when A has been scanned' do
  it 'shows the price of A' do
    pricing_rules = PricingRules.new(
      "A" => {unit_price: 50, discount_price: 130, discount_count: 3})
    checkout = CheckOut.new(pricing_rules)

    checkout.scan('A')
    total = checkout.total

    expect(total).to eq 50
  end
end

When the test is run, it passes successfully:

./bin/rspec spec/checkout_spec.rb:16
Run options: include {:locations=>{"./spec/checkout_spec.rb"=>[16]}}

Randomized with seed 64567

checkout
  when A has been scanned
    shows the price of A

Finished in 0.00064 seconds (files took 0.04095 seconds to load)
1 example, 0 failures

Randomized with seed 64567


Press ENTER or type command to continue

Adding Pricing Rules to the rest of the items:

   context 'when B has been scanned' do
     it 'shows the price of B' do
       pricing_rules = PricingRules.new(
         "B" => {unit_price: 30, discount_price: 45, discount_count: 2})
       checkout = CheckOut.new(pricing_rules)
       checkout.scan('B')
       total = checkout.total

       expect(total).to eq 30
     end
   end

   context 'when C has been scanned' do·
     it 'shows the price of C' do
       pricing_rules = PricingRules.new("C" => {unit_price: 20})
       checkout = CheckOut.new(pricing_rules)
       checkout.scan('C')
       total = checkout.total

       expect(total).to eq 20
     end
   end

   context 'when B, A and then D have been scanned' do
     it 'shows the total price of B, A and D' do
       pricing_rules = PricingRules.new(
         "B" => {unit_price: 30, discount_price: 45, discount_count: 2},
         "A" => {unit_price: 50, discount_price: 130, discount_count: 3},
         "D" => {unit_price: 15}
       )
       checkout = CheckOut.new(pricing_rules)

       checkout.scan('B')
       checkout.scan('A')
       checkout.scan('D')
       total = checkout.total

       expect(total).to eq 95
     end
   end

  context 'when D has been scanned' do·
    it 'shows the price of D' do
      pricing_rules = PricingRules.new("D" => {unit_price: 15})
      checkout = CheckOut.new(pricing_rules)
      checkout.scan('D')
      total = checkout.total

      expect(total).to eq 15
    end
  end

  context 'when B, A and another B has been scanned' do
    it 'shows the total discounted price of B plus price of A' do
      pricing_rules = PricingRules.new(
        "B" => {unit_price: 30, discount_price: 45, discount_count: 2},
        "A" => {unit_price: 50, discount_price: 130, discount_count: 3},
        "D" => {unit_price: 15}
      )
      checkout = CheckOut.new(pricing_rules)

      checkout.scan('B')
      checkout.scan('A')
      checkout.scan('B')
      total = checkout.total

      expect(total).to eq 95
    end
  end

  context 'when A, A, and another A have been scanned' do
    it 'shows the total discounted price of three A items' do
      pricing_rules = PricingRules.new(
        "A" => {unit_price: 50, discount_price: 130, discount_count: 3})
      checkout = CheckOut.new(pricing_rules)

      checkout.scan('A')
      checkout.scan('A')
      checkout.scan('A')
      total = checkout.total

      expect(total).to eq 130
     end
   end

Notice that some new contexts have been added;

1. 'when B, A and then D have been scanned'
2. 'when B, A and then D have been scanned'
3. 'when A, A, and another A have been scanned'

These new contexts are meant to handle the situations for discounts.

These tests run successfully;

./bin/rspec spec/checkout_spec.rb:4
Run options: include {:locations=>{"./spec/checkout_spec.rb"=>[4]}}

Randomized with seed 1369

checkout
  when B, A and another B has been scanned
    shows the total discounted price of B plus price of A
  when nothing has been scanned
    shows total of zero
  when A has been scanned
    shows the price of A
  when D has been scanned
    shows the price of D
  when B has been scanned
    shows the price of B
  when A, A, and another A have been scanned
    shows the total discounted price of three A items
  when C has been scanned
    shows the price of C
  when B, A and then D have been scanned
    shows the total price of B, A and D

Finished in 0.00125 seconds (files took 0.05214 seconds to load)
8 examples, 0 failures

Randomized with seed 1369


Press ENTER or type command to continue

Conclusion:

This concludes the series.

Shout out to Rob for his immense assistance on this and making it easy to comprehend.

The final project can be found here.

Introduction:

In part 1, this was achieved;

1. Initialising project
2. Writing a test for when nothing has been scanned

In part 2, this is going to be handled;

1. Scanning of A
2. Scanning of B
3. Scanning of C
4. Scanning of D

Tests will be run using;

1. ⎵ + t : run entire test (⎵ means the keyboard space bar button)
2. ⎵ + l : run last test
3. ⎵ + s: run nearest test

Scanning of A:

Add another context to check for when A has been scanned. The file changes to this;

class CheckOut
  def initialize(pricing_rules)

  end

  def total
    0
  end
end

RSpec.describe 'checkout' do
  context 'when nothing has been scanned' do
    it 'shows a total of zero' do
      pricing_rules = :Rule
      checkout = CheckOut.new(pricing_rules)
      total = checkout.total

      expect(total).to eq 0
    end
  end
  context 'when A has been scanned' do
    it 'shows the price of A' do

      expect(total).to eq 50
    end
  end
end

Run the test by pressing ⎵ + t. We get this error;

~
./bin/rspec spec/check_out_spec.rb

Randomized with seed 34364
.F

Failures:

  1) checkout when A has been scanned shows the price of A
     Failure/Error: expect(total).to eq 50

     NameError:
       undefined local variable or method `total' for #<RSpec::ExampleGroups::Checkout::WhenAHasBeenScanned "shows the price of A" (./spec/check_out_spec.rb:22)>
     # ./spec/check_out_spec.rb:24:in `block (3 levels) in <top (required)>'

Finished in 0.00256 seconds (files took 0.05539 seconds to load)
2 examples, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:22 # checkout when A has been scanned shows the price of A

Randomized with seed 34364


shell returned 1

Press ENTER or type command to continue

Modify the file to add the lines specifying what total is and define pricing_rules;

class CheckOut
  def initialize(pricing_rules)

  end

  def total
    0
  end
end

RSpec.describe 'checkout' do
  context 'when nothing has been scanned' do
    it 'shows a total of zero' do
      pricing_rules = :Rule
      checkout = CheckOut.new(pricing_rules)
      total = checkout.total

      expect(total).to eq 0
    end
  end
  context 'when A has been scanned' do
    it 'shows the price of A' do
      pricing_rules = :Rule
      checkout = CheckOut.new(pricing_rules)
      total = checkout.total

      expect(total).to eq 50
    end
  end
end

When the test is run, as expected we get the error as shown below;

./bin/rspec spec/check_out_spec.rb

Randomized with seed 5579
.F

Failures:

  1) checkout when A has been scanned shows the price of A
     Failure/Error: expect(total).to eq 50

       expected: 50
            got: 0

       (compared using ==)
     # ./spec/check_out_spec.rb:27:in `block (3 levels) in <top (required)>'

Finished in 0.00758 seconds (files took 0.0523 seconds to load)
2 examples, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:22 # checkout when A has been scanned shows the price of A

Randomized with seed 5579


shell returned 1

Press ENTER or type command to continue

A change needs to be made to the spec to include scanning of Item A. This changes the file to be;

 class CheckOut
   def initialize(pricing_rules)

   end

   def total
     0
   end
 end

 RSpec.describe 'checkout' do
   context 'when nothing has been scanned' do
     it 'shows a total of zero' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)
       total = checkout.total

       expect(total).to eq 0
     end
   end
   context 'when A has been scanned' do
     it 'shows the price of A' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)

       checkout.scan('A')
       total = checkout.total

       expect(total).to eq 50
     end
   end
 end

When checkout.scan('A') is added, we get this error;

./bin/rspec spec/check_out_spec.rb

Randomized with seed 45438
.F

Failures:

  1) checkout when A has been scanned shows the price of A
     Failure/Error: checkout.scan('A')

     NoMethodError:
       undefined method `scan' for #<CheckOut:0x0000000130ca8448>
     # ./spec/check_out_spec.rb:26:in `block (3 levels) in <top (required)>'

Finished in 0.00187 seconds (files took 0.04966 seconds to load)
2 examples, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:22 # checkout when A has been scanned shows the price of A

Randomized with seed 45438


shell returned 1

Press ENTER or type command to continue

Add the method: scan(item) to CheckOut class to fix this error;

class CheckOut
  def initialize(pricing_rules)

  end

  def total
    0
  end

  def scan(item)

  end
end

Now we are back to the previous error when the test is run;

./bin/rspec spec/check_out_spec.rb

Randomized with seed 56370
.F

Failures:

  1) checkout when A has been scanned shows the price of A
     Failure/Error: expect(total).to eq 50

       expected: 50
            got: 0

       (compared using ==)
     # ./spec/check_out_spec.rb:33:in `block (3 levels) in <top (required)>'

Finished in 0.00768 seconds (files took 0.04974 seconds to load)
2 examples, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:26 # checkout when A has been scanned shows the price of A

Randomized with seed 56370


shell returned 1

Press ENTER or type command to continue

To fix this error, we make three changes to the CheckOut class as below;

 class CheckOut
   def initialize(pricing_rules)
     @total = 0
   end

   def total
     @total
   end

   def scan(item)
     @total = 50
   end
 end

Now when the test is run, all the current two tests will pass successfully;

./bin/rspec spec/check_out_spec.rb

Randomized with seed 4857
..

Finished in 0.00201 seconds (files took 0.04948 seconds to load)
2 examples, 0 failures

Randomized with seed 4857


Press ENTER or type command to continue

Scanning of B:

Add another context to check for when B has been scanned. Add the context to the RSpec.describe 'checkout' block.

The file changes to this;

 RSpec.describe 'checkout' do
   context 'when nothing has been scanned' do
     it 'shows a total of zero' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)
       total = checkout.total

       expect(total).to eq 0
     end
   end
   context 'when A has been scanned' do
     it 'shows the price of A' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)

       checkout.scan('A')
       total = checkout.total

       expect(total).to eq 50
     end
   end
   context 'when B has been scanned' do
     it 'shows the price of B' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)

       checkout.scan('B')
       total = checkout.total

       expect(total).to eq 30
     end
   end
 end

When ⎵ + s is pressed on the keyboard to only run this new test, the following error is displayed;

./bin/rspec spec/check_out_spec.rb:36
Run options: include {:locations=>{"./spec/check_out_spec.rb"=>[36]}}

Randomized with seed 53332
F

Failures:

  1) checkout when B has been scanned shows the price of B
     Failure/Error: expect(total).to eq 30

       expected: 30
            got: 50

       (compared using ==)
     # ./spec/check_out_spec.rb:44:in `block (3 levels) in <top (required)>'

Finished in 0.00643 seconds (files took 0.0565 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:37 # checkout when B has been scanned shows the price of A

Randomized with seed 53332


shell returned 1

Press ENTER or type command to continue

To fix this, make changes to the scan method in the CheckOut class;

class CheckOut
  def initialize(pricing_rules)
    @total = 0
  end

  def total
    @total
  end

  def scan(item)
    if item == 'A'
      @total = 50
    elsif item == 'B'
      @total = 30
    end
  end
end

Now when press ⎵ + l to run the last test, the test for scanning B now passes as well;

./bin/rspec spec/check_out_spec.rb:40
Run options: include {:locations=>{"./spec/check_out_spec.rb"=>[40]}}

Randomized with seed 59538
.

Finished in 0.00059 seconds (files took 0.05165 seconds to load)
1 example, 0 failures

Randomized with seed 59538


Press ENTER or type command to continue

Scanning of C:

Add another context to check for when C has been scanned. Add the context to the RSpec.describe 'checkout' block.

This is the context;

   context 'when C has been scanned' do
     it 'shows the price of C' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)

       checkout.scan('C')
       total = checkout.total

       expect(total).to eq 20
     end
   end

When + s is pressed to run this new test, this error results;

./bin/rspec spec/check_out_spec.rb:59
Run options: include {:locations=>{"./spec/check_out_spec.rb"=>[59]}}

Randomized with seed 51710
F

Failures:

  1) checkout when C has been scanned shows the price of C
     Failure/Error: expect(total).to eq 20

       expected: 20
            got: 0

       (compared using ==)
     # ./spec/check_out_spec.rb:59:in `block (3 levels) in <top (required)>'

Finished in 0.00602 seconds (files took 0.05125 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:52 # checkout when C has been scanned shows the price of C

Randomized with seed 51710


shell returned 1

Press ENTER or type command to continue

To fix this, make changes to the CheckOut class.

Do a check for item C like so;

 class CheckOut
   def initialize(pricing_rules)
     @total = 0
   end

   def total
     @total
   end

   def scan(item)
     if item == 'A'
       @total = 50
     elsif item == 'B'
       @total = 30
     elsif item == 'C'
       @total = 20
     end
   end
 end

And now when the test is run, it should be pass;

./bin/rspec spec/check_out_spec.rb:59
Run options: include {:locations=>{"./spec/check_out_spec.rb"=>[59]}}

Randomized with seed 2878
.

Finished in 0.00068 seconds (files took 0.05424 seconds to load)
1 example, 0 failures

Randomized with seed 2878


Press ENTER or type command to continue

Scanning of D:

Add another context to check for when D has been scanned. Add the context to the RSpec.describe 'checkout' block.

This is the context;

   context 'when D has been scanned' do
     it 'shows the price of D' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)

       checkout.scan('D')
       total = checkout.total

       expect(total).to eq 15
     end
   end

When + s is pressed to run this new test, this error results;

./bin/rspec spec/check_out_spec.rb:72
Run options: include {:locations=>{"./spec/check_out_spec.rb"=>[72]}}

Randomized with seed 61671
F

Failures:

  1) checkout when D has been scanned shows the price of D
     Failure/Error: expect(total).to eq 15

       expected: 15
            got: 0

       (compared using ==)
     # ./spec/check_out_spec.rb:72:in `block (3 levels) in <top (required)>'

Finished in 0.00622 seconds (files took 0.0561 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:65 # checkout when D has been scanned shows the price of D

Randomized with seed 61671


shell returned 1

Press ENTER or type command to continue

To fix this, make changes to the CheckOut class.

Add an else to check for item D;

 class CheckOut
   def initialize(pricing_rules)
     @total = 0
   end

   def total
     @total
   end

   def scan(item)
     if item == 'A'
       @total = 50
     elsif item == 'B'
       @total = 30
     elsif item == 'C'
       @total = 20
     else 
       @total = 15
     end
   end
 end

And now when the test is run, it should be pass;

./bin/rspec spec/check_out_spec.rb:72
Run options: include {:locations=>{"./spec/check_out_spec.rb"=>[72]}}

Randomized with seed 38120
.

Finished in 0.00059 seconds (files took 0.05152 seconds to load)
1 example, 0 failures

Randomized with seed 38120


Press ENTER or type command to continue

Conclusion:

This concludes part 2.

In part 3, this will handled;

1. refactoring to make the code better.
2. taking the pricing rules into account

Shout out to Rob for his immense assistance on this and making it easy to comprehend.

Introduction:

The challenge was to implement the code for a checkout system that handles pricing schemes such as “apples cost 50 cents, three apples cost $1.30.”

The basic guidelines on how to implement the kata can be found here

The idea is to use the Red, Green, Refactor approach.

Write a failing test, and then write little code to get the failing test to pass and then clean up the code.

Initialising project:

1. Navigate to an appropriate directory: ~ cd practice
2. Create a new directory & change to it: ~ mkdir checkout && cd $_
3. Create and edit Gemfile: vim Gemfile (vim is being used as the editor for this project)

# frozen_string_literal: true

source "https://rubygems.org"

git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }

gem 'rspec'

1. Press ctrl + z to navigate back to terminal and then type bundle binstubs --all (including binstubs --all after bundle is a shortcut to not use bundle exec when running the rspec command)
2. Type bin/rspec --init to initialise rspec (a spec folder will be created)

Writing the first test:

1. Create a new file under the spec folder: touch spec/check_out_spec.rb

2. Write the first failing test which checks when nothing has been scanned;

   RSpec.describe 'checkout' do
   context 'when nothing has been scanned' do
     it 'shows a total of zero' do
   
       expect(total).to eq 0
     end
   end
   end
   

3. As expected, this test fails when ⎵ + t is pressed on the keyboard;

./bin/rspec spec/check_out_spec.rb

Randomized with seed 59413
F

Failures:

  1) checkout when nothing has been scanned shows a total of zero
     Failure/Error: expect(total).to eq 0

     NameError:
       undefined local variable or method `total' for #<RSpec::ExampleGroups::Checkout::WhenNothingHasBeenScanned "shows a total of zero" (./spec/check_out_spec.rb:3)>
     # ./spec/check_out_spec.rb:5:in `block (3 levels) in <top (required)>'

Finished in 0.00169 seconds (files took 0.04863 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:3 # checkout when nothing has been scanned shows a total of zero

Randomized with seed 59413


shell returned 1

Press ENTER or type command to continue

1. Let us incrementally get this test to pass. The feedback loop with TDD is second to none as the error actually tells us what to do next

   RSpec.describe 'checkout' do
   context 'when nothing has been scanned' do
    it 'shows a total of zero' do
      pricing_rules = :Rule
      checkout = CheckOut.new(pricing_rules)
      total = checkout.total
   
      expect(total).to eq 0
    end
   end
   end
   

   In the above code snippet, two lines have been added; pricing_rules = :Rule and checkout = CheckOut.new(pricing_rules)

The error is now different;

~
./bin/rspec spec/check_out_spec.rb

Randomized with seed 59719
F

Failures:

  1) checkout when nothing has been scanned shows a total of zero
     Failure/Error: checkout = CheckOut.new(pricing_rules)

     NameError:
       uninitialized constant CheckOut
     # ./spec/check_out_spec.rb:5:in `block (3 levels) in <top (required)>'

Finished in 0.00174 seconds (files took 0.04954 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:3 # checkout when nothing has been scanned shows a total of zero

Randomized with seed 59719


shell returned 1

Press ENTER or type command to continue

Now we create add a class: CheckOut as the code below;

 class CheckOut

 end

 RSpec.describe 'checkout' do
   context 'when nothing has been scanned' do
     it 'shows a total of zero' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)
       total = checkout.total

       expect(total).to eq 0
     end
   end
 end

Now, this is the error returned;

~
./bin/rspec spec/check_out_spec.rb

Randomized with seed 45459
F

Failures:

  1) checkout when nothing has been scanned shows a total of zero
     Failure/Error: checkout = CheckOut.new(pricing_rules)

     ArgumentError:
       wrong number of arguments (given 1, expected 0)
     # ./spec/check_out_spec.rb:9:in `initialize'
     # ./spec/check_out_spec.rb:9:in `new'
     # ./spec/check_out_spec.rb:9:in `block (3 levels) in <top (required)>'

Finished in 0.00264 seconds (files took 0.05216 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:7 # checkout when nothing has been scanned shows a total of zero

Randomized with seed 45459


shell returned 1

Press ENTER or type command to continue

Now we can write code to solve the above error. It would look something like so;

 class CheckOut
   def initialize(pricing_rules)

   end

 end

 RSpec.describe 'checkout' do
   context 'when nothing has been scanned' do
     it 'shows a total of zero' do
       pricing_rules = :Rule
       checkout = CheckOut.new(pricing_rules)
       total = checkout.total

       expect(total).to eq 0
     end
   end
 end

For this, we get the undefined method total as the error shows;

~
./bin/rspec spec/check_out_spec.rb

Randomized with seed 46712
F

Failures:

  1) checkout when nothing has been scanned shows a total of zero
     Failure/Error: total = checkout.total

     NoMethodError:
       undefined method `total' for #<CheckOut:0x000000013952bd60>
     # ./spec/check_out_spec.rb:13:in `block (3 levels) in <top (required)>'

Finished in 0.00174 seconds (files took 0.05301 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:10 # checkout when nothing has been scanned shows a total of zero

Randomized with seed 46712


shell returned 1

Press ENTER or type command to continue

To fix the error, add a method: total as shown below;

class CheckOut
  def initialize(pricing_rules)

  end

  def total

  end
end

RSpec.describe 'checkout' do
  context 'when nothing has been scanned' do
    it 'shows a total of zero' do
      pricing_rules = :Rule
      checkout = CheckOut.new(pricing_rules)
      total = checkout.total

      expect(total).to eq 0
    end
  end
end

We now get another error as shown;

~
./bin/rspec spec/check_out_spec.rb

Randomized with seed 15684
F

Failures:

  1) checkout when nothing has been scanned shows a total of zero
     Failure/Error: expect(total).to eq 0

       expected: 0
            got: nil

       (compared using ==)
     # ./spec/check_out_spec.rb:18:in `block (3 levels) in <top (required)>'

Finished in 0.00714 seconds (files took 0.05137 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/check_out_spec.rb:13 # checkout when nothing has been scanned shows a total of zero

Randomized with seed 15684


shell returned 1

Press ENTER or type command to continue

Now, to get this to pass, we need to change the total method to return 0;

class CheckOut
  def initialize(pricing_rules)

  end

  def total
    0
  end
end

RSpec.describe 'checkout' do
  context 'when nothing has been scanned' do
    it 'shows a total of zero' do
      pricing_rules = :Rule
      checkout = CheckOut.new(pricing_rules)
      total = checkout.total

      expect(total).to eq 0
    end
  end
end

Below is the output of the passing test;

~
./bin/rspec spec/check_out_spec.rb

Randomized with seed 9210
.

Finished in 0.00187 seconds (files took 0.04874 seconds to load)
1 example, 0 failures

Randomized with seed 9210


Press ENTER or type command to continue

This is just one of the tests though. Other tests need to be done i.e. when A has been scanned, when B has been scanned, when C has been scanned, when D has been scanned

This concludes part 1.

In part 2, we will tackle how to handle tests for the scanning of A, B, C & D.

In part 3, we will do some refactoring to make the code better.

Shout out to Rob for his immense assistance on this and making it easy to comprehend.