anima-core 0.3.0 → 1.0.0

data/skills/rspec/examples/rails/mailer_specs.rb

@@ -0,0 +1,228 @@
+# RSpec Rails: Mailer Specs Examples
+# Source: rspec-rails gem features/mailer_specs/
+
+# Mailer specs test ActionMailer classes.
+# Location: spec/mailers/
+
+# Basic mailer spec
+RSpec.describe NotificationsMailer, type: :mailer do
+  describe "#signup" do
+    let(:mail) { NotificationsMailer.signup }
+
+    it "renders the headers" do
+      expect(mail.subject).to eq("Signup")
+      expect(mail.to).to eq(["to@example.org"])
+      expect(mail.from).to eq(["from@example.com"])
+    end
+
+    it "renders the body" do
+      expect(mail.body.encoded).to include("Hi")
+    end
+  end
+end
+
+# Testing with dynamic recipient
+RSpec.describe WelcomeMailer, type: :mailer do
+  describe "#welcome" do
+    let(:user) { create(:user, email: "john@example.com", name: "John") }
+    let(:mail) { WelcomeMailer.welcome(user) }
+
+    it "sends to the user email" do
+      expect(mail.to).to eq(["john@example.com"])
+    end
+
+    it "personalizes the greeting" do
+      expect(mail.body.encoded).to include("Hello John")
+    end
+
+    it "includes welcome link" do
+      expect(mail.body.encoded).to include(dashboard_url)
+    end
+  end
+end
+
+# Testing multipart emails (HTML and text)
+RSpec.describe NewsletterMailer, type: :mailer do
+  describe "#weekly_digest" do
+    let(:user) { create(:user) }
+    let(:mail) { NewsletterMailer.weekly_digest(user) }
+
+    it "has both HTML and text parts" do
+      expect(mail.parts.length).to eq(2)
+      expect(mail.parts.map(&:content_type)).to include(
+        a_string_matching(/text\/plain/),
+        a_string_matching(/text\/html/)
+      )
+    end
+
+    describe "HTML part" do
+      subject(:html_body) { mail.html_part.body.encoded }
+
+      it "includes styled content" do
+        expect(html_body).to include("<h1>")
+        expect(html_body).to include("Weekly Digest")
+      end
+    end
+
+    describe "text part" do
+      subject(:text_body) { mail.text_part.body.encoded }
+
+      it "includes plain text content" do
+        expect(text_body).to include("Weekly Digest")
+        expect(text_body).not_to include("<h1>")
+      end
+    end
+  end
+end
+
+# Testing email with attachments
+RSpec.describe ReportMailer, type: :mailer do
+  describe "#monthly_report" do
+    let(:mail) { ReportMailer.monthly_report }
+
+    it "includes PDF attachment" do
+      expect(mail.attachments.length).to eq(1)
+      expect(mail.attachments.first.filename).to eq("report.pdf")
+      expect(mail.attachments.first.content_type).to start_with("application/pdf")
+    end
+  end
+end
+
+# Testing delivery
+RSpec.describe OrderMailer, type: :mailer do
+  describe "#confirmation" do
+    let(:order) { create(:order) }
+    let(:mail) { OrderMailer.confirmation(order) }
+
+    it "delivers email" do
+      expect { mail.deliver_now }.to change { ActionMailer::Base.deliveries.count }.by(1)
+    end
+
+    it "queues email for later delivery" do
+      expect { mail.deliver_later }.to have_enqueued_job(ActionMailer::MailDeliveryJob)
+    end
+  end
+end
+
+# send_email matcher (rspec-rails 7.0+)
+RSpec.describe NotificationsMailer, type: :mailer do
+  describe "#alert" do
+    let(:user) { create(:user, email: "user@example.com") }
+
+    it "sends email with correct attributes" do
+      expect {
+        NotificationsMailer.alert(user).deliver_now
+      }.to send_email(
+        from: "alerts@example.com",
+        to: "user@example.com",
+        subject: "Alert Notification"
+      )
+    end
+  end
+end
+
+# Testing email previews exist (meta-test)
+RSpec.describe "Mailer Previews" do
+  it "has preview for WelcomeMailer" do
+    expect(defined?(WelcomeMailerPreview)).to be_truthy
+  end
+end
+
+# Testing with parameterized mailers (Rails 5.1+)
+RSpec.describe NotificationsMailer, type: :mailer do
+  describe "#with parameters" do
+    let(:user) { create(:user) }
+    let(:mail) do
+      NotificationsMailer.with(user:, urgency: :high).important_update
+    end
+
+    it "uses parameterized values" do
+      expect(mail.to).to eq([user.email])
+      expect(mail.subject).to include("[URGENT]")
+    end
+  end
+end
+
+# Testing email headers
+RSpec.describe TransactionalMailer, type: :mailer do
+  describe "#receipt" do
+    let(:order) { create(:order) }
+    let(:mail) { TransactionalMailer.receipt(order) }
+
+    it "sets reply-to header" do
+      expect(mail.reply_to).to eq(["support@example.com"])
+    end
+
+    it "sets custom headers" do
+      expect(mail.headers["X-Transaction-ID"]).to eq(order.id.to_s)
+    end
+
+    it "sets high priority" do
+      expect(mail.headers["X-Priority"]).to eq("1")
+    end
+  end
+end
+
+# Testing mailer with conditional content
+RSpec.describe UserMailer, type: :mailer do
+  describe "#password_reset" do
+    let(:user) { create(:user) }
+    let(:mail) { UserMailer.password_reset(user) }
+
+    context "when user has two-factor enabled" do
+      let(:user) { create(:user, :with_two_factor) }
+
+      it "includes 2FA reminder" do
+        expect(mail.body.encoded).to include("two-factor authentication")
+      end
+    end
+
+    context "when user does not have two-factor" do
+      it "does not mention 2FA" do
+        expect(mail.body.encoded).not_to include("two-factor authentication")
+      end
+    end
+  end
+end
+
+# Testing mailer callbacks
+RSpec.describe AuditableMailer, type: :mailer do
+  describe "after_action callback" do
+    let(:mail) { AuditableMailer.system_notification }
+
+    it "logs email delivery" do
+      expect(EmailLog).to receive(:create!).with(
+        mailer: "AuditableMailer",
+        action: "system_notification"
+      )
+
+      mail.deliver_now
+    end
+  end
+end
+
+# Clearing deliveries between examples
+RSpec.describe "Email delivery", type: :mailer do
+  before { ActionMailer::Base.deliveries.clear }
+
+  it "starts with empty deliveries" do
+    expect(ActionMailer::Base.deliveries).to be_empty
+  end
+
+  it "tracks delivered emails" do
+    NotificationsMailer.signup.deliver_now
+    expect(ActionMailer::Base.deliveries.count).to eq(1)
+  end
+end
+
+# Testing I18n in emails
+RSpec.describe LocalizedMailer, type: :mailer do
+  describe "#welcome" do
+    let(:user) { create(:user, locale: "es") }
+    let(:mail) { LocalizedMailer.welcome(user) }
+
+    it "uses user locale" do
+      expect(mail.subject).to eq("Bienvenido")
+    end
+  end
+end

