Rails%203%20In%20Action

Middleware
To make your first test pass you’ll need to check that your find_user method actually
returns a valid user; otherwise you’ll return this 404 response. The best place to do
this would be inside the find_user method itself, turning it into this:
def find_user
@user = User.find_by_authentication_token(params[:token])
halt 401, "Token is invalid." unless @user
end
The halt method here will stop a request dead in its tracks. In this case, it will return
a 401 status code with the body being the string specified. When you run your tests
again the first two should be passing, with the third one still failing:
3 examples, 1 failure
Alright, so now if an invalid token is passed, you’re throwing exactly the same error as
the last two iterations of your API did—good progress! Finally, you’ll need to send a
404 response when a project cannot be found within the scope for the current user.
To do this, change the find_project method in your app to this:
def find_project
@project = Project.for(@user).find(params[:project_id])
rescue ActiveRecord::RecordNotFound
halt 404, "The project you were looking for could not be found."
end
When you run your tests for a final time with bundle exec rspec spec/api/v3/
tickets_spec.rb, they should all pass:
3 examples, 0 failures
Awesome! This should give you a clear idea of how you could implement an API similar
to the one you created back in chapter 13 by using the lightweight framework of
Sinatra. All of this is possible because Rails provides an easy way to mount Rack-based
applications inside your Rails applications. You could go further with this API, but this
is probably another exercise for you later on if you wish to undertake it.
You’ve learned how you can use Rack applications to serve as endpoints of
requests, but you can also create pieces that hook into the middle of the request cycle
called middleware. Rails has a few of these already, and you saw the effects of one of
them when you were able to access the env["action_dispatch.request.path
_parameters"] key inside your Sinatra application. Without the middleware of the
Rails stack, this parameter would be unavailable. In the next section, we look at the
middleware examples in the real world, including some found in the Rails stack, as
well as how you can build and use your own.
18.4 Middleware
When a request comes into a Rack application, it doesn’t go straight to a single place
that serves the request. Instead, it goes through a series of pieces known as middleware,
which may process the request before it gets to the end of the stack (your application)
or modify it and pass it onward, as shown in figure 18.3.
533