Toying around with stub and mock on Minitest

account_member_test.rb

class AccountMemberTest < ActiveSupport::TestCase
  test "Select only Accepted status" do
    create_list(:account, 5, :with_user)

    accepted_member = AccountMember.accepted

    assert_equal 5, accepted_member.count
  end

  test "Select only owner" do
    create_list(:account, 5, :with_user)

    assert_equal 5, AccountMember.owner.count
  end

  test "Select only owner and Accepted status" do
    owner_setsuna    = create(:user, first_name: "Setsuna", email: "setsuna@gundam.com")
    account_setsuna  = create(:account, name: "Exia", owner: owner_setsuna)
    user_lockon      = create(:user, first_name: "Lockon", email: "lockon@gundam.com")
    member_lockon    = create(:account_member, account: account_setsuna, user: user_lockon, status: AccountMember::PENDING)

    owner_amuro      = create(:user, first_name: "Amuro", email: "amuro@gundam.com")
    account_amuro    = create(:account, name: "RX 78-2", owner: owner_amuro)
    user_ryu         = create(:user, first_name: "Ryu", email: "ryu@gundam.com")
    member_ryu       = create(:account_member, account: account_amuro, user: user_ryu, status: AccountMember::ACCEPTED)

    owner_banagher   = create(:user, first_name: "Banagher", email: "banagher@gundam.com")
    account_banagher = create(:account, name: "Unicorn", owner: owner_banagher)

    assert_equal 4, AccountMember.shown.count
  end

  test "Select only is_default equal true" do
    user    = create(:user, first_name: "Setsuna", email: "exia@gundam.com")
    account = create(:account, name: "Celestial Being", owner: user)

    create_list(:account_member, 5, is_default: true, account: account)

    # +1 is account member default created by Account#create_default_account_member via after_create callback
    assert_equal 5 + 1, AccountMember.defaults.count
  end

  test "Return true if status is 'Pending'" do
    account_member = build(:account_member, status: AccountMember::PENDING)

    assert account_member.is_pending?
  end

  test "Return true if status is 'Invited'" do
    account_member = build(:account_member, status: AccountMember::INVITED)

    assert account_member.is_invited?
  end

  test "Return true if status is 'Accepted'" do
    account_member = build(:account_member, status: AccountMember::ACCEPTED)

    assert account_member.is_accepted?
  end

  test "Return true if user_id is equal to Account#owner_id" do
    user           = create(:user, first_name: "The Owner", email: "owner@mail.com")
    account        = create(:account, name: "MyCompany", owner: user)
    account_member = account.account_members.first

    assert account_member.is_owner?
  end

  test "Accept the invitation" do
    account_member = create(:account_member)
    user           = create(:user, email: account_member.email)

    assert_nil account_member.user_id
    assert_equal AccountMember::INVITED, account_member.status

    account_member.accept!

    assert_equal user.id, account_member.user_id
    assert_equal AccountMember::ACCEPTED, account_member.status
  end

  test "Resend the invitation, status back to 'Invited'" do
    account_member = create(:account_member, status: AccountMember::ACCEPTED)

    account_member.resend!

    assert_equal AccountMember::INVITED, account_member.status
  end

  test "Send the invitation, status change from  'Pending' to Invited'" do
    account_member = build(:account_member)

    assert_equal AccountMember::PENDING, account_member.status

    # account_member.send_invitation is invoked on after_create callback
    account_member.save

    assert_equal AccountMember::INVITED, account_member.status
  end

  test "Transfer ownership" do
    user      = create(:user, first_name: "The Owner", email: "old_owner@mail.com")
    account   = create(:account, name: "MyCompany", owner: user)
    old_owner = account.account_members.first

    assert_equal account.owner_id, old_owner.user_id
    assert old_owner.is_owner?

    new_user  = create(:user, first_name: "The New Owner", email: "new_owner@mail.com")
    new_owner = create(:account_member, account: account, email: new_user.email, status: AccountMember::ACCEPTED, user: new_user)

    refute new_owner.is_owner?
    assert_equal old_owner.account_id, new_owner.account_id

    new_owner.transfer_owner!

    old_owner.reload

    assert_equal account.owner_id, new_owner.user_id
    refute old_owner.is_owner?
    assert new_owner.is_owner?
  end

  test "Learning stub" do
    require 'minitest/mock'

    class Tahu
      def jos
        "tahuuuuu"
      end
    end

    class TahuPalsu
      def jos
        "tahuuuuu palsu"
      end
    end

    class MainCourse
      def jos
        Tahu.new.jos
      end
    end

    tahu = Tahu.new

    tahu.stub :jos, "Tempeee" do
      puts MainCourse.new.jos
      puts tahu.jos
    end

    Tahu.stub :new, TahuPalsu.new do
      puts MainCourse.new.jos
      # puts Tahu.new
      # puts TahuPalsu.new.jos
    end
  end

  test "Learning mock" do
    require "minitest/mock"

    class Tahu
      def jos
        "tahuuuuu"
      end
    end

    class MainCourse
      def jos
        Tahu.new.jos
      end
    end

    mock = Minitest::Mock.new
    def mock.jos; "MOCK MOCK MOCK"; end

    mock.expect :jos, "MOCK MOCK MOCK"

    Tahu.stub :new, mock do
      puts MainCourse.new.jos
    end

    mock.verify
  end
end