Larvata

declare examples using the it method

an example group is a class in which the block passed to describe is evaluated

The blocks passed to it are evaluated in the context of an instance of that class

nested groups using the describe or context methods

can declare example groups using either describe or context

can declare examples within a group using any of it, specify, or example

Nearly anything that can be declared within an example group can be declared within a shared example group.

shared_context and include_context.

When a class is passed to describe, you can access it from an example using the described_class method

rspec-core stores a metadata hash with every example and group

Example groups are defined by a describe or context block, which is eagerly evaluated when the spec file is loaded

Examples -- typically defined by an it block -- and any other blocks with per-example semantics -- such as a before(:example) hook -- are evaluated in the context of an instance of the example group class to which the example belongs.

這其實是一種投資，如果是簡單的程式，也許你手動執行一次就寫對了，但是如果是複雜的程式，往往第一次不會寫對，你會浪費很多時間在檢查到底你寫的程式的正確性，而寫測試就可以大大的節省這些時間。更不用說你明天，下個禮拜或下個月需要再確認其他程式有沒有副作用影響的時候，你有一組測試程式可以大大節省手動檢查的時間。

幾乎每種語言都有一套叫做xUnit測試框架的測試工具

標準流程是 1. (Setup) 設定測試資料 2. (Exercise) 執行要測試的方法 3. (Verify) 檢查結果是否正確 4. (Teardown) 清理還原資料

RSpec是一套改良版的xUnit測試框架，非常風行於Rails社群

個別的單元測試應該是獨立不會互相影響的

一個it區塊，就是一個單元測試，裡面的expect方法會進行驗證。

RSpec裡，我們又把一個小單元測試叫做example

BDD(Behavior-driven development)測試框架，相較於TDD用test思維，測試程式的結果。BDD強調的是用spec思維，描述程式應該有什麼行為。

describe和context幫助你組織分類，都是可以任意套疊的。

每個it就是一小段測試，在裡面我們會用expect(…).to來設定期望

let可以用來簡化上述的before用法，並且支援lazy evaluation和memoized，也就是有需要才初始，並且不同單元測試之間，只會初始化一次，可以增加測試執行效率

let!則會在測試一開始就先初始一次，而不是lazy evaluation。

先列出來預計要寫的測試，或是暫時不要跑的測試

specify和example都是it方法的同義字。

進階一點你可以自己寫Matcher

RSpec分成數種不同測試，分別是Model測試、Controller測試、View測試、Helper測試、Route和Request測試

Rails內建有Fixture功能可以建立假資料，方法是為每個Model使用一份YAML資料。

記得確認每個測試案例之間的測試資料需要清除

mount multiple API implementations inside another one

mount on a path, which is similar to using prefix inside the mounted API itself.

four strategies in which clients can reach your API's endpoints: :path, :header, :accept_version_header and :param

clients should pass the desired version as a request parameter, either in the URL query string or in the request body.

clients should pass the desired version in the HTTP Accept head

clients should pass the desired version in the UR

clients should pass the desired version in the HTTP Accept-Version header.

add a description to API methods and namespaces

Parameters are automatically populated from the request body on POST and PUT

route string parameters will have precedence.

Grape allows you to access only the parameters that have been declared by your params block

By default declared(params) includes parameters that have nil values

type: File

JSON objects and arrays of objects are accepted equally

any class can be used as a type so long as an explicit coercion method is supplied

As a special case, variant-member-type collections may also be declared, by passing a Set or Array with more than one member to type

Parameters can be nested using group or by calling requires or optional with a block

relevant if another parameter is given

Parameters options can be grouped

allow_blank can be combined with both requires and optional

Parameters can be restricted to a specific set of values

Parameters can be restricted to match a specific regular expression

Never define mutually exclusive sets with any required params

Namespaces allow parameter definitions and apply to every method within the namespace

define a route parameter as a namespace using route_param

create custom validation that use request to validate the attribute

rescue a Grape::Exceptions::ValidationErrors and respond with a custom response or turn the response into well-formatted JSON for a JSON API that separates individual parameters and the corresponding error messages

custom validation messages

Request headers are available through the headers helper or from env in their original form

define requirements for your named route parameters using regular expressions on namespace or endpoint

mix in a module

define reusable params

using cookies method

a 201 for POST-Requests

204 for DELETE-Requests

200 status code for all other Requests

use status to query and set the actual HTTP Status Code

raising errors with error!

rescue_from will rescue the exceptions listed and all their subclasses.

Grape::API provides a logger method which by default will return an instance of the Logger class from Ruby's standard library.

Grape supports a range of ways to present your data

Grape has built-in Basic and Digest authentication (the given block is executed in the context of the current Endpoint).

Blocks can be executed before or after every API call, using before, after, before_validation and after_validation

