TILs - Fueling Curiosity, One Insight at a Time

RSpec.shared_context "user and post setup", shared_context: :metadata do
  let(:user) { User.create(name: "Alice") }
  let(:post) { Post.create(title: "First Post", user: user) }
end

RSpec.describe "Using shared context in tests" do
  include_context "user and post setup"

  it "has a user with a name" do
    expect(user.name).to eq("Alice")
  end

  it "has a post with a title" do
    expect(post.title).to eq("First Post")
  end
end

SELECT DISTINCT ON (user_id, event_name) id, user_id, event_name, inquiry_id, created_at
FROM public.persona_inquiry
ORDER BY user_id, event_name, created_at DESC;

class Current < ActiveSupport::CurrentAttributes
  attribute :role
end

class ApplicationController < ActionController::Base  
  before_action :set_current_attributes

  def set_current_attributes
    Current.role = session[:role]
    // ... other attributes
  end
end

mise use -g ruby@3

curl https://mise.run | sh

echo 'eval "$(~/.local/bin/mise activate)"' >> ~/.zshrc

source ~/.zshrc

class MyClass
  mattr_accessor :my_variable
end

class MyClass
  @my_variable = nil

  def self.my_variable
    @my_variable
  end

  def self.my_variable=(value)
    @my_variable = value
  end
end

class User < ApplicationRecord
  has_one :profile
  accepts_nested_attributes_for :profile
end

user_params = {
  name: "John Doe",
  profile_attributes: { bio: "Developer", age: 30 }
}

user = User.create(user_params)

# config/initializers/pagy.rb

require "pagy/extras/array"

def index
 // some code
 @pagy, @purchase_order_attachments = pagy_array(orders_with_attachments, items: params[:limit] || 10)
end

class MyClass:
    class_variable = "Class Variable"

    def __init__(self):
        self.instance_variable = "Instance Variable"

    def my_method(self):
        pass

obj = MyClass()
print(dir(obj))

ssh -vT "[email protected]"

let value: string;
console.log(value); // TS4.x: This was allowed but could lead to runtime undefined

let value: string;
console.log(value); // TS5.x: Error - Variable 'value' is used before being assigned

// To fix, either initialize:
let value = "initial";

// Or use definite assignment assertion:
let value!: string;

class UserProfileForm
  include ActiveModel::Model

 # Attributes accessible for the form object.
  attr_accessor :user_name, :email, :profile_bio, :profile_age

  validates :user_name, :email, presence: true
  validates :profile_age, numericality: { only_integer: true, greater_than: 0 }

  def save
    return false unless valid?
    
    #a single transaction for multiple operations
    ActiveRecord::Base.transaction do
      user = User.create!(name: user_name, email: email)
      user.create_profile!(bio: profile_bio, age: profile_age)
    end

    true # Return true if all operations succeed.
  rescue ActiveRecord::RecordInvalid
    false # Return false if the save process fails.
  end
end

class UsersController < ApplicationController
  def new
    @form = UserProfileForm.new
  end

  def create
    @form = UserProfileForm.new(user_profile_form_params)

    if @form.save
      redirect_to root_path, notice: "User created successfully!"
    else
      render :new, status: :unprocessable_entity
    end
  end

  private

  def user_profile_form_params
    params.require(:user_profile_form).permit(:user_name, :email, :profile_bio, :profile_age)
  end
end

openssl pkcs12 -export -out certificate.pfx -inkey privatekey.pem -in certificate.pem -certfile ca-chain.pem

openssl pkcs12 -info -in certificate.pfx

class CoinsValidator < Dry::Validation::Contract
  params do
    required(:user).filled(:integer)
    required(:coins).filled(:integer, gt?: 0)
  end

  rule(:user) do
    member = Member.find_by(unique_id: value) // querying database for member details
    key.failure("does not exist") if member.nil?
  end

  rule(:coins, :user) do
    member = Member.find_by(unique_id: values[:user]) // querying database for member details
    if member && member.coins < values[:coins]
      key(:coins).failure("are insufficient")
    end
  end
end

class CoinsValidator < Dry::Validation::Contract
  params do
    required(:user).filled(:integer)
    required(:coins).filled(:integer, gt?: 0)
  end

  rule(:user) do
    values[:member] = Member.find_by(unique_id: value)  // Caching the member object
    key.failure("does not exist") if values[:member].nil?
  end

  rule(:coins) do
    member = values[:member]  // accessing the cached Member from values[:member] rather than querying the database again.
    if member && member.coins < value
      key.failure("are insufficient")
    end
  end
