imanner (来见证奇迹!)

在 Rails7 中使用 devise 的邮箱验证

imanner — Tue, 01 Mar 2022 12:36:14 +0800

本文特点：

本地邮件服务器；
Rails7 避坑；
Dry。

安装 mailcatcher

# 全局 安装 mailcatcher
$ gem install mailcatcher

# 开启 mail server
$ mailcatcher
Starting MailCatcher v0.8.1
==> smtp://127.0.0.1:1025
==> http://127.0.0.1:1080
*** MailCatcher runs as a daemon by default. Go to the web interface to quit.

# 查看进程状态
$ ps -aux | grep mailcatcher

# 在浏览器 查看 mail server 状态
在浏览器打开 http://127.0.0.1:1080

创建新项目

$ rails new r7-devise-mail-confirm
$ cd r7-devise-mail-confirm
# 使用vscode 打开
$ code .

快速美化 UI

修改全局模板 [app/views/layouts/application.html.erb]，添加样式！

<link rel="stylesheet" href="https://cdn.simplecss.org/simple.min.css">

安装 devise

# 添加到 gem
$ bundle add devise
# 安装 devise
$ rails g devise:install
# 创建要使用的模型
$ rails g devise user

修改新生成的 migrate，去掉 Confirmable 块儿的注释

## Confirmable
t.string   :confirmation_token
t.datetime :confirmed_at
t.datetime :confirmation_sent_at
t.string   :unconfirmed_email # Only if using reconfirmable

修改新生成的 migrate，去掉 confirmation_token 索引的注释

add_index :users, :confirmation_token,   unique: true

执行 migrate

$ rails db:migrate

修改 user[app/models/user.rb] 模型，开启 devise 的 confirmable 功能

devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable,
         :confirmable

修改 devise 初始化配置 [config/initializers/devise.rb]，添加对 turbo_stream 的支持

config.navigational_formats = ['*/*', :html, :turbo_stream]

修改 devise 初始化配置 [config/initializers/devise.rb]，确认网站的发信邮箱

config.mailer_sender = 'devise@example.com'

修改模板 [app/views/layouts/application.html.erb]，提供通知功能

<body>
  <p><%= notice if notice %></p>
  <p><%= alert if alert %></p>
  <%= yield %>
</body>

配置 SMTP 信息

修改开发环境的配置文件：config/environments/development.rb

# Show full error reports.
config.consider_all_requests_local = true

# devise turbo
config.action_mailer.default_url_options = {
  host: 'localhost:3000',
}

config.action_mailer.delivery_method = :smtp

config.action_mailer.smtp_settings = {
  address: '127.0.0.1',
  port: 1025
}
#####

重启服务器！！！！！

创建测试页

# 创建 articles#index
$ rails g controller articles index
# 修改路由
root "articles#index"

在 articles 的 index 中添加跳转到 devise 登录，注册，退出的链接

<% if current_user %>
    <%= button_to 'Sign Out', destroy_user_session_path, method: :delete %>
<% else %>
    <%= link_to "Sign Up", new_user_registration_path %>
    <br>
    <%= link_to "Login", new_user_session_path %>
<% end %>

测试

测试就不多说了，这里给出一点提示：

如果没有确认过邮箱登录会出现上面图片中红框位置的提示信息！

而 mailcatcher 中可以点击注册的连接：

大家可以自己试试“忘记密码”等其它功能！

Have fun, Enjoy yourself, ^ _ ^!

gRPC 快速开始 | 翻译并修复官方文档几处 bug | 更新软件版本到最新 | 已经提交 Pull 给官方

imanner — Thu, 16 Dec 2021 11:36:28 +0800

gRPC | 快速开始

原文地址：https://grpc.io/docs/languages/go/quickstart/#regenerate-grpc-code

本文将带你使用 go 语言实现一个 gRPC 的小小示例。

环境准备

Go, 推荐安装最新的 go 版本。

具体安装方法，可以参考go 语言官方文档的 快速开始
Protocol buffer 的编译器版本 3.

具体安装方法，可以参考文章： Protocol Buffer 编译器安装
protocol 编译器的 go 语言插件：

使用下面的命令安装：

// 当前日期为20211216 最新版本为: 1.27.1
$ go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.27
// 当前日期为20211216 最新版本为: 1.1.0
$ go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.1

将 protoc 编译器的执行文件路径添加到PATH:
```
$ export PATH="$PATH:$(go env GOPATH)/bin"
```

获取示例代码

示例代码仓库的位置：grpc-go .

克隆仓库，当然，您也可以下载 zip 压缩文件，下载地址： zip :

// 当前日期为20211216 最新版本为: 1.43.0

$ git clone -b v1.43.0 https://github.com/grpc/grpc-go

切换到示例文件夹：
```
$ cd grpc-go/examples/helloworld
```

运行示例

假设您已经切换至目录：examples/helloworld

编译并运行服务端文件：
```
$ go run greeter_server/main.go
```
打开一个新的命令行，也要进入grpc-go/examples/helloworld目录，运行客户端文件，观察客户端输出：
```
$ go run greeter_client/main.go
Greeting: Hello world
```

ヾ (◍°∇°◍) ﾉﾞ, 至此，恭喜，您已经成功运行了一个包含完整客户端和服务端的 gRPC 项目。

升级一下我们的 gRPC 服务

本小节中咱们将通过扩展服务端方法来升级一下我们的示例项目。

gRPC 服务是通过 protocol buffers 来定义的，如果您想学习更多通过编写 .proto 文件来定义服务的知识，可以参考文章：基础指引.

但现在，咱们只要知道在示例项目中，服务端和客户端都包含一个 RPC 调用的 SayHello() 方法，并且需要从客户端传入参数 HelloRequest , 服务端会返回 HelloReply , 能明白到这儿，就足够了！

方法定义如下：

