Comment appeler des méthodes contrôleur / vue à partir de la console dans Rails?

StackOverflow https://stackoverflow.com/questions/151030

  •  02-07-2019
  •  | 
  •  

Question

Lorsque je charge script / console , je souhaite parfois jouer avec la sortie d'un contrôleur ou d'une méthode d'assistance de vue.

Existe-t-il des moyens pour:

  • simuler une demande?
  • appeler des méthodes depuis une instance de contrôleur sur ladite requête?
  • tester des méthodes d'assistance, via l'instance de contrôleur ou par un autre moyen?
Était-ce utile?

La solution

Pour appeler les assistants, utilisez l'objet helper : 

$ ./script/console
>> helper.number_to_currency('123.45')
=> "R$ 123,45"

Si vous souhaitez utiliser un utilitaire qui n'est pas inclus par défaut (par exemple, car vous avez supprimé helper: all de ApplicationController ), incluez simplement l'assistant. 

>> include BogusHelper
>> helper.bogus
=> "bogus output"

En ce qui concerne les contrôleurs , je cite La réponse de Nick : 

> app.get '/posts/1'
> response = app.response
# you now have a rails response object much like the integration tests

> response.body            # get you the HTML
> response.cookies         # hash of the cookies

# etc, etc

Autres conseils

Une méthode simple pour appeler une action de contrôleur à partir de script / console et afficher / manipuler l'objet de réponse est la suivante: 

> app.get '/posts/1'
> response = app.response
# you now have a rails response object much like the integration tests

> response.body            # get you the HTML
> response.cookies         # hash of the cookies

# etc, etc

L'objet d'application est une instance de ActionController :: Integration :: Session

Cela fonctionne pour moi avec Rails 2.1 et 2.3, je n'ai pas essayé les versions précédentes.

Si vous devez tester depuis la console (testé sur Rails 3.1 et 4.1):

Actions du contrôleur d'appel: 

app.get '/'              
   app.response            
   app.response.headers  # => { "Content-Type"=>"text/html", ... }
   app.response.body     # => "<!DOCTYPE html>\n<html>\n\n<head>\n..."

Méthodes ApplicationController: 

foo = ActionController::Base::ApplicationController.new
foo.public_methods(true||false).sort
foo.some_method

Assistants de routage: 

app.myresource_path     # => "/myresource" 
app.myresource_url      # => "http://www.example.com/myresource"

Afficher les aides: 

foo = ActionView::Base.new

foo.javascript_include_tag 'myscript' #=> "<script src=\"/javascripts/myscript.js\"></script>"

helper.link_to "foo", "bar" #=> "<a href=\"bar\">foo</a>"

ActionController::Base.helpers.image_tag('logo.png')  #=> "<img alt=\"Logo\" src=\"/images/logo.png\" />"

Rendu: 

views = Rails::Application::Configuration.new(Rails.root).paths["app/views"]
views_helper = ActionView::Base.new views
views_helper.render 'myview/mytemplate'
views_helper.render file: 'myview/_mypartial', locals: {my_var: "display:block;"}
views_helper.assets_prefix  #=> '/assets'

Méthodes ActiveSupport: 

require 'active_support/all'
1.week.ago
=> 2013-08-31 10:07:26 -0300
a = {'a'=>123}
a.symbolize_keys
=> {:a=>123}

Lib modules: 

> require 'my_utils'
 => true 
> include MyUtils
 => Object 
> MyUtils.say "hi"
evaluate: hi
 => true

Voici un moyen de procéder via la console: 

>> foo = ActionView::Base.new
=> #<ActionView::Base:0x2aaab0ac2af8 @assigns_added=nil, @assigns={}, @helpers=#<ActionView::Base::ProxyModule:0x2aaab0ac2a58>, @controller=nil, @view_paths=[]>

>> foo.extend YourHelperModule
=> #<ActionView::Base:0x2aaab0ac2af8 @assigns_added=nil, @assigns={}, @helpers=#<ActionView::Base::ProxyModule:0x2aaab0ac2a58>, @controller=nil, @view_paths=[]>

>> foo.your_helper_method(args)
=> "<html>created by your helper</html>"

La création d'une nouvelle instance de ActionView :: Base vous donne accès aux méthodes d'affichage normales que votre assistant utilise probablement. Ensuite, l'extension de YourHelperModule mélange ses méthodes dans votre objet, ce qui vous permet d'afficher leurs valeurs de retour.

Une autre façon de faire consiste à utiliser le débogueur de rails. Un http://guides.rubyonrails.org/debugging_rails_applications.html contient un guide Rails sur le débogage.

Fondamentalement, démarrez le serveur avec l'option -u: 

./script/server -u

Ensuite, insérez dans votre script un point d'arrêt permettant d'accéder aux contrôleurs / assistants / etc .. 

class EventsController < ApplicationController
  def index
    debugger
  end
end

Et lorsque vous faites une demande et appuyez sur cette partie du code, la console du serveur renvoie une invite dans laquelle vous pouvez ensuite faire des demandes, afficher des objets, etc. à partir d'une invite de commande. Lorsque vous avez terminé, tapez simplement 'cont' pour continuer l'exécution. Il existe également des options pour le débogage étendu, mais cela devrait au moins vous aider à démarrer.

