DEV Community: YC Yap

Testing concerns in rails

YC Yap — Tue, 15 Sep 2020 00:56:47 +0000

Rails's ActiveSupport::Concern can be a useful place to put code that needs to be shared across classes. It is also a way to implement multiple inheritance.

When it comes to testing a concern, we want to be testing the behaviour instead of the class which implements the concern, as it can be shared among multiple classes.

One of my preferred way to test a concern is to use a dummy class which inherits from ActiveRecord,it gives me confidence that i am testing against my actual ActiveRecord models.

module Personable
  extend ActiveSupport::Concern

  def full_name
    "#{first_name} #{last_name}"
  end
end

require 'rails_helper'

RSpec.describe Personable do
  it 'has a full name' do
    person = DummyPerson.new(first_name: 'yc', last_name: 'yap')
    expect(person.full_name).to eq 'yc yap'
  end
end

class DummyPerson < ActiveRecord::Base
  self.table_name = 'users'

  include Personable
end

[TIL] Typescript index signatures

YC Yap — Thu, 09 Apr 2020 01:46:04 +0000

I have recently encountered a problem while porting my toy react application from Javascript to Typescript, this toy-application , fetches all the popular repos from Github and displays them on the page.

The object looks something like this:

const [repos, setRepos ] = useState<{}>({})
{
'All': object,
'Ruby': object,
'Javascript: object
}

Problem arises when you try to access the repos object, Typescript compiler throws a type mismatch error. ( Element implicitly has an 'any' type because expression of type 'string' can't be used to index type '{}'.)

repos[selectedLanguage]

To solve this, i needed to define an interface in which any string can be as index for the object, it looks something like this.

interface Repos{
  [key: string]: object
}

Use the interface as the generic type for setState

const [repos, setRepos ] = useState<{Repos}>({})

And the problem goes away

repos[selectedLanguage]

[TIL] Debugging external gem in Ruby

YC Yap — Tue, 04 Feb 2020 09:12:31 +0000

Sometimes there comes a time where an external gem that you installed is not behaving as expected. It was not until a week ago that i learned from my colleague that you can actually open the gems to inspect the code inside the gem and debugging it using a debugger.

Firstly, you can open the gem by running.

bundle open countries

Identify the part of the code which you wish to debug. For example i would like to understand why a method in the gem 'countries' is not returning values as expected.

Start inserting calls to debugger in places you expect it to call.

require 'byebug'

module ISO3166
  class Country
    def initialize(country_data)
      byebug
      @country_data_or_code = country_data
      reload
    end
  end
end

Using debugger allows you to better understand the code execution, so that variables which are causing the unexpected behaviours during the execution call be be inspected.

Running a book club in PostCo

YC Yap — Mon, 30 Dec 2019 06:34:52 +0000

This article will be about our learnings running a tech book club in PostCo for the past 3 months.

Our motivation
We want to try to cultivate a strong learning culture in PostCo, book clubs are a fast way to encourage cross learning and healthy discussion among team members. We decided to start with a book that is simple enough and is on everybody’s reading list, Pragmatic Programmer by Dave Thomas and Andy Hunt.

Running the book club

Setup a recurring calendar invite
A Github wiki to keep track of the discussions.
Inform ahead to the participants which chapter will be in discussion.
We encourage everyone to go through the chapters, so that everyone is in line with the topics that will be discussed in the book club sessions. This allows conversation and discussion to flow more smoothly.

Learnings:

We would encourage active participation by encouraging questions in the middle of the session.
Create a page, in which participants can propose new books for the book club.
One person leading the talk normally does not work, participants will rely too much on the lead to delivery book’s content rather than reading the content themselves.
Active participation, where participants should bring up topics they found interesting in the chapter.
Generate follow-up discussion in Slack channel participants can post interesting blogs, videos, papars that related to the day.

Some of the books which are currently in our list.

Seven Databases in Seven weeks
99 Bottles by Sandi Metz
Structure and Interpretation of Computer Programs
Design patterns in Ruby

Conclusion
Book clubs are a great way to level up your team, and encourage healthy discussion between members.