// 定义 greeting 服务.
service Greeter {
    // 发送 greeting 信息
    rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// 请求 message 包含用户的 name.
message HelloRequest {
    string name = 1;
}

// 响应 message 包含 greetings 信息
message HelloReply {
    string message = 1;
}

打开 helloworld/helloworld.proto 文件，新建 SayHelloAgain() 方法，参数和返回值和 SayHello 保持一致：

// 定义 greeting 服务.
service Greeter {
    // 发送 greeting 信息
    rpc SayHello (HelloRequest) returns (HelloReply) {}
    // 新增方法
    // 发送 另一 greeting 信息
    rpc SayHelloAgain (HelloRequest) returns (HelloReply) {}
}

// 请求 message 包含用户的 name.
message HelloRequest {
    string name = 1;
}

// 响应 message 包含 greetings 信息
message HelloReply {
    string message = 1;
}

友情提示：别忘了保存文件哦 ^_^~~!

重新创建 gRPC 代码

在使用新的服务方法之前，我们需要重新编译 .proto 文件。

首先要切换到 examples/helloworld 目录，然后运行下列命令：

$ protoc --go_out=. --go_opt=paths=source_relative \
    --go-grpc_out=. --go-grpc_opt=paths=source_relative \
    helloworld/helloworld.proto

以上命令会重新创建 helloworld/helloworld.pb.go 和 helloworld/helloworld_grpc.pb.go 文件，文件内容包含以下内容：

构成，序列化，检索 HelloRequest 和 HelloReply 消息类型的一些列代码。
创建客户端和服务端的代码。

升级并运行项目

你已经重新生成了服务端和客户端的代码，但是你仍然需要在应用中自己去实现以及调用新添加的方法。

升级服务端

打开 greeter_server/main.go 文件，将下面的方法添加到文件中：

func (s *server) SayHelloAgain(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    return &pb.HelloReply{Message: "Hello again " + in.GetName()}, nil
}

升级客户端

打开 greeter_client/main.go 文件，将下面的代码添加到 main() 方法体的尾部：

r, err = c.SayHelloAgain(ctx, &pb.HelloRequest{Name: *name})
if err != nil {
    log.Fatalf("could not greet: %v", err)
}
log.Printf("Greeting: %s", r.GetMessage())

友情提示：别忘了保存文件哦！

运行吧！

和之前一样，首先切换到 examples/helloworld 目录：

运行服务端：
```
$ go run greeter_server/main.go
```
打开另一命令行窗口，运行客户端。这一次，要在命令行上添加一个名字 Alice 作为参数：
```
$ go run greeter_client/main.go -name=Alice
```
您应该看到如下输出：
```
Greeting: Hello Alice
Greeting: Hello again Alice
```

下一步要做啥

深入了解 gRPC 工作机制：gRPC 简介和 gRPC 核心概念.
过一遍基础指引.
翻阅 API 文档.

支持 Docker-compose,内置指令集,提供原生开发体验, LNPPR-Docker 一键安装脚本, 让工作更快更轻松

imanner — Wed, 24 Nov 2021 17:05:08 +0800

LNPPR 一键配置脚本升级，支持 Docker

让工作更快更轻松！

地址：https://github.com/letseeqiji/LNPPR/tree/lnppr-docker

脚本说明

LNPPR-Docker = Docker ( Linux + Nginx + Puma + PosrgreSQL + Rails )

LNPPR-Docker 一键安装脚本是基于配置文件的 Shell 脚本文件。

它从 dokcer 的自动安装到可以基于 Docker-compose 快速的帮您搭建在 linux 平台上包含服务器的 Rails 项目。

其中的套件包含不仅包含 :Docker + Docker-compose + Nodejs + Yarn + Nginx + Ruby + Rails + Sqlite3/MySQL/PostgreSQL + Redis 等等。

你可以通过修改脚本根目录下的 docker.conf 文件来控制软件的版本，也可以通过修改 rails_new.conf 来定义 rails 项目的参数。

然后就是 一键创建新项目 ~~

脚本特点

多语言支持：内置语言包，嫌提示不好看？那就定制成自己专属界面！
基于配置：无需界面操作与等待，配置好了，安装即可，这才是真正的 "一键搞定"!
基于 Docker: 自动根据配置拉去和创建 image!
自动维护 Docker-compose: 自动根据选择创建 Docker-compose 文件！
自动配置：根据配置实现项目的自动配置！
内置指令集：提供原生的开发体验！
更多独立工具：想用就用，不想绝不强塞！要扩展，就弄个新包上去！
更多功能来袭 !!!

使用要求

特殊说明

仅支持 64 位系统！仅支持 64 位系统！仅支持 64 位系统！
软件版本
- Ruby: 2.7.4+
- Rails: 5.2.5+

系统

linux 64 位系统

目前支持的系统列表

系统	版本	位数
centOS	7.0 及以上	64 位
Ubuntu	20.04 及以上	64 位
Debian	9 及以上	64 位
Linux Mint	20 及以上	64 位
Fedora	32 及以上	64 位
Mint	20 及以上	64 位
Deepin	20 及以上	64 位
Oracle	7 及以上	64 位
RHEL	7 及以上	64 位
Kali	2020 及以上	64 位
...	...	...

使用说明

克隆脚本到本地文件夹;
一定要！必须要！** 切换目录到 **脚本根目录;
切换分支到 lnppr-docker: git checkout lnppr-docker
配置 脚本根目录下的配置文件：docker.conf 和 rails_new.conf ;
给与 docker_rails.sh 可执行权限：
- shell # chmod +x docker_rails.sh
使用 root 用户执行脚本：
- shell # su root # ./docker_rails.sh
喝杯茶，等着吧~ ;

* 配置文件 docker.conf 说明 *

# 界面语言 zh | en
Language=zh

# Docker
# docker 下载地址
Docker_Binary_Download="https://mirrors.163.com/docker-ce/linux/static/stable/x86_64/"
# docker 主镜像地址
Docker_Main_Registry="https://hub-mirror.c.163.com"
# 要安装的docker版本
Docker_Install_Ver="20.10.9"

# Compose
# docker-compose 下载地址
Compose_Binary_Download="https://get.daocloud.io/docker/compose/releases/download"
# docker-compose 安装版本
Compose_Install_Ver="2.1.1"
# docker-compose.yml version
Compose_Version="3.8"
# 默认的 docker-compose 文件名
Compose_File="docker-compose.yml"
# 内置制定集自定义
Compose_Instruction=compose
Rails_Instruction=rails

# dockerfile
Docker_File_Label="maintainer=qiji"

# Rails App default value
# rails 服务名
Rails_Service="web"
# 3位如：3.0.2 2.7.4
# ruby镜像使用版本
Ruby_Default_Ver="3.0.2"
# 3位如：6.1.4 5.2.5
# rails 默认镜像版本
Rails_Default_Ver="6.1.4"
# rails 默认的使用的端口号
Rails_Default_Port=3000
# product || development || test
Rails_ENV="development"
# 是否安装redis
Rails_Enable_Redis="n"
# 默认的项目地址
Rails_Default_Project_Dir="/data/www"
# 项目env文件默认文件夹
Env_Dir=".env/${Rails_ENV}"

# Node 镜像地址
Node_Registry="registry.npmmirror.com"

#ruby 镜像地址
Ruby_Registry="gems.ruby-china.com"

# Postgres 服务名
Postgres_Service="postgres"
# Postgres镜像名
Postgres_Img="postgres"
# Postgres镜像默认版本
Postgres_Default_Ver="latest"
# Postgres是否允许远程
Postgres_Enable_Remote='y'
# Postgres 默认远程端口
Postgres_Remote_port="5432"
# Postgres连接host地址
Postgres_Host="${Postgres_Service}"
# Postgres host 存放文件
Postgres_Host_File="${Postgres_Host}"
# Postgres 用户
Postgres_User="postgres"
# Postgres 用户密码
Postgres_Passwd="123456"
# Postgres 数据库
Postgres_Db="${Rails_Service}_${Rails_ENV}"
# Postgres 挂载镜像
Postgres_Data_Valume="${Rails_ENV}_postgres_db_data"

# MySQL 服务名
MySQL_Service="mysql"
# MySQL 镜像名
MySQL_Img="mysql"
# MySQL 镜像版本
MySQL_Default_Ver="latest"
# MySQL 允许远程
MySQL_Enable_Remote='y'
# MySQL 远程端口
MySQL_Remote_port=3306
# MySQL 存储引擎
MySQL_Default_Storage_Engine="INNODB"
# MySQL 字符编码
MySQL_Default_Character="utf8mb4"
# MySQL 连接host
MySQL_Host="${MySQL_Service}"
MySQL_Host_File="${MySQL_Host}"
# MySQL 用户
MySQL_User="lnppr"
# MySQL 用户密码
MySQL_Passwd="123456"
# MySQL root 密码
MySQL_Root_Passwd="123456"
# MySQL 挂载镜像
MySQL_Data_Valume="${Rails_ENV}_mysql_db_data"

# Redis 服务名
Redis_Service="redis"
# Redis 镜像名
Redis_Img="redis"
# Redis 镜像默认版本
Redis_Default_Ver="latest"
# Redis 是否允许编程
Redis_Enable_Remote='y'
# Redis 远程端口
Redis_Remote_port="6379"
# Redis 密码
Redis_Remote_Passwd="123456"

* 配置文件 rails_new.conf 说明 *

# Rails_New_Options
# 可选：mysql/postgresql/sqlite3/oracle/sqlserver/jdbcmysql/jdbcsqlite3/jdbcpostgresql/jdbc
Rails_New_Option_Database="sqlite3"

# 运行端口 任意可用端口即可
Rails_New_Option_Port="3000"

# 可选：no-redis | redis
Rails_New_Option_Redis="redis"

# 可选：--api | --no-api
Rails_New_Option_Api="--no-api"

# 可选：--skip-bundle | --no-skip-bundle
Rails_New_Option_Skip_Bundle="--no-skip-bundle"

# 可选：--skip-test | --no-skip-test
Rails_New_Option_Skip_Test="--no-skip-test"

# 可选：--minimal | --no-minimal
Rails_New_Option_Minimal="--no-minimal"

# 可选：--webpack= WEBPACK, react, vue, angular, elm, stimulus
# Rails_New_Option_Webpacker="--webpack=WEBPACK"
Rails_New_Option_Webpacker="WEBPACK"

# 可选：--skip-gemfile | --no-skip-gemfile
Rails_New_Option_Skip_Gemfile="--no-skip-gemfile"

# 可选：--skip-git | --no-skip-git
Rails_New_Option_Skip_Git="--no-skip-git"

# 可选：--skip-action-mailer | --no-skip-action-mailer
Rails_New_Option_Skip_Action_Mailer="--no-skip-action-mailer"

# 可选：--skip-action-mailbox | --no-skip-action-mailbox
Rails_New_Option_Skip_Action_Mailbox="--no-skip-action-mailbox"

# 可选：--skip-action-text | --no-skip-action-text
Rails_New_Option_Skip_Action_Text="--no-skip-action-text"

# 可选：--skip-active-record | --no-skip-active-record
Rails_New_Option_Skip_Active_Record="--no-skip-active-record"

# 可选：--skip-active-job | --no-skip-active-job
Rails_New_Option_Skip_Active_Job="--no-skip-active-job"

# 可选：--skip-active-storage | --no-skip-active-storage
Rails_New_Option_Skip_Active_Storage="--no-skip-active-storage"

# 可选：--skip-puma | --no-skip-puma
Rails_New_Option_Skip_Puma="--no-skip-puma"

# 可选：--skip-action-cable | --no-skip-action-cable
Rails_New_Option_Skip_Action_Cable="--no-skip-action-cable"

# 可选：--skip-javascript | --no-skip-javascript
Rails_New_Option_Skip_Javascript="--no-skip-javascript"

# 可选：--skip-turbolinks | --no-skip-turbolinks
Rails_New_Option_Skip_Turbolinks="--no-skip-turbolinks"

# 可选：--skip-system-test | --no-skip-system-test
Rails_New_Option_Skip_System_Test="--no-skip-system-test"

# 可选：--skip-bootsnap | --no-skip-bootsnap
Rails_New_Option_Skip_Bootsnap="--no-skip-bootsnap"

# 可选：--skip-webpack-install | --no-skip-webpack-install
Rails_New_Option_Skip_Webpack_Install="--no-skip-webpack-install"

# 使用自定义模板
Rails_New_Option_Template=""

* 内置默认指令集说明 *

compose up: docker-compose up
compose down: docker-compose down
compose start: docker-compose start
compose stop: docker-compose stop
compose ps: docker-compose ps
compose build: docker-compose build
compose -v: docker-compose -v
rails console: docker-compose run web rails console
rails db:migrate: docker-compose run web rails db:migrate
rails webpacker:install: docker-compose run web rails webpacker:install
bundle: docker-compose run web bundle
mysql: docker-compose run mysql mysql

L(inux) N(ginx) P(uma) P(ostgresql) R(ails) 一键安装脚本, 让工作更快更轻松

imanner — Fri, 12 Nov 2021 17:19:23 +0800

LNPPR 一键安装脚本

==让工作更快更轻松！==

地址：https://github.com/letseeqiji/LNPPR

脚本说明

LNPPR = Linux + Nginx + Puma + PostgreSQL + Rails

LNPPR 一键安装脚本是基于配置文件的 Shell 脚本文件。

它可以快速的帮您搭建基于 linux 平台包含反向代理的的 Rails 服务器。

其中的套件包含不仅包含 :Nodejs + Yarn + Nginx + Ruby + Rails + Sqlite3/MySQL/PostgreSQL + Redis 等等。

你可以通过修改脚本根目录下的 install.conf 文件来控制软件的安装和一系列配置。

然后就是 一键安装 ~~

脚本特点

最小化安装：只安装必要的软件，保持您系统的稳定和苗条！
过程透明：不"偷偷"修改系统配置，一切都在您的掌控！
自动回滚：安装失败会自动清除已经安装的软件残留，走也要走的干干净净！
多语言支持：内置语言包，嫌提示不好看？那就定制成自己专属界面！
基于配置：无需界面操作与等待，配置好了，安装即可，这才是真正的 "一键搞定"!
更多独立工具：想用就用，不想绝不强塞！要扩展，就弄个新包上去！
更多功能来袭 !!!

使用要求

# 特殊说明

仅支持 64 位系统！仅支持 64 位系统！仅支持 64 位系统！
目前，目前，目前 不支持 WSL!

安装要求

硬件要求
- 若安装 MySQL5.7.x
  - 需要内存至少 1G
  - 硬盘空间至少 10G
- 若安装 MySQL8.x
  - 需要内存至少 2G
  - 硬盘空间至少 25G
- 若安装 PostgreSQL
  - 需要内存至少 1G
  - 硬盘空间至少 1G

系统

linux 64 位系统

目前支持的系统列表

系统	版本	位数
CentOS	7.0 及以上	64 位
Ubuntu	20.04 及以上	64 位
Debian	9 及以上	64 位
Fedora	32 及以上	64 位
Mint	20 及以上	64 位
Deepin	20 及以上	64 位
Oracle	7 及以上	64 位
RHEL	7 及以上	64 位
Kali	2020 及以上	64 位
...	...	...

使用说明

克隆脚本到本地文件夹;
一定要！必须要！** 切换目录到 **脚本根目录;
配置 脚本根目录下的配置文件：install.conf ;
给与 install.sh 可执行权限：
- # chmod +x install.sh
使用 root 用户执行脚本：
- # su root - # ./install.sh
喝杯茶，等着吧~ ;
完成后，不用重启计算机！不用重启计算机！不用重启计算机！

* 配置文件 install.conf 说明 *

# 选择界面显示语言: zh | en
Language=zh
# 要安装的环境 dev | pro | test
Install_Env=pro

# 控制要安装的软件：y-安装 | n-不安装
# 安装Nodejs:默认安装
Nodejs_Enable_Install='y'
# 安装Yarn:默认安装
Yarn_Enable_Install='y'
# 安装Nginx:默认安装
Nginx_Enable_Install='y'
# 安装Ruby:默认安装
Ruby_Enable_Install='y'
# 安装Rails:默认安装
Rails_Enable_Install='y'
# 安装Puma:默认安装
Puma_Enable_Install='y'
# 安装Sqlite3:默认安装
Sqlite3_Enable_Install='y'
# 安装Mysql:默认不安装
Mysql_Enable_Install='n'
# 安装PostgreSQL:默认不安装
PostgreSQL_Enable_Install='n'
# 安装Redis:默认不安装
Redis_Enable_Install='n'

# Nodejs 相关配置
# 要安装的版本
Nodejs_Install_Ver=14.18.1
# 镜像下载地址
Nodejs_Base_Download_Url='https://mirrors.aliyun.com/nodejs-release'
# 安装路径
Nodejs_Install_Dir=/usr/local/nodejs
# 修改npm国内源
Nodejs_Reset_Registry='淘宝'
Nodejs_Registry_Url=https://registry.npm.taobao.org

# Yarn 相关配置
# 安装版本
Yarn_Install_Ver=1.22.4

# ruby 相关配置
# 安装版本
Ruby_Install_Ver=3.0.2
# 安装路径
Ruby_Install_Dir=/usr/local/ruby

# rails 相关配置
# 安装版本
# Rails_Install_Ver=5.2.5
Rails_Install_Ver=6.1.4

# sqlite 相关配置
# 安装版本
Sqlite3_Install_Ver=3.36.0
# 安装路径
Sqlite3_Install_Dir=/usr/local/sqlite

# MySQL 相关配置
# 安装版本
# Mysql_Install_Ver=8.0.27
Mysql_Install_Ver=5.7.36
# 镜像下载地址
MySQL_Base_Download_Url='https://mirrors.aliyun.com/mysql'
# 安装路径
Mysql_Install_Dir='/usr/local/mysql'
# 数据目录
MySQL_Data_Dir='/data/mysql/data'
# 使用端口
MySQL_Port=3306
# 要设置的root密码
MySQL_Root_Passwd='123456'
# 默认配置文件所在目录
MySQL_DSYSCONFDIR='/etc'
# 默认数据编码
MySQL_DEFAULT_CHARSET=utf8mb4
# socket文件所在目录
MySQL_Sock=/tmp/mysql.sock
# 是否开启远程登录访问
MySQL_Enable_Remote='y'

# PgSql 相关配置
# 安装版本
# PgSQL_Install_Ver=10.19
# PgSQL_Install_Ver=11.14
# PgSQL_Install_Ver=12.9
# PgSQL_Install_Ver=14.1
PgSQL_Install_Ver=13.5
# 镜像下载地址
PgSQL_Base_Download_Url='https://mirrors.aliyun.com/postgresql'
# 安装路径
PgSQL_Install_Dir='/usr/local/pgsql'
# 数据目录
PgSQL_Data_Dir='/data/pgsql'
# 使用端口
PgSQL_Port=5432
# 是否开启远程登录访问
PgSQL_Enable_Remote='y'

# Redis 相关配置
# 安装版本
Redis_Install_Ver=6.2.6
# 是否开启远程登录访问
Redis_Enable_Remote='y'
# 设置登录需要密码
Redis_Enable_Passwd='y'
# 登录用密码
Redis_Passwd='123456'
# 安装路径
Redis_Install_Dir='/usr/local/redis'
# 使用端口
Redis_Port=6379
# 数据目录
Redis_Data_Dir='/data/redis/data'
# 日志目录
Redis_Log_Dir='/data/redis/log'
Redis_Log_File='/data/redis/log/redis_log'
# 配置文件所在目录
Redis_Config_Dir='/usr/local/redis/etc'
Redis_Config_File='/usr/local/redis/etc/redis.conf'
# pid文件所在目录
Redis_Pid_File='/var/run/redis.pid'

# Nginx 相关配置
# 安装版本
Nginx_Install_Ver=1.20.1
# nginx用户
Nginx_User=www
# nginx用户组
Nginx_Group=www
# 安装路径
Nginx_Install_Dir='/usr/local/nginx'
# 使用端口
Nginx_Port=80
# 日志目录
Nginx_Log_Dir='/data/nginx/log'
Nginx_Log_File='/data/nginx/log/error.log'
# 配置文件目录
Nginx_Config_Dir='/usr/local/nginx/conf'
Nginx_Config_File='/usr/local/nginx/conf/nginx.conf'
# 网站默认的路径
Default_Website_Dir='/data/wwwroot/default'

安装参考

硬件配置

名称	大小/核心数/转速/速率	类型
CPU	2.80GHz	4 核心 4 线程
内存	4GB	2666MHz
硬盘	7200rpm	机械
带宽	10M	光纤

测试平台：CentOS 7.9x64

GCC 版本：4.8.5

软件	版本	安装时长	安装过程最大占用空间	安装后占用空间
Nodejs	14.18.1	5 秒	108MB	107MB
Yarn	1.22.4	10 秒	5.5MB	5.2MB
Nginx	1.20.1	1.3min-1.8min	39MB	6.4MB
Ruby	3.0.2	2.3min-3min	677MB	113MB
Rails	6.1.4	1min-1.1min	42MB	41.5M
Sqlite3	3.36.0	1min-1.3min	90MB	26MB
PostgreSQL	13.4	1.5min-2min	227MB	67MB
MySQL5	5.7.36	15.3min-18min	6.3GB	2173.6MB
MySQL8	8.0.27	35min-40min	22.3GB	2470MB
Redis	6.2.6	1.3min-1.5min	179MB	19MB
软件依赖库	---	1.5min-2min	<300MB	260MB

测试平台：Debian 11x64

GCC 版本：10.2.1

软件	版本	安装时长	安装过程最大占用空间	安装后占用空间
Nodejs	14.18.1	5 秒	130MB	110MB
Yarn	1.22.4	10 秒	15MB	8MB
Nginx	1.20.1	1.3min-1.8min	39MB	5.5MB
Ruby	3.0.2	2.3min-3min	700MB	126MB
Rails	6.1.4	1min-1.1min	55MB	43.5M
Sqlite3	3.36.0	1min-1.3min	107MB	38MB
PostgreSQL	13.4	1.5min-2min	207MB	28MB
MySQL5	5.7.36	15.3min-18min	6.7GB	2273.6MB
MySQL8	8.0.27	35min-40min	22.3GB	2566MB
Redis	6.2.6	1.3min-1.5min	179MB	25MB
软件依赖库	---	1.5min-2min	<300MB	235.6MB

论坛献礼：使用 Rails 6 开发纯后端 API 项目

imanner — Mon, 07 Jun 2021 14:02:08 +0800

使用 rails6 开发纯后端 API 项目

项目地址：https://github.com/letseeqiji/pure-rails6-api

前言

本书是结合作者实战经验和心得，参考了国内外诸多大神的资料，本着一颗学习、总结与分享的心书写而成，希望对读者有着有益的指导作用，如果能指导读者并能帮助读者创造一点点价值，那我就会更加开心了！

本书简介

书中实现了一个简易商铺系统的纯后台 API 项目！适用于目前流行的使用 http 或 https 协议通信并使用json 作为数据交互的restful 风格的前后端分离项目。使用的技术栈包括 L N M R R【linux nginx mysql redis ruby】等！

本书分为 13 大章节

第一章：环境准备工作
第二章：API 版本的管理
第三章：实战项目分析
第四章：用户模块的开发
- 模型相关开发
- 控制器相关开发
第五章：用户状态管理模块开发
第六章：商铺模块开发
- 模型相关开发
- 控制器相关开发
第七章：分页和返回值定制
第八章：商品模块开发
- 模型相关开发
- 控制器相关开发
第九章：订单模块开发
- 模型相关开发
- 控制器相关开发
第十章：订单与商品模块关系开发
- 模型相关开发
- 控制器相关开发
第十一章：异常处理
第十二章：项目优化
第十三章：项目部署

前两章是开发的准备工作，从第三章开始进入项目开发阶段，按照用户、商铺、商品、订单的顺序进行开发，中间还穿插了一些重要的知识点，比如分页和返回值格式的定制！第十一和十二两章是对项目的优化，分别从异常的处理和项目本身的优化来研讨，最后一章是项目的线上部署，我们将采用 nginx+puma+mina 实现项目的自动部署。

每一章节的知识都很丰富，也是我对自我知识的总结和分享，希望大家能够从中有所收获！

你将收获

使用 Git 进行版本控制；
在 Rails 中使用 JWT 进行用户状态验证；
定制返回的 json 数据；
单元测试的编写并使用 TDD 推进开发；
跨域问题的解决；
使用 nginx + ssl + puma + mina 进行项目部署；
邮件服务的配置；
Rails 中 redis 缓存的使用；
Rails 中的一些编程技巧；

本书约定

为了更好的阅读及理解文中的知识点，我对每一章甚至是每一个小的模块都做了相对统一的结构，从浅入深，从知识点的梳理到应用的开发，所以，每一个模块的开发基本上都遵循了下面的结构：

基础知识储备
- 当前模块用到的 ruby 和 Rails 中知识点的补充和说明
版本控制
- 生成分支
模块开发
- 功能分析
- 测试编写
- 代码实现
- 测试通过
版本控制
- 合并分支

感谢

本书能够出现，要感谢很多人。这其中有很多人的文章及作品为本书的书写提供了充实的资料和参考，有些人默默付出，让我能够安心的完成本书！这其中有我的家人也有志同道合的朋友！

Rails 官网 : 十分感激创造出 Rails 这么优秀的框架，让我感受的语言的优美，编程的快乐。这里有最新的信息和文档，希望大家有时间多逛逛这里。
ruby 中国 : 这是一个超级友好的社区，里面没有撕逼，只有互相共勉，互相支持，希望更多的人可以喜欢这个社区，我非常感谢这个社区，在这里能够感受到技术人的热情与执着。这个社区还维护着国内的稳定的 gem 源，感谢作者及团队的默默付出！
Alexandre Rousseau ：十分感谢该作者的文献，该作者的文档写的极具水平，能把知识溶于简单的语言，十分感激与敬佩。
theforeman ：这是一只十分优秀的团队，一直在维护着十分优秀的项目！本书代码的一些灵感来源于该团队的开源项目，十分感激！

本书参与者【排名不分先后】

期待

期待本书中的内容可以为读者提供有意义的指导，如果阅读中遇到什么问题，或者有好的建议，您可以发送邮件到我的邮箱：wowiwo@yeah.net

最后，期待我们一起奋力前行，让努力的人不孤单！加油，伙伴们！！！

rspec5 一览大文

imanner — Fri, 14 May 2021 19:02:05 +0800

安装

添加到 Gemfile

$ echo 'gem "rspec-rails", group: [:development, :test]' >> Gemfile

安装

$ bundle install

初始化成为默认测试框架

$ rails generate rspec:install

运行测试

$ rails spec

或者

$ rspec spec --format documentation

测试框架

# spec/failing_spec.rb
require "rails_helper"

# 配置
RSpec.configure do |config|
  config.xxx
  ...
end

# 类级别命名空间
RSpec.describe "类名", :type => :类型 do
  # 使用内部的匿名控制器
  controller do
    def 方法名
      # 实现
    end
  end

  before(:context) do
    @widget = Widget.create!
  end

  after(:context) do
    @widget.destroy
  end

  # 类的方法级别命名空间
  # describe "请求方法 方法名" 
  describe "GET index" do
    before(:context) do
      @widget = Widget.create!
    end

    after(:context) do
      @widget.destroy
    end

    # 具体的测试用例 允许多个，包含成功的和失败的
    it "raises an error" do
      # 具体实现
      get :index
    end
  end
end

内置创建器

$ rails generate rspec:model user
$ rails generate rspec:controller api::v1::users

生成文件 spec/models/user_spec.rb

更多的 specs 标签支持：

scaffold
model
controller
- rails g rspec:controller api::v1::users
helper
view
mailer
integration
feature
job
channel
generator
mailbox
request
system

事务

rspec 默认开启事务，这样可以保证测试完成后自动清空数据库。当然可以使用其他 gem 来完成这个功能，例如 database_cleaner 。

当运行 rails generate rspec:install, 在文件 spec/rails_helper.rb 中默认引入了系列配置：

RSpec.configure do |config|
  config.use_transactional_fixtures = true
end

禁用事务

RSpec.configure do |config|
  config.use_transactional_fixtures = false
end

利用 `before` 关键字实现自动回滚的控制

自动回滚：任何在 before(:example) 定义的数据在执行完测试后都会自动清空。

describe Widget do
before(:example) do
  @widget = Widget.create
end

it "does something" do
  expect(@widget).to do_something
end

it "does something else" do
  expect(@widget).to do_something_else
end
end

@widget 在每个 it 中都会被重新创建，所以互不干扰。

手动控制：在 before(:context) 中创建的数据则不会自动回滚。你可以利用before(:context) 创建多个方法的公用数据。下面是几个原则：

一定要定义 after(:context) 来手动删除数据：
```
before(:context) do
  @widget = Widget.create!
end

after(:context) do
  @widget.destroy
end
```
否则你的数据会一直存在有可能影响其他测试。

一定要使用 before(:example) 刷新数据。

before(:context) do
  @widget = Widget.create!
end

before(:example) do
  @widget.reload
end

目录结构建议

rspec 的目录规范

模块	所在目录
`Model specs`	`spec/models`
`Controller specs`	`spec/controllers`
`Request specs`	`spec/requests` 或者 `integration` 或者`api`
`Feature specs`	`spec/features`
`View specs`	`spec/views`
`Helper specs`	`spec/helpers`
`Mailer specs`	`spec/mailers`
`Routing specs`	`spec/routing`
`Job specs`	`spec/jobs`
`System specs`	`spec/system`

当然开发人员可以任意自定义目录结构，这个时候就需要明确的说明当前的测试是针对那个模块儿。如何指定呢？使用type, 在 rspec 中可用的 type 类型有：

模块	使用类型标示
`Model specs`	`type: :model`
`Controller specs`	`type: :controller`
`Request specs`	`type: :request`
`Feature specs`	`type: :feature`
`View specs`	`type: :view`
`Helper specs`	`type: :helper`
`Mailer specs`	`type: :mailer`
`Routing specs`	`type: :routing`
`Job specs`	`type: :job`
`System specs`	`type: :system`

举个例子：

# spec/legacy/things_controller_spec.rb
# 明确表明了要测试的类型
RSpec.describe ThingsController, type: :controller do
  describe "GET index" do
    # Examples
  end
end

自动识别类型

如果目录的安排是按照 rspec 规范的目录，可以通过配置自动的识别类型

# spec/rails_helper.rb
RSpec.configure do |config|
  config.infer_spec_type_from_file_location!
end

但是如果是自定义目录，也可以这样做：

# set `:type` for serializers directory
RSpec.configure do |config|
  config.define_derived_metadata(:file_path => Regexp.new('/spec/serializers/')) do |metadata|
    metadata[:type] = :serializer
  end
end

建议

强烈推荐按照规范罗列目录，例如：

app
├── controllers
│   ├── application_controller.rb
│   └── books_controller.rb
├── helpers
│   ├── application_helper.rb
│   └── books_helper.rb
├── models
│   ├── author.rb
│   └── book.rb
└── views
    ├── books
    └── layouts
lib
├── country_map.rb
├── development_mail_interceptor.rb
├── enviroment_mail_interceptor.rb
└── tasks
    └── irc.rake
spec
├── controllers
│   └── books_controller_spec.rb
├── country_map_spec.rb
├── features
│   └── tracking_book_delivery_spec.rb
├── helpers
│   └── books_helper_spec.rb
├── models
│   ├── author_spec.rb
│   └── book_spec.rb
├── rails_helper.rb
├── requests
│   └── books_spec.rb
├── routing
│   └── books_routing_spec.rb
├── spec_helper.rb
├── tasks
│   └── irc_spec.rb
└── views
    └── books

场景

自动识别测试类型，添加 type

#spec/functional/widgets_controller_spec.rb
require "rails_helper"

RSpec.describe WidgetsController, :type => :controller do
  it "responds successfully" do
    get :index
    expect(response.status).to eq(200)
  end
end

非 Rails 应用就不要添加 type

#spec/ledger/entry_spec.rb
require "spec_helper"

Entry = Struct.new(:description, :us_cents)

RSpec.describe Entry do
  it "has a description" do
    is_expected.to respond_to(:description)
  end
end

从文件位置推断规范类型会添加适当的元数据

#spec/controllers/widgets_controller_spec.rb
require "rails_helper"

RSpec.configure do |config|
  config.infer_spec_type_from_file_location!
end

RSpec.describe WidgetsController do
  it "responds successfully" do
    get :index
    expect(response.status).to eq(200)
  end
end

# spec/routing/duckduck_routing_spec.rb
require "rails_helper"

Rails.application.routes.draw do
  get "/example" => redirect("http://example.com")
end

RSpec.configure do |config|
  config.infer_spec_type_from_file_location!
end

# Due to limitations in the Rails routing test framework, routes that
# perform redirects must actually be tested via request specs
RSpec.describe "/example", :type => :request do
  it "redirects to example.com" do
    get "/example"
    expect(response).to redirect_to("http://example.com")
  end
end

Backtrace 过滤

Rails 中有些 gem 会让失败输出的 backtrace 信息会被过滤和简化，我们可以通过配置让失败的输出全部的 backtrace：

RSpec.configure do |config|
  config.filter_rails_from_backtrace!
end

局部使用 `filter_rails_from_backtrace!`

# spec/failing_spec.rb
require "rails_helper"

RSpec.configure do |config|
  config.filter_rails_from_backtrace!
end

RSpec.describe "Controller", :type => :controller do
  # 使用内部的匿名控制器
  controller do
    def index
      raise "Something went wrong."
    end
  end

  describe "GET index" do
    it "raises an error" do
      get :index
    end
  end
end

为模型编写 rspec

模型的 rspec 是 ActiveSupport :: TestCase 的美化包装，并且包括所有它提供的行为和断言，以及 RSpec 自身的行为和期望。

例子：

require "rails_helper"
# 模型是：Post， 明确指定了type
RSpec.describe Post, :type => :model do
  # 命名空间是 with 2 or more comments
  context "with 2 or more comments" do
    # 真正的测试
    it "orders them in reverse chronologically" do
      # 调用create方法创建了一个 post
      post = Post.create!
      # 创建一个回复
      comment1 = post.comments.create!(:body => "first comment")
      # 创建第二个回复
      comment2 = post.comments.create!(:body => "second comment")
      # 期望所有回复中 comment2, comment1相等
      expect(post.reload.comments).to eq([comment2, comment1])
    end
  end
end

事务的例子

默认使用事务

# spec/models/widget_spec.rb
require "rails_helper"

# 验证模型 Widget
RSpec.describe Widget, :type => :model do
  # 没有数据
  it "has none to begin with" do
    expect(Widget.count).to eq 0
  end

  # 添加一个
  it "has one after adding one" do
    Widget.create
    expect(Widget.count).to eq 1
  end

  # 因为有事务 所以这个数据是独立的  也成立
  it "has none after one was created in a previous example" do
    expect(Widget.count).to eq 0
  end
end

运行测试：

$ rspec spec/models/widget_spec.rb

应该都通过。

明确指定事务开启

#spec/models/widget_spec.rb
require "rails_helper"

RSpec.configure do |c|
  c.use_transactional_examples = true
end

RSpec.describe Widget, :type => :model do
  it "has none to begin with" do
    expect(Widget.count).to eq 0
  end

  it "has one after adding one" do
    Widget.create
    expect(Widget.count).to eq 1
  end

  it "has none after one was created in a previous example" do
    expect(Widget.count).to eq 0
  end
end

运行测试：

$ rspec spec/models/widget_spec.rb

应该都通过。

明确禁用事务

#spec/models/widget_spec.rb" with:
require "rails_helper"

RSpec.configure do |c|
  # 关闭事务 
  c.use_transactional_examples = false
  # 设定公用值
  c.order = "defined"
end

RSpec.describe Widget, :type => :model do
  it "has none to begin with" do
    expect(Widget.count).to eq 0
  end

  it "has one after adding one" do
    Widget.create
    expect(Widget.count).to eq 1
  end

  it "has one after one was created in a previous example" do
    expect(Widget.count).to eq 1
  end

  # 利用after删除
  after(:all) { Widget.destroy_all }
end

运行测试：

$ rspec spec/models/widget_spec.rb

应该都通过。

使用 fixture 预定值

#spec/models/thing_spec.rb
require "rails_helper"

RSpec.describe Thing, :type => :model do
  fixtures :things
  it "fixture method defined" do
    things(:one)
  end
end


#spec/fixtures/things.yml
one:
  name: MyString

运行测试：

$ rspec spec/models/thing_spec.rb

应该都通过。

支持 double

默认情况下，rspec 验证的 double 不支持动态方法。而 instance_double.rspec-rails 通过扩展的方法为列启用了此支持。

例子：

# spec/models/widget_spec.rb
require "rails_helper"

RSpec.describe Widget, :type => :model do
  it "has one after adding one" do
    # 假造一个对象Widget 属性为name
    instance_double("Widget", :name => "my name")
  end
end

为控制器编写 rspec

controller spec 继承自 ActionController::TestCase::Behavior, 允许你发送 http 请求并获取相应的期望：

rendered templates
redirects
controller 与 view 共用的实例变量
cookies

可以像这样制定结果：

标准匹配： (expect(response.status).to eq(200))
标准断言： (assert_equal 200, response.status)
rails 断言 (assert_response 200)

rails-specific 匹配器：

期望渲染了模板

expect(response).to render_template(:new)   # wraps assert_template

期望执行了重定向

expect(response).to redirect_to(location)   # wraps assert_redirected_to

期望得到指定的状态值

expect(response).to have_http_status(:created)

期待新创建了对象

expect(assigns(:widget)).to be_a_new(Widget)

简单实例：

RSpec.describe TeamsController do
  describe "GET index" do
    it "assigns @teams" do
      team = Team.create
      get :index
      expect(assigns(:teams)).to eq([team])
    end

    it "renders the index template" do
      get :index
      expect(response).to render_template("index")
    end
  end
end

指定头信息

require "rails_helper"

RSpec.describe TeamsController, type: :controller do
  describe "GET index" do
    it "returns a 200" do
      # 添加头信息
      request.headers["Authorization"] = "foo"
      # 请求show方法
      get :show
      # 期待返回值是 200
      expect(response).to have_http_status(:ok)
    end
  end
end

controller 相关

简单实例

# spec/controllers/widgets_controller_spec.rb
require "rails_helper"

RSpec.describe WidgetsController, :type => :controller do
  describe "GET index" do
    it "has a 200 status code" do
      get :index
      # 期待状态码的值是 200
      expect(response.status).to eq(200)
    end
  end
end

运行测试

$ rspec spec

all 通过测试

测试返回值的数据类型

# spec/controllers/widgets_controller_spec.rb
require "rails_helper"

RSpec.describe WidgetsController, :type => :controller do
  describe "responds to" do
    it "responds to html by default" do
      post :create, :params => { :widget => { :name => "Any Name" } }
      # 返回值为类型为 "text/html"
      expect(response.content_type).to eq "text/html"
    end

    it "responds to custom formats when provided in the params" do
      post :create, :params => { :widget => { :name => "Any Name" }, :format => :json }
      # 返回值为类型为 "text/html"
      expect(response.content_type).to eq "application/json"
    end
  end
end

运行测试

$ rspec spec

all 通过测试

指定请求参数的数据类型

# spec/controllers/widgets_controller_spec.rb
require "rails_helper"

RSpec.describe WidgetsController, :type => :controller do
  describe "responds to" do
    it "responds to html by default" do
      post :create, :params => { :widget => { :name => "Any Name" } }
      expect(response.content_type).to eq "text/html"
    end

    it "responds to custom formats when provided in the params" do
      # 设定请求参数类型为 json
      post :create, :params => { :widget => { :name => "Any Name" }, :format => :json }
      expect(response.content_type).to eq "application/json"
    end
  end
end

运行测试

$ rspec spec

all 通过测试

测试返回值的数据编码类型

#spec/controllers/widgets_controller_spec.rb
require "rails_helper"

RSpec.describe WidgetsController, :type => :controller do
  describe "responds to" do
    it "responds to html by default" do
      post :create, :params => { :widget => { :name => "Any Name" } }
      # 编码类型为 text/html; charset=utf-8
      expect(response.content_type).to eq "text/html; charset=utf-8"
    end

    it "responds to custom formats when provided in the params" do
      post :create, :params => { :widget => { :name => "Any Name" }, :format => :json }
      # 编码类型为 application/json; charset=utf-8
      expect(response.content_type).to eq "application/json; charset=utf-8"
    end
  end
end

运行测试

$ rspec spec

all 通过测试

测试返回值的 media_type

# spec/controllers/widgets_controller_spec.rb
require "rails_helper"

RSpec.describe WidgetsController, :type => :controller do
  describe "responds to" do
    it "responds to html by default" do
      post :create, :params => { :widget => { :name => "Any Name" } }
      #media_type 为 text/html
      expect(response.media_type).to eq "text/html"
    end

    it "responds to custom formats when provided in the params" do
      post :create, :params => { :widget => { :name => "Any Name" }, :format => :json }
      expect(response.media_type).to eq "application/json"
    end
  end
end

运行测试

$ rspec spec

all 通过测试

指定具体的视图文件

期望通过控制器动作呈现的模板（通过）

# spec/controllers/widgets_controller_spec.rb
require "rails_helper"

RSpec.describe WidgetsController, :type => :controller do
  describe "index" do
    it "renders the index template" do
      get :index
      # 测试渲染了指定的 index 模板
      expect(response).to render_template("index")
      # 测试返回值为 “”
      expect(response.body).to eq ""
    end
    it "renders the widgets/index template" do
      get :index
      expect(response).to render_template("widgets/index")
      expect(response.body).to eq ""
    end
  end
end

运行测试

$ rspec spec

all 通过测试

期望控制器操作未呈现的模板（失败）

# spec/controllers/widgets_controller_spec.rb
require "rails_helper"

RSpec.describe WidgetsController, :type => :controller do
  describe "index" do
    it "renders the 'new' template" do
      get :index
      expect(response).to render_template("new")
    end
  end
end

运行测试

$ rspec spec

没有通过测试

期望在运行时更改视图路径时呈现空模板（通过）

# spec/controllers/things_controller_spec.rb
require "rails_helper"

RSpec.describe ThingsController, :type => :controller do
  describe "custom_action" do
    it "renders an empty custom_action template" do
      # 更改视图路径
      controller.prepend_view_path 'app/views'
      controller.append_view_path 'app/views'
      get :custom_action
      expect(response).to render_template("custom_action")
      expect(response.body).to eq ""
    end
  end
end


#app/controllers/things_controller.rb
class ThingsController < ActionController::Base
  layout false
  def custom_action
  end
end

#app/views/things/custom_action.html.erb
# 空文件

运行测试

$ rspec spec

all 通过测试

在运行时更改视图路径时，期望模板使用 render_views 渲染实际模板（通过）

# spec/controllers/things_controller_spec.rb
require "rails_helper"

RSpec.describe ThingsController, :type => :controller do
  render_views

  it "renders the real custom_action template" do
    controller.prepend_view_path 'app/views'
    get :custom_action
    expect(response).to render_template("custom_action")
    expect(response.body).to match(/template for a custom action/)
  end
end

运行测试

$ rspec spec

all 通过测试

匹配渲染绘图内容

直接在单个组中进行 render_views

# spec/controllers/widgets_controller_spec.rb
require "rails_helper"

RSpec.describe WidgetsController, :type => :controller do
  render_views

  describe "GET index" do
    it "has a widgets related heading" do
      get :index
      expect(response.body).to match /<h1>.*widgets/im
    end
  end
end

运行测试

$ rspec spec

all 通过测试

在嵌套组中打开和关闭 render_views

# spec/controllers/widgets_controller_spec.rb
require "rails_helper"

RSpec.describe WidgetsController, :type => :controller do
  context "with render_views" do
    render_views

    describe "GET index" do
      it "renders the actual template" do
        get :index
        expect(response.body).to match /<h1>.*widgets/im
      end
    end

    context "with render_views(false) nested in a group with render_views" do
      render_views false

      describe "GET index" do
        it "renders the RSpec generated template" do
          get :index
          expect(response.body).to eq("")
        end
      end
    end
  end

  context "without render_views" do
    describe "GET index" do
      it "renders the RSpec generated template" do
        get :index
        expect(response.body).to eq("")
      end
    end
  end

  context "with render_views again" do
    render_views

    describe "GET index" do
      it "renders the actual template" do
        get :index
        expect(response.body).to match /<h1>.*widgets/im
      end
    end
  end
end

运行测试

$ rspec spec --order default --format documentation
WidgetsController
  with render_views
    GET index
      renders the actual template
    with render_views(false) nested in a group with render_views
      GET index
        renders the RSpec generated template
  without render_views
    GET index
      renders the RSpec generated template
  with render_views again
    GET index
      renders the actual template

all 通过测试

全局 render_views

# spec/support/render_views.rb" with:
RSpec.configure do |config|
  config.render_views
end


# spec/controllers/widgets_controller_spec.rb
require "rails_helper"
require "support/render_views"

RSpec.describe WidgetsController, :type => :controller do
  describe "GET index" do
    it "renders the index template" do
      get :index
      expect(response.body).to match /<h1>.*widgets/im
    end
  end
end

运行测试

$ rspec spec

all 通过测试

匿名控制器

使用 controller 方法定义一个匿名控制器，该匿名控制器将从传入的参数所描述的类继承。这对于指定类似全局错误处理的行为很有用。

要指定其他基类，您可以将该类显式传递给 controller 方法：

controller(BaseController)

您还可以禁用基本类型推断，在这种情况下，匿名控制器将默认继承自 ApplicationController 方法而不是所描述的类。

RSpec.configure do |c|
  # 禁用基本类型推断
  c.infer_base_class_for_anonymous_controllers = false
end

RSpec.describe BaseController, :type => :controller do
    # ApplicationController
    controller do
    def index; end

    # this normally creates an anonymous `BaseController` subclass,
    # however since `infer_base_class_for_anonymous_controllers` is
    # disabled, it creates a subclass of `ApplicationController`
  end
end

使用重定向处理在ApplicationController中指定的错误

# spec/controllers/application_controller_spec.rb
require "rails_helper"

class ApplicationController < ActionController::Base
  class AccessDenied < StandardError; end

  rescue_from AccessDenied, :with => :access_denied

private

  def access_denied
    redirect_to "/401.html"
  end
end

RSpec.describe ApplicationController, :type => :controller do
  controller do
    def index
      raise ApplicationController::AccessDenied
    end
  end

  describe "handling AccessDenied exceptions" do
    it "redirects to the /401.html page" do
      get :index
      expect(response).to redirect_to("/401.html")
    end
  end
end

运行测试

$ rspec spec

all 通过测试

使用 render 处理在ApplicationController中指定的错误

# spec/controllers/application_controller_spec.rb
require "rails_helper"

class ApplicationController < ActionController::Base
  class AccessDenied < StandardError; end

  rescue_from AccessDenied, :with => :access_denied

private

  def access_denied
    render "errors/401"
  end
end

RSpec.describe ApplicationController, :type => :controller do
  controller do
    def index
      raise ApplicationController::AccessDenied
    end
  end

  describe "handling AccessDenied exceptions" do
    it "renders the errors/401 template" do
      get :index
      expect(response).to render_template("errors/401")
    end
  end
end

运行测试

$ rspec spec

all 通过测试

使用 render_template 处理在ApplicationController中指定的错误

# spec/controllers/application_controller_spec.rb
require "rails_helper"

class ApplicationController < ActionController::Base
  class AccessDenied < StandardError; end

  rescue_from AccessDenied, :with => :access_denied

private

  def access_denied
    render :file => "errors/401"
  end
end

RSpec.describe ApplicationController, :type => :controller do
  controller do
    def index
      raise ApplicationController::AccessDenied
    end
  end

  describe "handling AccessDenied exceptions" do
    it "renders the errors/401 template" do
      get :index
      expect(response).to render_template("errors/401")
    end
  end
end

运行测试

$ rspec spec

all 通过测试

使用子类处理在ApplicationController中指定的错误

# spec/controllers/application_controller_subclass_spec.rb
require "rails_helper"

class ApplicationController < ActionController::Base
  class AccessDenied < StandardError; end
end

class FoosController < ApplicationController

  rescue_from ApplicationController::AccessDenied, with: :access_denied

private

  def access_denied
    redirect_to "/401.html"
  end
end

RSpec.describe FoosController, :type => :controller do
  controller(FoosController) do
    def index
      raise ApplicationController::AccessDenied
    end
  end

  describe "handling AccessDenied exceptions" do
    it "redirects to the /401.html page" do
      get :index
      expect(response).to redirect_to("/401.html")
    end
  end
end

运行测试

$ rspec spec

all 通过测试

从描述的类中推断基类

# spec/controllers/base_class_can_be_inferred_spec.rb
require "rails_helper"

class ApplicationController < ActionController::Base; end

class FoosController < ApplicationController; end

RSpec.describe FoosController, :type => :controller do
  controller do
    def index
      render :plain => "Hello World"
    end
  end

  it "creates anonymous controller derived from FoosController" do
    expect(controller).to be_a_kind_of(FoosController)
  end
end

运行测试

$ rspec spec

all 通过测试

在描述的类中使用name和controller_name

# spec/controllers/get_name_and_controller_name_from_described_class_spec.rb
require "rails_helper"

class ApplicationController < ActionController::Base; end
class FoosController < ApplicationController; end

RSpec.describe "Access controller names", :type => :controller do
  controller FoosController do
    def index
      @name = self.class.name
      @controller_name = controller_name
      render :plain => "Hello World"
    end
  end

  before do
    get :index
  end

  it "gets the class name as described" do
    expect(assigns[:name]).to eq('FoosController')
  end

  it "gets the controller_name as described" do
    expect(assigns[:controller_name]).to eq('foos')
  end
end

运行测试

$ rspec spec

all 通过测试

在基类中调用around_filter和around_action

# spec/controllers/application_controller_around_filter_spec.rb
require "rails_helper"

class ApplicationController < ActionController::Base
  around_action :an_around_filter

  def an_around_filter
    @callback_invoked = true
    yield
  end
end

RSpec.describe ApplicationController, :type => :controller do
  controller do
    def index
      render :plain => ""
    end
  end

  it "invokes the callback" do
    get :index

    expect(assigns[:callback_invoked]).to be_truthy
  end
end

运行测试

$ rspec spec

all 通过测试

匿名控制器仅创建资源路由

# spec/controllers/application_controller_spec.rb
require "rails_helper"

if defined?(ActionController::UrlGenerationError)
  ExpectedRoutingError = ActionController::UrlGenerationError
else
  ExpectedRoutingError = ActionController::RoutingError
end

RSpec.describe ApplicationController, :type => :controller do
  controller do
    def index
      render :plain => "index called"
    end

    def create
      render :plain => "create called"
    end

    def new
      render :plain => "new called"
    end

    def show
      render :plain => "show called"
    end

    def edit
      render :plain => "edit called"
    end

    def update
      render :plain => "update called"
    end

    def destroy
      render :plain => "destroy called"
    end

    def willerror
      render :plain => "will not render"
    end
  end

  describe "#index" do
    it "responds to GET" do
      get :index
      expect(response.body).to eq "index called"
    end

    it "also responds to POST" do
      post :index
      expect(response.body).to eq "index called"
    end

    it "also responds to PUT" do
      put :index
      expect(response.body).to eq "index called"
    end

    it "also responds to DELETE" do
      delete :index
      expect(response.body).to eq "index called"
    end
  end

  describe "#create" do
    it "responds to POST" do
      post :create
      expect(response.body).to eq "create called"
    end

    # And the rest...
    %w{get post put delete}.each do |calltype|
      it "responds to #{calltype}" do
        send(calltype, :create)
        expect(response.body).to eq "create called"
      end
    end
  end

  describe "#new" do
    it "responds to GET" do
      get :new
      expect(response.body).to eq "new called"
    end

    # And the rest...
    %w{get post put delete}.each do |calltype|
      it "responds to #{calltype}" do
        send(calltype, :new)
        expect(response.body).to eq "new called"
      end
    end
  end

  describe "#edit" do
    it "responds to GET" do
      get :edit, :params => { :id => "anyid" }
      expect(response.body).to eq "edit called"
    end

    it "requires the :id parameter" do
      expect { get :edit }.to raise_error(ExpectedRoutingError)
    end

    # And the rest...
    %w{get post put delete}.each do |calltype|
      it "responds to #{calltype}" do
        send(calltype, :edit, :params => {:id => "anyid"})
        expect(response.body).to eq "edit called"
      end
    end
  end

  describe "#show" do
    it "responds to GET" do
      get :show, :params => { :id => "anyid" }
      expect(response.body).to eq "show called"
    end

    it "requires the :id parameter" do
      expect { get :show }.to raise_error(ExpectedRoutingError)
    end

    # And the rest...
    %w{get post put delete}.each do |calltype|
      it "responds to #{calltype}" do
        send(calltype, :show, :params => {:id => "anyid"})
        expect(response.body).to eq "show called"
      end
    end
  end

  describe "#update" do
    it "responds to PUT" do
      put :update, :params => { :id => "anyid" }
      expect(response.body).to eq "update called"
    end

    it "requires the :id parameter" do
      expect { put :update }.to raise_error(ExpectedRoutingError)
    end

    # And the rest...
    %w{get post put delete}.each do |calltype|
      it "responds to #{calltype}" do
        send(calltype, :update, :params =>  {:id => "anyid"})
        expect(response.body).to eq "update called"
      end
    end
  end

  describe "#destroy" do
    it "responds to DELETE" do
      delete :destroy, :params => { :id => "anyid" }
      expect(response.body).to eq "destroy called"
    end

    it "requires the :id parameter" do
      expect { delete :destroy }.to raise_error(ExpectedRoutingError)
    end

    # And the rest...
    %w{get post put delete}.each do |calltype|
      it "responds to #{calltype}" do
        send(calltype, :destroy, :params => {:id => "anyid"})
        expect(response.body).to eq "destroy called"
      end
    end
  end

  describe "#willerror" do
    it "cannot be called" do
      expect { get :willerror }.to raise_error(ExpectedRoutingError)
    end
  end
end

运行测试

$ rspec spec

all 通过测试

为不从应用程序控制器继承的匿名控制器创建自定义路由

# spec/controllers/other_controller_spec.rb
require "rails_helper"
class OtherController < ActionController::Base
end

RSpec.describe OtherController, :type => :controller do
  controller do
    def custom
      render :plain => "custom called"
    end
  end

  specify "manually draw the route to request a custom action" do
    routes.draw { get "custom" => "other#custom" }

    get :custom
    expect(response.body).to eq "custom called"
  end
end

运行测试

$ rspec spec

all 通过测试

为定义的控制器创建自定义路由

# spec/controllers/application_controller_spec.rb
require "rails_helper"

class FoosController < ApplicationController; end

RSpec.describe ApplicationController, :type => :controller do
  controller FoosController do
    def custom
      render :plain => "custom called"
    end
  end

  specify "manually draw the route to request a custom action" do
    routes.draw { get "custom" => "foos#custom" }

    get :custom
    expect(response.body).to eq "custom called"
  end
end

运行测试

$ rspec spec

all 通过测试

与命名空间控制器一起使用

# spec/controllers/namespaced_controller_spec.rb
require "rails_helper"

class ApplicationController < ActionController::Base; end

module Outer
  module Inner
    class FoosController < ApplicationController; end
  end
end

RSpec.describe Outer::Inner::FoosController, :type => :controller do
  controller do
    def index
      @name = self.class.name
      @controller_name = controller_name
      render :plain => "Hello World"
    end
  end

  it "creates anonymous controller derived from the namespace" do
    expect(controller).to be_a_kind_of(Outer::Inner::FoosController)
  end

  it "gets the class name as described" do
    expect{ get :index }.to change{
      assigns[:name]
    }.to eq('Outer::Inner::FoosController')
  end

  it "gets the controller_name as described" do
    expect{ get :index }.to change{
      assigns[:controller_name]
    }.to eq('foos')
  end
end

运行测试

$ rspec spec

all 通过测试

参阅被测控制器中的应用程序路由

# spec/controllers/application_controller_spec.rb
require "rails_helper"

Rails.application.routes.draw do
  match "/login" => "sessions#new", :as => "login", :via => "get"
end

RSpec.describe ApplicationController, :type => :controller do
  controller do
    def index
      redirect_to login_url
    end
  end

  it "redirects to the login page" do
    get :index
    expect(response).to redirect_to("/login")
  end
end

运行测试

$ rspec spec

all 通过测试

忽略 rescue

使用bypass_rescue可以绕过两个 Rails 对错误的默认处理控制器动作，以及使用 screw_from 声明的任何自定义处理。

这使您可以指定引发异常的详细信息。

背景

# spec/controllers/gadgets_controller_spec_context.rb
class AccessDenied < StandardError; end

class ApplicationController < ActionController::Base
  rescue_from AccessDenied, :with => :access_denied

  private

  def access_denied
    redirect_to "/401.html"
  end
end

使用rescue_from处理标准异常

# spec/controllers/gadgets_controller_spec.rb
require "rails_helper"

require 'controllers/gadgets_controller_spec_context'

RSpec.describe GadgetsController, :type => :controller do
  before do
    def controller.index
      raise AccessDenied
    end
  end

  describe "index" do
    it "redirects to the /401.html page" do
      get :index
      expect(response).to redirect_to("/401.html")
    end
  end
end

运行测试

$ rspec spec/controllers/gadgets_controller_spec.rb

all 通过测试

使用bypass_rescue绕过rescue_from处理

# spec/controllers/gadgets_controller_spec.rb
require "rails_helper"

require 'controllers/gadgets_controller_spec_context'

RSpec.describe GadgetsController, :type => :controller do
  before do
    def controller.index
      raise AccessDenied
    end
  end

  describe "index" do
    it "raises AccessDenied" do
      bypass_rescue
      # 断言抛出异常
      expect { get :index }.to raise_error(AccessDenied)
    end
  end
end

运行测试

$ rspec spec/controllers/gadgets_controller_spec.rb

all 通过测试

路由控制

指定路由引擎

# spec/controllers/widgets_controller_spec.rb
require "rails_helper"

# A very simple Rails engine
module MyEngine
  class Engine < ::Rails::Engine
    isolate_namespace MyEngine
  end

  Engine.routes.draw do
    resources :widgets, :only => [:show] do
      get :random, :on => :collection
    end
  end

  class WidgetsController < ::ActionController::Base
    def random
      @random_widget = Widget.all.shuffle.first
      redirect_to widget_path(@random_widget)
    end

    def show
      @widget = Widget.find(params[:id])
      render :text => @widget.name
    end
  end
end

RSpec.describe MyEngine::WidgetsController, :type => :controller do
  routes { MyEngine::Engine.routes }

  it "redirects to a random widget" do
    widget1 = Widget.create!(:name => "Widget 1")
    widget2 = Widget.create!(:name => "Widget 2")

    get :random
    expect(response).to be_redirect
    expect(response).to redirect_to(assigns(:random_widget))
  end
end

运行测试

$ rspec spec

all 通过测试

Cookies

测试在控制器中清除 cookie 的值

# spec/controllers/application_controller_spec.rb
require "rails_helper"

RSpec.describe ApplicationController, :type => :controller do
  controller do
    def clear_cookie
      cookies.delete(:user_name)
      head :ok
    end
  end

  before do
    routes.draw { get "clear_cookie" => "anonymous#clear_cookie" }
  end

  it "clear cookie's value 'user_name'" do
    cookies[:user_name] = "Sam"

    get :clear_cookie

    expect(cookies[:user_name]).to eq nil
  end
end

运行测试

$ rspec spec

all 通过测试

设置请求头

不推荐直接在控制器中设置请求头，如果非要设置，请使用下面的 request.headers 方法

设置请求头

# spec/controllers/application_controller_spec.rb
require "rails_helper"

RSpec.describe ApplicationController, type: :controller do
  controller do
    def show
      if request.headers["Authorization"] == "foo"
        head :ok
      else
        head :forbidden
      end
    end
  end

  before do
    routes.draw { get "show" => "anonymous#show" }
  end

  context "valid Authorization header" do
    it "returns a 200" do
      request.headers["Authorization"] = "foo"

      get :show

      expect(response).to have_http_status(:ok)
    end
  end

  context "invalid Authorization header" do
    it "returns a 403" do
      request.headers["Authorization"] = "bar"

      get :show

      expect(response).to have_http_status(:forbidden)
    end
  end
end

运行测试

$ rspec spec

all 通过测试

期望值匹配

rspec-rails 提供了许多自定义匹配器，其中大多数是 rspec 的用于 Rails 的断言装饰器。所以完全兼容 Rails 默认的断言方式。

关于兼容性，例如：

# rails 写法
assert_equal 403, response.status
assert_response 403
# rspec写法
expect(response).to have_http_status(403)

完全等价

Be_a_new 新建

四个 be_a_new 示例

# spec/models/widget_spec.rb
require "rails_helper"

RSpec.describe Widget do
  context "when initialized" do
    subject(:widget) { Widget.new }

    it "is a new widget" do
      expect(widget).to be_a_new(Widget)
    end

    it "is not a new string" do
      expect(widget).not_to be_a_new(String)
    end
  end

  context "when saved" do
    subject(:widget) { Widget.create }

    it "is not a new widget" do
      expect(widget).not_to be_a_new(Widget)
    end

    it "is not a new string" do
      expect(widget).not_to be_a_new(String)
    end
  end
end

运行测试

$ rspec spec/models/widget_spec.rb

all 通过测试

Render_template

3 种 render_template 示例

# spec/controllers/gadgets_spec.rb
require "rails_helper"

RSpec.describe GadgetsController do
  describe "GET #index" do
    subject { get :index }

    it "renders the index template" do
      expect(subject).to render_template(:index)
      expect(subject).to render_template("index")
      expect(subject).to render_template("gadgets/index")
    end

    it "does not render a different template" do
      expect(subject).to_not render_template("gadgets/show")
    end
  end
end

运行测试

$ rspec spec/controllers/gadgets_spec.rb

all 通过测试

指定 layout

# spec/controllers/gadgets_spec.rb
require "rails_helper"

RSpec.describe GadgetsController do
  describe "GET #index" do
    subject { get :index }

    it "renders the application layout" do
      expect(subject).to render_template("layouts/application")
    end

    it "does not render a different layout" do
      expect(subject).to_not render_template("layouts/admin")
    end
  end
end

运行测试

$ rspec spec/controllers/gadgets_spec.rb

all 通过测试

视图中使用

# spec/views/gadgets/index.html.erb_spec.rb
require "rails_helper"

RSpec.describe "gadgets/index" do
  it "renders the index template" do
    assign(:gadgets, [Gadget.create!])
    render

    expect(view).to render_template(:index)
    expect(view).to render_template("index")
    expect(view).to render_template("gadgets/index")
  end

  it "does not render a different template" do
    expect(view).to_not render_template("gadgets/show")
  end
end

运行测试

$ rspec spec/views

all 通过测试

Redirect_to

4 种 redirect_to 示例

# spec/controllers/widgets_controller_spec.rb
require "rails_helper"

RSpec.describe WidgetsController do

  describe "#create" do
    subject { post :create, :params => { :widget => { :name => "Foo" } } }

    it "redirects to widget_url(@widget)" do
      expect(subject).to redirect_to(widget_url(assigns(:widget)))
    end

    it "redirects_to :action => :show" do
      expect(subject).to redirect_to :action => :show,
                                     :id => assigns(:widget).id
    end

    it "redirects_to(@widget)" do
      expect(subject).to redirect_to(assigns(:widget))
    end

    it "redirects_to /widgets/:id" do
      expect(subject).to redirect_to("/widgets/#{assigns(:widget).id}")
    end
  end
end

运行测试

$  rspec spec/controllers/widgets_controller_spec.rb

all 通过测试

have_http_status

检查数字状态码

# spec/controllers/application_controller_spec.rb
require "rails_helper"

RSpec.describe ApplicationController, :type => :controller do

  controller do
    def index
      render :json => {}, :status => 209
    end
  end

  describe "GET #index" do
    it "returns a 209 custom status code" do
      get :index
      expect(response).to have_http_status(209)
    end
  end

end

运行测试

$  rspec spec

all 通过测试

检查符号状态码

# spec/controllers/application_controller_spec.rb
require "rails_helper"

RSpec.describe ApplicationController, :type => :controller do

  controller do
    def index
      render :json => {}, :status => :see_other
    end
  end

  describe "GET #index" do
    it "returns a :see_other status code" do
      get :index
      expect(response).to have_http_status(:see_other)
    end
  end

end

运行测试

$  rspec spec

all 通过测试

检查通用符号状态类型

# spec/controllers/application_controller_spec.rb
require "rails_helper"

RSpec.describe ApplicationController, :type => :controller do

  controller do
    def index
      render :json => {}, :status => :bad_gateway
    end
  end

  describe "GET #index" do
    it "returns a some type of error status code" do
      get :index
      expect(response).to have_http_status(:error)
    end
  end

end

运行测试

$  rspec spec

all 通过测试

在控制器中使用

# spec/controllers/gadgets_spec.rb
require "rails_helper"

RSpec.describe GadgetsController, :type => :controller do

  describe "GET #index" do
    it "returns a 200 OK status" do
      get :index
      expect(response).to have_http_status(:ok)
    end
  end

end

运行测试

$  rspec spec/controllers/gadgets_spec.rb

all 通过测试

在 request 中使用

# spec/requests/gadgets/widget_management_spec.rb
require "rails_helper"

RSpec.describe "Widget management", :type => :request do

  it "creates a Widget and redirects to the Widget's page" do
    get "/widgets/new"
    expect(response).to have_http_status(:ok)

    post "/widgets", :params => { :widget => {:name => "My Widget"} }
    expect(response).to have_http_status(302)

    follow_redirect!

    expect(response).to have_http_status(:success)
  end

end

运行测试

$  rspec spec/requests

all 通过测试

在 feature 中使用

# spec/features/widget_management_spec.rb
require "rails_helper"

RSpec.feature "Widget management", :type => :feature do

  scenario "User creates a new widget" do
    visit "/widgets/new"
    expect(page).to have_http_status(200)

    click_button "Create Widget"

    expect(page).to have_http_status(:success)
  end

end

运行测试

$  rspec spec/features/widget_management_spec.rb

all 通过测试

match_array

实例

# spec/models/widget_spec.rb
require "rails_helper"

RSpec.describe Widget do
  let!(:widgets) { Array.new(3) { Widget.create } }

  subject { Widget.all }

  it "returns all widgets in any order" do
    expect(subject).to match_array(widgets)
  end
end

运行测试

$ rspec spec/models/widget_spec.rb

all 通过测试

Have_been_enqueued

检查指定的任务是否在排队

检查任务的类名

# spec/jobs/upload_backups_job_spec.rb
require "rails_helper"

RSpec.describe UploadBackupsJob do
  it "matches with enqueued job" do
    ActiveJob::Base.queue_adapter = :test
    UploadBackupsJob.perform_later
    expect(UploadBackupsJob).to have_been_enqueued
  end
end

运行测试

$ rspec spec/jobs/upload_backups_job_spec.rb

all 通过测试

检查任务传参

# spec/jobs/upload_backups_job_spec.rb
require "rails_helper"

RSpec.describe UploadBackupsJob do
  it "matches with enqueued job" do
    ActiveJob::Base.queue_adapter = :test
    UploadBackupsJob.perform_later("users-backup.txt", "products-backup.txt")
    expect(UploadBackupsJob).to(
      have_been_enqueued.with("users-backup.txt", "products-backup.txt")
    )
  end
end

运行测试

$ rspec spec/jobs/upload_backups_job_spec.rb

all 通过测试

检查任务排队时间

# spec/jobs/upload_backups_job_spec.rb"
require "rails_helper"

RSpec.describe UploadBackupsJob do
  it "matches with enqueued job" do
    ActiveJob::Base.queue_adapter = :test
    UploadBackupsJob.set(:wait_until => Date.tomorrow.noon).perform_later
    expect(UploadBackupsJob).to have_been_enqueued.at(Date.tomorrow.noon)
  end
end

运行测试

$ rspec spec/jobs/upload_backups_job_spec.rb

all 通过测试

检查没有等待的工作

# spec/jobs/upload_backups_job_spec.rb
require "rails_helper"

RSpec.describe UploadBackupsJob do
  it "matches with enqueued job" do
    ActiveJob::Base.queue_adapter = :test
    UploadBackupsJob.perform_later
    expect(UploadBackupsJob).to have_been_enqueued.at(:no_wait)
  end
end

运行测试

$ rspec spec/jobs/upload_backups_job_spec.rb

all 通过测试

检查任务队列名称

# spec/jobs/upload_backups_job_spec.rb" with:
require "rails_helper"

RSpec.describe UploadBackupsJob do
  it "matches with enqueued job" do
    ActiveJob::Base.queue_adapter = :test
    UploadBackupsJob.perform_later
    expect(UploadBackupsJob).to have_been_enqueued.on_queue("default")
  end
end

运行测试

$ rspec spec/jobs/upload_backups_job_spec.rb

all 通过测试

Have_been_performed

检查任务是否已经执行

检查任务类名

# spec/jobs/upload_backups_job_spec.rb
require "rails_helper"

RSpec.describe UploadBackupsJob do
  it "matches with performed job" do
    ActiveJob::Base.queue_adapter = :test
    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
    UploadBackupsJob.perform_later
    expect(UploadBackupsJob).to have_been_performed
  end
end

运行测试

$ rspec spec/jobs/upload_backups_job_spec.rb

all 通过测试

检查任务参数

# spec/jobs/upload_backups_job_spec.rb
require "rails_helper"

RSpec.describe UploadBackupsJob do
  it "matches with performed job" do
    ActiveJob::Base.queue_adapter = :test
    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
    UploadBackupsJob.perform_later("users-backup.txt", "products-backup.txt")
    expect(UploadBackupsJob).to(
      have_been_performed.with("users-backup.txt", "products-backup.txt")
    )
  end
end

运行测试

$ rspec spec/jobs/upload_backups_job_spec.rb

all 通过测试

检查任务执行时间

# spec/jobs/upload_backups_job_spec.rb
require "rails_helper"

RSpec.describe UploadBackupsJob do
  it "matches with performed job" do
    ActiveJob::Base.queue_adapter = :test
    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
    ActiveJob::Base.queue_adapter.perform_enqueued_at_jobs = true
    UploadBackupsJob.set(:wait_until => Date.tomorrow.noon).perform_later
    expect(UploadBackupsJob).to have_been_performed.at(Date.tomorrow.noon)
  end
end

运行测试

$ rspec spec/jobs/upload_backups_job_spec.rb

all 通过测试

检查任务队列名

# spec/jobs/upload_backups_job_spec.rb
require "rails_helper"

RSpec.describe UploadBackupsJob do
  it "matches with performed job" do
    ActiveJob::Base.queue_adapter = :test
    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
    UploadBackupsJob.perform_later
    expect(UploadBackupsJob).to have_been_performed.on_queue("default")
  end
end

运行测试

$ rspec spec/jobs/upload_backups_job_spec.rb

all 通过测试

request rspec

Request spec

使用 Rails 内部方法管理 Widget

# spec/requests/widget_management_spec.rb
require "rails_helper"

RSpec.describe "Widget management", :type => :request do

  it "creates a Widget and redirects to the Widget's page" do
    get "/widgets/new"
    expect(response).to render_template(:new)

    post "/widgets", :params => { :widget => {:name => "My Widget"} }

    expect(response).to redirect_to(assigns(:widget))
    follow_redirect!

    expect(response).to render_template(:show)
    expect(response.body).to include("Widget was successfully created.")
  end

  it "does not render a different template" do
    get "/widgets/new"
    expect(response).to_not render_template(:show)
  end
end

运行测试

$ rspec spec/requests/widget_management_spec.rb

all 通过测试

发送 json 请求数据

# spec/requests/widget_management_spec.rb
require "rails_helper"

RSpec.describe "Widget management", :type => :request do

  it "creates a Widget" do
    # 设置请求头
    headers = { "ACCEPT" => "application/json" }
    # 设置响应数据格式
    post "/widgets", :params => { :widget => {:name => "My Widget"} }, :headers => headers

    expect(response.content_type).to eq("application/json")
    expect(response).to have_http_status(:created)
  end

end

运行测试

$ rspec spec/requests/widget_management_spec.rb

all 通过测试

请求 json 响应数据

# spec/requests/widget_management_spec.rb
require "rails_helper"

RSpec.describe "Widget management", :type => :request do
  it "creates a Widget" do
    headers = { "ACCEPT" => "application/json" }
    post "/widgets", :params => { :widget => {:name => "My Widget"} }, :headers => headers

    expect(response.content_type).to eq("application/json; charset=utf-8")
    expect(response).to have_http_status(:created)
  end
end

运行测试

$ rspec spec/requests/widget_management_spec.rb

all 通过测试

请求 json 数据

# spec/requests/widget_management_spec.rb
require "rails_helper"

RSpec.describe "Widget management", :type => :request do

  it "creates a Widget and redirects to the Widget's page" do
    # 设置请求数据的格式
    headers = { "CONTENT_TYPE" => "application/json" }
    post "/widgets", :params => '{ "widget": { "name":"My Widget" } }', :headers => headers
    expect(response).to redirect_to(assigns(:widget))
  end

end

运行测试

$ rspec spec/requests/widget_management_spec.rb

all 通过测试

使用路由辅助方法

# spec/requests/widgets_spec.rb
require "rails_helper"

# 简单的 Rails engine
module MyEngine
  class Engine < ::Rails::Engine
    isolate_namespace MyEngine
  end

  class LinksController < ::ActionController::Base
    def index
      render plain: 'hit_engine_route'
    end
  end
end

MyEngine::Engine.routes.draw do
  resources :links, :only => [:index]
end

Rails.application.routes.draw do
  mount MyEngine::Engine => "/my_engine"
end

module MyEngine
  RSpec.describe "Links", :type => :request do
    include Engine.routes.url_helpers

    it "redirects to a random widget" do
      # 允许使用 辅助方法访问
      get links_path
      expect(response.body).to eq('hit_engine_route')
    end
  end
end

运行测试

$ rspec spec

all 通过测试

Mailer specs

URL helpers

使用 url 辅助方法的默认参数

# config/initializers/mailer_defaults.rb
Rails.configuration.action_mailer.default_url_options = { :host => 'example.com' }


# spec/mailers/notifications_spec.rb
require 'rails_helper'

RSpec.describe NotificationsMailer, :type => :mailer do
  it 'should have access to URL helpers' do
    expect { gadgets_url }.not_to raise_error
  end
end

运行测试

$ rspec spec

all 通过测试

使用 url 辅助方法，不使用默认参数

# config/initializers/mailer_defaults.rb
# no default options

#spec/mailers/notifications_spec.rb
require 'rails_helper'

RSpec.describe NotificationsMailer, :type => :mailer do
  it 'should have access to URL helpers' do
    expect { gadgets_url :host => 'example.com' }.not_to raise_error
    expect { gadgets_url }.to raise_error
  end
end

运行测试

$ rspec spec

all 通过测试

Mailer

简单实例

# spec/mailers/notifications_mailer_spec.rb" with:
require "rails_helper"

# 最外层的架构快
# RSpec.describe 类名, :type => :类型 do
RSpec.describe NotificationsMailer, :type => :mailer do
  # 一个 describe 块
  describe "notify" do
    let(:mail) { NotificationsMailer.signup }
  # 一个测试用例
    it "renders the headers" do
      # expect(值).to eq(等于的值)
      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 match("Hi")
    end
  end
end

运行测试

$ rspec spec

all 通过测试

File fixture

Rails 5 新增 file fixture 对象。

稳进默认存储路径：spec/fixtures/files

File fixtures 代表了 +Pathname+ 对象，使用很简单。

实例：

file_fixture("example.txt").read # get the file's content
file_fixture("example.mp3").size # get the file size

通过配置可以改变默认文件位置

RSpec.configure do |config|
  config.file_fixture_path = "spec/custom_directory"
end

读取文件内容

# spec/fixtures/files/sample.txt
Hello


# spec/lib/file_spec.rb
require "rails_helper"

RSpec.describe "file" do
  it "reads sample file" do
    #期待.读取文件的内容.为 等于("hello")
    expect(file_fixture("sample.txt").read).to eq("Hello")
  end
end

运行测试

$ rspec spec/lib/file_spec.rb

all 通过测试

imanner (来见证奇迹!)

在 Rails7 中使用 devise 的邮箱验证

安装 mailcatcher

创建新项目

快速美化 UI

安装 devise

配置 SMTP 信息

重启服务器！！！！！

创建测试页

测试

Have fun, Enjoy yourself, ^ _ ^!

gRPC 快速开始 | 翻译并修复官方文档几处 bug | 更新软件版本到最新 | 已经提交 Pull 给官方

gRPC | 快速开始

环境准备

获取示例代码

运行示例

升级一下我们的 gRPC 服务

重新创建 gRPC 代码

升级并运行项目

升级服务端

升级客户端

运行吧！

下一步要做啥

支持 Docker-compose,内置指令集,提供原生开发体验, LNPPR-Docker 一键安装脚本, 让工作更快更轻松

LNPPR 一键配置脚本升级，支持 Docker

让工作更快更轻松！

脚本说明

脚本特点

使用要求

特殊说明

使用说明

* 配置文件 docker.conf 说明 *

* 配置文件 rails_new.conf 说明 *

* 内置默认指令集 说明 *

L(inux) N(ginx) P(uma) P(ostgresql) R(ails) 一键安装脚本, 让工作更快更轻松

LNPPR 一键安装脚本

==让工作更快更轻松！==

脚本说明

脚本特点

使用要求

# 特殊说明

安装要求

使用说明

* 配置文件 install.conf 说明 *

安装参考

硬件配置

测试平台：CentOS 7.9x64

GCC 版本：4.8.5

测试平台：Debian 11x64

GCC 版本：10.2.1

论坛献礼：使用 Rails 6 开发纯后端 API 项目

使用 rails6 开发纯后端 API 项目

前言

本书简介

你将收获

本书约定

感谢

本书参与者【排名不分先后】

期待

rspec5 一览大文

安装

添加到 Gemfile

安装

初始化成为默认测试框架

运行测试

或者

测试框架

内置创建器

事务

禁用事务

利用 before 关键字实现自动回滚的控制

目录结构建议

rspec 的目录规范

自动识别类型

建议

场景

Backtrace 过滤

局部使用 filter_rails_from_backtrace!

为模型编写 rspec

事务的例子

* 内置默认指令集说明 *

利用 `before` 关键字实现自动回滚的控制

局部使用 `filter_rails_from_backtrace!`