Si la méthode est POST , alors 

app.post 'controller/action?parameter1=value1&parameter2=value2'

[ici les paramètres seront selon votre applicabilité]

sinon s'il s'agit de la méthode GET puis 

app.get 'controller/action'

Voici comment faire une demande POST authentifiée, en utilisant l'exemple de la raffinerie: 

# Start Rails console
rails console
# Get the login form
app.get '/community_members/sign_in'
# View the session
app.session.to_hash
# Copy the CSRF token "_csrf_token" and place it in the login request.
# Log in from the console to create a session
app.post '/community_members/login', {"authenticity_token"=>"gT7G17RNFaWUDLC6PJGapwHk/OEyYfI1V8yrlg0lHpM=",  "refinery_user[login]"=>'chloe', 'refinery_user[password]'=>'test'}
# View the session to verify CSRF token is the same
app.session.to_hash
# Copy the CSRF token "_csrf_token" and place it in the request. It's best to edit this in Notepad++
app.post '/refinery/blog/posts', {"authenticity_token"=>"gT7G17RNFaWUDLC6PJGapwHk/OEyYfI1V8yrlg0lHpM=", "switch_locale"=>"en", "post"=>{"title"=>"Test", "homepage"=>"0", "featured"=>"0", "magazine"=>"0", "refinery_category_ids"=>["1282"], "body"=>"Tests do a body good.", "custom_teaser"=>"", "draft"=>"0", "tag_list"=>"", "published_at(1i)"=>"2014", "published_at(2i)"=>"5", "published_at(3i)"=>"27", "published_at(4i)"=>"21", "published_at(5i)"=>"20", "custom_url"=>"", "source_url_title"=>"", "source_url"=>"", "user_id"=>"56", "browser_title"=>"", "meta_description"=>""}, "continue_editing"=>"false", "locale"=>:en}

Vous pourriez également trouver ces informations utiles en cas d'erreur: 

app.cookies.to_hash
app.flash.to_hash
app.response # long, raw, HTML

Vous pouvez accéder à vos méthodes dans la console Rails comme suit 

controller.method_name
helper.method_name

Dans les rails 3, essayez ceci: 

session = ActionDispatch::Integration::Session.new(Rails.application)
session.get(url)
body = session.response.body

Body contiendra le code HTML de l'URL.

Comment router et rendre (dispatch) à partir d'un modèle dans Rails 3

Les réponses précédentes appellent les assistants, mais ce qui suit aidera à appeler les méthodes du contrôleur. Je l'ai utilisé sur les rails 2.3.2.

commencez par ajouter le code suivant à votre fichier .irbrc (qui peut se trouver dans votre répertoire personnel) 

class Object
   def request(options = {})
     url=app.url_for(options)
     app.get(url)
     puts app.html_document.root.to_s    
  end
end

puis dans la console des rails, vous pouvez taper quelque chose comme ... 

request(:controller => :show, :action => :show_frontpage)

... et le code HTML sera vidé sur la console.

À l'intérieur de toute action ou vue du contrôleur, vous pouvez appeler la console en appelant la méthode console .

Par exemple, dans un contrôleur: 

class PostsController < ApplicationController
  def new
    console
    @post = Post.new
  end
end

Ou dans une vue: 

<% console %>

<h2>New Post</h2>

Ceci rendra une console dans votre vue. Vous n'avez pas besoin de vous soucier de l'emplacement de l'appel de la console; il ne sera pas rendu sur le lieu de son invocation mais à côté de votre contenu HTML.

Voir: http://guides.rubyonrails.org/debugging_rails_applications.html

Une approche possible pour tester la méthode Helper dans la console de rails est

Struct.new (: t) .extend (YourHelper) .your_method (* arg)

et pour recharger et faire

recharger !; Struct.new (: t) .extend (YourHelper) .your_method (* arg)

Pour le contrôleur, vous pouvez instancier un objet contrôleur dans la console rails.

Par exemple, 

class CustomPagesController < ApplicationController

  def index
    @customs = CustomPage.all
  end

  def get_number
    puts "Got the Number"
  end

  protected

  def get_private_number
    puts 'Got private Number'
  end

end

custom = CustomPagesController.new
2.1.5 :011 > custom = CustomPagesController.new
 => #<CustomPagesController:0xb594f77c @_action_has_layout=true, @_routes=nil, @_headers={"Content-Type"=>"text/html"}, @_status=200, @_request=nil, @_response=nil> 
2.1.5 :014 > custom.get_number
Got the Number
 => nil

# For calling private or protected methods,
2.1.5 :048 > custom.send(:get_private_number)
Got private Number
 => nil

Si vous avez ajouté votre propre assistant et que vous souhaitez que ses méthodes soient disponibles dans la console, procédez comme suit:

  1. dans la console exécuter inclure YourHelperName
  2. vos méthodes d'assistance sont maintenant disponibles dans la console, utilisez-les en appelant nom_méthode (args) dans la console.

Exemple: disons que vous avez MyHelper (avec une méthode my_method ) dans 'app / helpers / my_helper.rb`, puis dans la console, faites:

  1. inclut MyHelper
  2. my_helper.my_method
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top