data/skills/rspec/examples/rails/matchers.rb

@@ -0,0 +1,374 @@
+# RSpec Rails: Rails-Specific Matchers Examples
+# Source: rspec-rails gem features/matchers/
+
+# Rails-specific matchers for testing HTTP responses,
+# redirects, templates, and more.
+
+# have_http_status - testing response codes
+RSpec.describe "have_http_status", type: :request do
+  describe "numeric status codes" do
+    it "matches exact code" do
+      get "/widgets"
+      expect(response).to have_http_status(200)
+    end
+
+    it "matches created status" do
+      post "/widgets", params: { widget: { name: "New" } }
+      expect(response).to have_http_status(201)
+    end
+  end
+
+  describe "symbolic status names" do
+    it "matches :ok" do
+      get "/widgets"
+      expect(response).to have_http_status(:ok)
+    end
+
+    it "matches :created" do
+      post "/api/widgets", params: { widget: { name: "New" } },
+        headers: { "ACCEPT" => "application/json" }
+      expect(response).to have_http_status(:created)
+    end
+
+    it "matches :not_found" do
+      get "/widgets/nonexistent"
+      expect(response).to have_http_status(:not_found)
+    end
+
+    it "matches :unprocessable_entity" do
+      post "/widgets", params: { widget: { name: "" } }
+      expect(response).to have_http_status(:unprocessable_entity)
+    end
+
+    it "matches :unauthorized" do
+      get "/admin/dashboard"
+      expect(response).to have_http_status(:unauthorized)
+    end
+  end
+
+  describe "status type matchers" do
+    it "matches :success (any 2xx)" do
+      get "/widgets"
+      expect(response).to have_http_status(:success)
+    end
+
+    it "matches :redirect (any 3xx)" do
+      post "/widgets", params: { widget: { name: "New" } }
+      expect(response).to have_http_status(:redirect)
+    end
+
+    it "matches :error (any 5xx)" do
+      allow_any_instance_of(WidgetsController).to receive(:index).and_raise(StandardError)
+      get "/widgets"
+      expect(response).to have_http_status(:error)
+    end
+
+    it "matches :missing (404)" do
+      get "/nonexistent"
+      expect(response).to have_http_status(:missing)
+    end
+  end
+end
+
+# redirect_to - testing redirects
+RSpec.describe "redirect_to", type: :controller do
+  controller WidgetsController do
+    def create
+      @widget = Widget.create!(params.require(:widget).permit(:name))
+      redirect_to @widget
+    end
+  end
+
+  describe "POST #create" do
+    let(:valid_params) { { widget: { name: "Test" } } }
+
+    it "redirects to URL" do
+      post :create, params: valid_params
+      expect(response).to redirect_to(widget_url(assigns(:widget)))
+    end
+
+    it "redirects to path" do
+      post :create, params: valid_params
+      expect(response).to redirect_to("/widgets/#{assigns(:widget).id}")
+    end
+
+    it "redirects to hash" do
+      post :create, params: valid_params
+      expect(response).to redirect_to(action: :show, id: assigns(:widget).id)
+    end
+
+    it "redirects to record" do
+      post :create, params: valid_params
+      expect(response).to redirect_to(assigns(:widget))
+    end
+  end
+end
+
+# render_template - testing template rendering
+RSpec.describe "render_template", type: :controller do
+  controller WidgetsController do
+  end
+
+  describe "GET #index" do
+    it "renders index template" do
+      get :index
+      expect(response).to render_template(:index)
+    end
+
+    it "renders with full path" do
+      get :index
+      expect(response).to render_template("widgets/index")
+    end
+
+    it "does not render other templates" do
+      get :index
+      expect(response).not_to render_template("widgets/show")
+    end
+  end
+
+  describe "layout rendering" do
+    it "renders with application layout" do
+      get :index
+      expect(response).to render_template("layouts/application")
+    end
+
+    it "does not render admin layout" do
+      get :index
+      expect(response).not_to render_template("layouts/admin")
+    end
+  end
+
+  describe "partial rendering" do
+    render_views
+
+    it "renders partial" do
+      create_list(:widget, 2)
+      get :index
+      expect(response).to render_template(partial: "_widget")
+    end
+  end
+end
+
+# route_to - testing routes
+RSpec.describe "route_to", type: :routing do
+  describe "shortcut syntax" do
+    it "routes with controller#action" do
+      expect(get: "/widgets").to route_to("widgets#index")
+    end
+
+    it "routes with id" do
+      expect(get: "/widgets/1").to route_to("widgets#show", id: "1")
+    end
+  end
+
+  describe "hash syntax" do
+    it "routes with full hash" do
+      expect(get: "/widgets").to route_to(
+        controller: "widgets",
+        action: "index"
+      )
+    end
+
+    it "routes with params" do
+      expect(get: "/widgets/1").to route_to(
+        controller: "widgets",
+        action: "show",
+        id: "1"
+      )
+    end
+  end
+
+  describe "negative matching" do
+    it "does not route nonexistent paths" do
+      expect(get: "/nonexistent").not_to route_to("widgets#index")
+    end
+  end
+end
+
+# be_routable - testing route existence
+RSpec.describe "be_routable", type: :routing do
+  describe "routable paths" do
+    it "matches existing routes" do
+      expect(get: "/widgets").to be_routable
+      expect(post: "/widgets").to be_routable
+      expect(get: "/widgets/1").to be_routable
+    end
+  end
+
+  describe "non-routable paths" do
+    it "does not match nonexistent routes" do
+      expect(put: "/widgets").not_to be_routable
+      expect(delete: "/admin/destroy_all").not_to be_routable
+    end
+  end
+end
+
+# be_a_new - testing new records
+RSpec.describe "be_a_new", type: :controller do
+  controller WidgetsController do
+    def new
+      @widget = Widget.new
+    end
+  end
+
+  describe "GET #new" do
+    it "assigns a new widget" do
+      get :new
+      expect(assigns(:widget)).to be_a_new(Widget)
+    end
+  end
+
+  describe "after save" do
+    let(:widget) { Widget.create!(name: "Saved") }
+
+    it "is not a new widget" do
+      expect(widget).not_to be_a_new(Widget)
+    end
+  end
+
+  describe "with attributes" do
+    it "matches with expected attributes" do
+      widget = Widget.new(name: "Test")
+      expect(widget).to be_a_new(Widget).with(name: "Test")
+    end
+  end
+end
+
+# be_valid - testing model validity
+RSpec.describe "be_valid", type: :model do
+  describe Widget do
+    it "is valid with valid attributes" do
+      widget = Widget.new(name: "Valid Widget")
+      expect(widget).to be_valid
+    end
+
+    it "is not valid without required attributes" do
+      widget = Widget.new(name: nil)
+      expect(widget).not_to be_valid
+    end
+
+    it "validates with context" do
+      widget = Widget.new(name: "Test")
+      expect(widget).to be_valid(:create)
+    end
+  end
+end
+
+# have_enqueued_job - testing job enqueuing
+RSpec.describe "have_enqueued_job", type: :job do
+  describe "block form" do
+    it "matches enqueued job" do
+      expect {
+        ProcessJob.perform_later("data")
+      }.to have_enqueued_job
+    end
+
+    it "matches specific job class" do
+      expect {
+        ProcessJob.perform_later("data")
+      }.to have_enqueued_job(ProcessJob)
+    end
+
+    it "matches with arguments" do
+      expect {
+        ProcessJob.perform_later("data", 123)
+      }.to have_enqueued_job.with("data", 123)
+    end
+
+    it "matches on queue" do
+      expect {
+        ProcessJob.perform_later
+      }.to have_enqueued_job.on_queue("default")
+    end
+
+    it "matches at time" do
+      scheduled_time = 1.hour.from_now
+      expect {
+        ProcessJob.set(wait_until: scheduled_time).perform_later
+      }.to have_enqueued_job.at(scheduled_time)
+    end
+  end
+
+  describe "imperative form" do
+    before { ProcessJob.perform_later }
+
+    it "verifies job was enqueued" do
+      expect(ProcessJob).to have_been_enqueued
+    end
+
+    it "verifies enqueue count" do
+      ProcessJob.perform_later
+      expect(ProcessJob).to have_been_enqueued.exactly(:twice)
+    end
+  end
+end
+
+# have_broadcasted_to - testing ActionCable broadcasts
+RSpec.describe "have_broadcasted_to", type: :channel do
+  describe "broadcasting messages" do
+    it "matches broadcast to channel" do
+      expect {
+        ActionCable.server.broadcast("notifications", text: "Hello!")
+      }.to have_broadcasted_to("notifications")
+    end
+
+    it "matches with message content" do
+      expect {
+        ActionCable.server.broadcast("notifications", text: "Hello!")
+      }.to have_broadcasted_to("notifications").with(text: "Hello!")
+    end
+
+    it "matches broadcast count" do
+      expect {
+        2.times { ActionCable.server.broadcast("notifications", text: "Hi") }
+      }.to have_broadcasted_to("notifications").exactly(:twice)
+    end
+  end
+
+  describe "broadcasting to record" do
+    let(:user) { create(:user) }
+
+    it "matches broadcast to model" do
+      expect {
+        ChatChannel.broadcast_to(user, text: "Message")
+      }.to have_broadcasted_to(user)
+    end
+  end
+end
+
+# send_email - testing email sending (rspec-rails 7.0+)
+RSpec.describe "send_email", type: :mailer do
+  describe "email sending" do
+    it "matches sent email" do
+      expect {
+        NotificationsMailer.welcome(user).deliver_now
+      }.to send_email
+    end
+
+    it "matches email attributes" do
+      user = create(:user, email: "test@example.com")
+
+      expect {
+        NotificationsMailer.welcome(user).deliver_now
+      }.to send_email(
+        from: "noreply@example.com",
+        to: "test@example.com",
+        subject: "Welcome!"
+      )
+    end
+  end
+end
+
+# match_array for ActiveRecord relations
+RSpec.describe "match_array with relations", type: :model do
+  let!(:widgets) { create_list(:widget, 3) }
+
+  it "matches relation regardless of order" do
+    expect(Widget.all).to match_array(widgets)
+  end
+
+  it "matches scope results" do
+    published = create_list(:widget, 2, :published)
+    expect(Widget.published).to match_array(published)
+  end
+end