Grape by default anchors all request paths, which means that the request URL should match from start to end to match

test a Grape API with RSpec by making HTTP requests and examining the response

POST JSON data and specify the correct content-type.

A certificate is considered a duplicate of an earlier certificate if they contain the exact same set of hostnames, ignoring capitalization and ordering of hostnames.

a Renewal Exemption to the Certificates per Registered Domain limit.

The Duplicate Certificate limit and the Renewal Exemption ignore the public key and extensions requested

You can issue 20 certificates in week 1, 20 more certificates in week 2, and so on, while not interfering with renewals of existing certificates.

Revoking certificates does not reset rate limits

If you’ve hit a rate limit, we don’t have a way to temporarily reset it.

get a list of certificates issued for your registered domain by searching on crt.sh

If you have a large number of pending authorization objects and are getting a rate limiting error, you can trigger a validation attempt for those authorization objects by submitting a JWS-signed POST to one of its challenges, as described in the ACME spec.

If you do not have logs containing the relevant authorization URLs, you need to wait for the rate limit to expire.

having a large number of pending authorizations is generally the result of a buggy client

application’s logic is a great example of a component

Aspects cross-cut our application - when we use some kind of persistence (e.g. a database) or network communication (such as ZMQ sockets) our components need to know about it.

It’s responsible for pushing snippets scenario

SRP-conformant object

the join points in Ruby

advice

In most cases after and before advice are sufficient.

to provide a join point

You’ll often see empty methods in code written in AOP paradigm

provide aspect code to link with our use case

use case is a pure domain object, without even knowing it’s connected with some kind of persistence and logging layer.

Aspect-oriented programming is fixing the problem with polluting pure logic objects with technical context of our applications.

we treat our glues as a configuration part, not the logic part of our apps.

config/environments/production.rb

Create an additional staging environment that closely resembles the production one

Keep any additional configuration in YAML files under the config/ directory

Rails::Application.config_for(:yaml_file)

Use nested routes to express better the relationship between ActiveRecord models

nest routes more than 1 level deep then use the shallow: true option

namespaced routes to group related actions

Keep the controllers skinny

all the business logic should naturally reside in the model

Share no more than two instance variables between a controller and a view.

using a template

Prefer corresponding symbols to numeric HTTP status codes

without abbreviations

Keep your models for business logic and data-persistence only

Avoid altering ActiveRecord defaults (table names, primary key, etc)

Prefer has_many :through to has_and_belongs_to_many

self[:attribute]

self[:attribute] = value

validates

Consider extracting custom validators to a shared gem

preferable to make a class method instead which serves the same purpose of the named scope

.update_attributes

Override the to_param method of the model

Use the friendly_id gem. It allows creation of human-readable URLs by using some descriptive attribute of the model instead of its id

.find_each

.find_each

Looping through a collection of records from the database (using the all method, for example) is very inefficient since it will try to instantiate all the objects at once

always call before_destroy callbacks that perform validation with prepend: true

When persisting AR objects

Avoid string interpolation in queries

param will be properly escaped

Consider using named placeholders instead of positional placeholders

use of find over where when you need to retrieve a single record by id

use of find_by over where and find_by_attribute

use of where.not over SQL

use heredocs with squish

Use rake db:schema:load instead of rake db:migrate to initialize an empty database

change_column_default

imposing data integrity from the Rails app is impossible

use the change method instead of up and down methods.

constructive migrations

use models in migrations, make sure you define them so that you don't end up with broken migrations in the future

In this case, block will be used by create_table in rollback

Never make complex formatting in the views, export the formatting to a method in the view helper or the model.

When the labels of an ActiveRecord model need to be translated, use the activerecord scope

Separate the texts used in the views from translations of ActiveRecord attributes

config/application.rb config.i18n.load_path += Dir[Rails.root.join('config', 'locales', '**', '*.{rb,yml}')]

I18n.t

I18n.l

Use "lazy" lookup for the texts used in views.

Use the dot-separated keys in the controllers and models

Reserve app/assets for custom stylesheets, javascripts, or images

Third party code such as jQuery or bootstrap should be placed in vendor/assets

Provide both HTML and plain-text view templates

config.action_mailer.raise_delivery_errors = true

Use a local SMTP server like Mailcatcher in the development environment

Provide default settings for the host name

The _url methods include the host name and the _path methods don't

Format the from and to addresses properly

default from:

sending html emails all styles should be inline

Sending emails while generating page response should be avoided. It causes delays in loading of the page and request can timeout if multiple email are sent.

.start_with?

.end_with?

&.

Config your timezone accordingly in application.rb

config.active_record.default_timezone = :local

it can be only :utc or :local

Time.zone.parse

Time.zone.now