end

jest.useFakeTimers();

test("delayed greeting is sent after 3 seconds", () => {
  const callback = jest.fn();

  setTimeout(() => callback("Hello!"), 3000);
  jest.runAllTimers();

  expect(callback).toHaveBeenCalledWith("Hello!");
});

class Person
  attr_reader :name

  def initialize(name)
    @name = name
  end
end

person = Person.new("Sibtain")
puts person.name  # Outputs: Sibtain

class Person
  attr_accessor :name

  def initialize(name)
    @name = name
  end
end

person = Person.new("Sibtain")
puts person.name  # Outputs: Sibtain

person.name = "John"
puts person.name  # Outputs: John

import { useForm, useFieldArray } from "react-hook-form";

function DynamicForm() {
  const { register, control, handleSubmit, formState: { errors } } = useForm({
    defaultValues: {
      questions: [{ question: "" }],
    },
  });

  // UseFieldArray to handle the questions array dynamically
  const { fields, append, remove } = useFieldArray({
    control,
    name: "questions",  // Name of the array in the form's state
  });

  const onSubmit = (data: any) => {
    console.log(data); // Submitting form data with dynamic fields
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      {fields.map((item, index) => (
        <div key={item.id}>
          <input
            {...register(`questions.${index}.question`)}  // Register each question dynamically
            defaultValue={item.question}  // Set default value for each item in the array
          />
          {errors.questions?.[index]?.question && (
            <span>{errors.questions[index]?.question.message}</span>
          )}
          <button type="button" onClick={() => remove(index)}>Remove</button>
        </div>
      ))}
      
      <button type="button" onClick={() => append({ question: "" })}>
        Add Question
      </button>

      <button type="submit">Submit</button>
    </form>
  );
}

const response = await slackClient.chat.deleteScheduledMessage({
  channel: channelId, {// ID of the channel where the message was scheduled }
  scheduled_message_id: scheduledMessageId, {// ID of the scheduled message to delete}
});

require 'webmock/webmock_api.rb'

config.before(:each) do
    stub_request(:any, /domain_name/).to_rack(WebmockApi
end

# spec/fixtures/member_api_success.json
[
  {
    "id": 1,
    "name": "John Doe",
    "email": "[email protected]",
    "phone": "123-456-7890",
    "membership_type": "Gold",
    "status": "active"
  },
  {
    "id": 2,
    "name": "Jane Smith",
    "email": "[email protected]",
    "phone": "987-654-3210",
    "membership_type": "Silver",
    "status": "inactive"
  }
]

class WebmockApi
  SPEC_FIXTURES_PATH = 'spec/fixtures'.freeze
  MEMBERS_SUCCESS = File.read("#{SPEC_FIXTURES_PATH}/members_api_success.json").freeze
  POSTS_SUCCESS = File.read("#{SPEC_FIXTURES_PATH}/posts_api_success.json").freeze
  ERROR = File.read("#{SPEC_FIXTURES_PATH}/error.json").freeze

  def self.call(env)
    new.call(env)
  end

  def call(env)
    action = env['REQUEST_METHOD']
    path = env['PATH_INFO']
    params = env['QUERY_STRING']

    case path
    when '/external_members_api_path'
      params.include?('test_user') ? [ 200, {}, [ MEMBERS_SUCCESS ] ] : [ 500, {}, [ ERROR ] ]
    when '/external_post_api_path'
      params.include?('new_post') ? [ 200, {}, [ POSTS_SUCCESS ] ] : [ 500, {}, [ ERROR ] ]
    end
  end
end

require 'rails_helper'
require 'webmock/rspec'

RSpec.describe "Members", type: :request do
  describe "GET /members_search_path" do
    context "when the members API call is successful" do
      it "returns member details from the API" do
        get "/external_members_api_path", params: { member: "test_user" }

        expect(response).to have_http_status(:ok)
        user = response.parsed_body["member"]
        expect(["id"]).to eq("123456")
        expect(user["name"]).to eq("abc")
      end
    end
    
    context "when the members API call is successful" do
      it "returns error message from the API" do
        get "/external_members_api_path", params: { member: "unknown_user" }

        expect(response).to have_http_status(:ok)
        expect(response).to have_http_status(:internal_server_error)
        error = response.parsed_body["error"]
        expect(error).to eq("Something went wrong")
      end
    end
  end
end