addicttux
addicttux
Reputation Top 1%
addicttux
16 Snippets  (46th place)
Published
2 Channels
Created
2 Channels
Following
Sep 16, 2015
Last Visit
Jul 30, 2015
Registered
486 points  (52nd place)
Reputation
Top 10% Publisher
Junior Code Generator
Serious Code Generator
Senior Code Generator
Junior Publisher
Serious Publisher
Senior Publisher
Junior Topic Creator
Junior Topic Hub
Junior Trend Maker
Serious Trend Maker
Junior Popular Coder
Serious Popular Coder
Junior Autobiographer
Serious Autobiographer
Serious Famous Coder
Serious Wise Coder

Recent Snippets See all snippets by addicttux

public by addicttux created Aug 12, 2015  10667  0  5  0

PDF Template

Template para la generación de reportes simples en PDF
# Genera el reporte en PDF
class NombreDeLaTablaEnSingularPdf < Prawn::Document

  include PdfHelper

  # Valores de inicialización del método.
  # @param nombre_de_la_tabla_en_singulars [Array] Contiene todos los registros a mostrar en el reporte
  # @param helpers [Obj] Utilizado para tener acceso a los helpers definidos en +app/helpers+
  # @note El encabezado y el título del reporte lo genera a través del código en +PdfHelper+ ubicado en +lib/pdf_helper.rb+
  def initialize( nombre_de_la_tabla_en_singulars, helpers )
    
    titulo =  'Listado de '
    encabezados    = %w( encabezado1 encabezado2 )
    ancho_columnas = [150,70]
    campos = Proc.new{|x| [x.campo_ordenado.titleize, x.campo_segundo.titleize] }

    super size: :letter,
          margin: 56,
          layout: :portrait

    pdf_encabezado_hoja_membretada

    pdf_titulo_del_reporte titulo

    #reporte
    elementos = [ encabezados ]
    elementos += nombre_de_la_tabla_en_singulars.map{|i| campos[i] }
    table elementos,
          column_widths: ancho_columnas,
          position: :center,
          cell_style: { size: 8 } do
      row(0).font_style = :bold
      row(0).align = :center
      row(0).size = 15
      self.row_colors = %w( EEEEEE FFE3BF )
      self.header = true
    end

  end

end                                                                        
;

public by addicttux created Aug 12, 2015  10630  2  6  0

TEST: xxx_test.rb

Unit Testing
require 'test_helper'

class NombreDeTablaEnSingularTest < ActiveSupport::TestCase

  setup do
    @root = users :admin
    @usr  = users :user
    @caracteres_minimo = 
    @caracteres_maximo = 
    @palabra = ''
    @datos_1char          = { forma_de_pago: 'a',                      solo_root_ns: false, usuario_actual: @usr }
    @datos_blanco         = { forma_de_pago: '',                       solo_root_ns: false, usuario_actual: @usr }
    @datos_blanco_ambos   = { forma_de_pago: " #{@palabra} ",          solo_root_ns: false, usuario_actual: @usr }
    @datos_blanco_final   = { forma_de_pago: "#{@palabra} ",           solo_root_ns: false, usuario_actual: @usr }
    @datos_blanco_inicial = { forma_de_pago: " #{@palabra}",           solo_root_ns: false, usuario_actual: @usr }
    @datos_excedido       = { forma_de_pago: 'a'*@caracteres_maximo*2, solo_root_ns: false, usuario_actual: @usr }
    @datos_maximo         = { forma_de_pago: 'a'*@caracteres_maximo,   solo_root_ns: false, usuario_actual: @usr }
    @datos_minimo         = { forma_de_pago: 'a'*@caracteres_minimo,   solo_root_ns: false, usuario_actual: @usr }
    @datos_minusculas     = { forma_de_pago: @palabra.upcase,          solo_root_ns: false, usuario_actual: @usr }
    @datos_nulo           = { forma_de_pago: nil,                      solo_root_ns: false, usuario_actual: @usr }
    @datos_root           = { forma_de_pago: 'segundo',                solo_root_ns: true,  usuario_actual: @root }
    @datos_user           = { forma_de_pago: 'valor',                  solo_root_ns: false }
    @duplicado            = { forma_de_pago: '',                       solo_root_ns: false, usuario_actual: @usr }
  end

  # +-------------------------+
  # | Pruebas para New/Create |
  # +-------------------------+

  test 'Prueba #XXX-U-001: Probando la creación de ______ [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_user
    assert tut.valid?, tut.errors.messages.to_yaml
  end

  test 'Prueba #XXX-U-002: Probando que no guarde ______ en blanco [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_blanco
    refute tut.valid?, 'Se guardó en blanco'
  end

  test 'Prueba #XXX-U-003: Probando que no guarde ______ nil [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_nulo
    refute tut.valid?, 'Se guardó siendo nil'
  end

  test 'Prueba #XXX-U-004: Probando que no guarde ______ menores al mínimo de caracteres [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_1char
    refute tut.valid?, 'Se guardó siendo menor al mínimo de caracteres'
  end

  test 'Prueba #XXX-U-005: Probando que guarde ______ igual al mínimo de caracteres [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_minimo
    assert tut.valid?, 'No se guardo palabra igual al mínimo de caracteres'
  end

  test 'Prueba #XXX-U-006: Probando que guarde ______ igual al máximo de caracteres [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_maximo
    assert tut.valid?, 'No se guardo palabra igual al maximo de caracteres'
  end

  test 'Prueba #XXX-U-007: Prueba que no se guarde ______ mayor del máximo de caracteres permitidos [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_excedido
    refute tut.valid?, 'Se guardo palabra de mas caracteres que los permitidos'
  end

  test 'Prueba #XXX-U-008: Prueba que elimine el espacio inicial [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_blanco_inicial
    assert_equal tut.forma_de_pago, @palabra, 'No eliminó el espacio inicial'
  end

  test 'Prueba #XXX-U-009: Prueba que elimine espacios finales [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_blanco_final
    assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios finales'
  end

  test 'Prueba #XXX-U-010: Prueba que elimine espacios iniciales y finales [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_blanco_ambos
    assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios alrededor del texto'
  end

  test 'Prueba #XXX-U-011: Prueba que se guarde en minúsculas [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_minusculas
    assert_equal tut.forma_de_pago, @palabra, 'No guardó el texto en minúsculas'
  end

  test 'Prueba #XXX-U-012: Prueba que detecte contenido duplicado [hmjr]' do
    original = NombreDeTablaEnSingular.first.forma_de_pago
    @duplicado[:forma_de_pago] = original
    tut = NombreDeTablaEnSingular.create @duplicado
    refute tut.valid?, 'No detectó duplicidad'
  end


  # +----------------------+
  # | Pruebas para Destroy |
  # +----------------------+

  test 'Prueba #XXX-U-013: No debe de poder eliminar sin ser usuario registrado [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_user
    antes = NombreDeTablaEnSingular.count
    tut.destroy
    assert_equal antes, NombreDeTablaEnSingular.count, 'Borró pese a no estar registrado'
  end

  test 'Prueba #XXX-U-014: Elimina ______, el usuario no es root, solo_root_ns = false, no tiene dependientes [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_user
    tut.usuario_actual = @usr
    antes = NombreDeTablaEnSingular.count
    tut.destroy
    refute_equal antes, NombreDeTablaEnSingular.count, 'No se borró y no tiene teléfonos dependientes'
  end

  test 'Prueba #XXX-U-015: Elimina ______, el usuario no es root, solo_root_ns = false, TIENE dependientes [hmjr]' do
#    tid = NombreDeTablaEnSingular.first
#    dir = Directorio.create razon_fiscal: 'borrame s.a. de c.v.', razon_comercial: 'borrame', sobrenombre: 'borrame'
#    TablaRelacionada.create tipo_forma_pago: tid, directorio: dir, solo_root_ns: false
#    antes = NombreDeTablaEnSingular.count
#    tid.usuario_actual = @usr
#    tid.destroy
#    assert_equal antes, NombreDeTablaEnSingular.count, 'Se eliminó pese a que tiene dependientes'
  end


  test 'Prueba #XXX-U-016: Elimina ______, el usuario no es root, solo_root_ns = true [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_root
    tut.usuario_actual = @usr
    antes = NombreDeTablaEnSingular.count
    tut.destroy
    assert_equal antes, NombreDeTablaEnSingular.count, 'Pudo borrar registro cuando solo root debería'
  end

  test 'Prueba #XXX-U-017: Elimina ______, el usuario es ROOT, solo_root_ns = false [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_user
    tut.usuario_actual = @root
    antes = NombreDeTablaEnSingular.count
    tut.destroy
    refute_equal antes, NombreDeTablaEnSingular.count, 'Root no pudo borrar un registro no exclusivo'
  end

  test 'Prueba #XXX-U-018: Elimina ______, el usuario es ROOT, solo_root_ns = true [hmjr]' do
    tut = NombreDeTablaEnSingular.create @datos_root
    antes = NombreDeTablaEnSingular.count
    tut.destroy
    refute_equal antes, NombreDeTablaEnSingular.count, 'Root no pudo borrar un registro exclusivo'
  end

  # +---------------------------------------+
  # | Pruebas para Edit para usuario normal |
  # +---------------------------------------+

  test 'Prueba #XXX-U-019: Probando la edición de ______ con usuario no logeado [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_user
    refute tut.save, tut.errors.messages.to_yaml
  end

  test 'Prueba #XXX-U-020: Probando la edición de ______ con usuario logeado [hmjr]' do
    @datos_user[:usuario_actual] = @usr
    tut = NombreDeTablaEnSingular.first
    tut.update @datos_user
    assert tut.save, tut.errors.messages.to_yaml
  end

  test 'Prueba #XXX-U-021: Probando que no edite ______ en blanco [hmjr]' do
    tut = NombreDeTablaEnSingular.first
    tut.update @datos_blanco
    refute tut.valid?, 'Se guardó en blanco'
  end

  test 'Prueba #XXX-U-022: Probando que no edite ______ nil [hmjr]' do
    tut = NombreDeTablaEnSingular.first
    tut.update @datos_nulo
    refute tut.valid?, 'Se guardó siendo nil'
  end

  test 'Prueba #XXX-U-023: Probando que no edite ______ menores al mínimo de caracteres [hmjr]' do
    tut = NombreDeTablaEnSingular.first
    tut.update @datos_1char
    refute tut.valid?, 'Se guardó siendo menor al mínimo de caracteres'
  end

  test 'Prueba #XXX-U-024: Probando que guarde ______ siendo igual al mínimo de caracteres [hmjr]' do
    tut = NombreDeTablaEnSingular.first
    tut.update @datos_minimo
    assert tut.valid?, 'No se guardo palabra igual al mínimo de caracteres'
  end

  test 'Prueba #XXX-U-025: Probando que guarde ______ igual al máximo de caracteres [hmjr]' do
    tut = NombreDeTablaEnSingular.first
    tut.update @datos_maximo
    assert tut.valid?, 'No se guardo palabra igual al máximo de caracteres'
  end

  test 'Prueba #XXX-U-026: Prueba que no se guarde ______ mayor al máximo de caracteres [hmjr]' do
    tut = NombreDeTablaEnSingular.first
    tut.update @datos_excedido
    refute tut.valid?, 'Se guardo palabra mayor al máximo de caracteres'
  end

  test 'Prueba #XXX-U-027: Prueba que elimine el espacio inicial [hmjr]' do
    tut = NombreDeTablaEnSingular.first
    tut.update @datos_blanco_inicial
    assert_equal tut.forma_de_pago, @palabra, 'No eliminó el espacio inicial'
  end

  test 'Prueba #XXX-U-028: Prueba que elimine espacios finales [hmjr]' do
    tut = NombreDeTablaEnSingular.first
    tut.update @datos_blanco_final
    assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios finales'
  end

  test 'Prueba #XXX-U-029: Prueba que elimine espacios iniciales y finales [hmjr]' do
    tut = NombreDeTablaEnSingular.first
    tut.update @datos_blanco_ambos
    assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios alrededor del texto'
  end

  test 'Prueba #XXX-U-030: Prueba que se guarde en minúsculas [hmjr]' do
    tut = NombreDeTablaEnSingular.first
    tut.update @datos_minusculas
    assert_equal tut.forma_de_pago, @palabra, 'No guardó el texto en minúsculas'
  end

  test 'Prueba #XXX-U-031: Prueba que detecte contenido duplicado [hmjr]' do
    tut = NombreDeTablaEnSingular.first
    tut.update forma_de_pago: NombreDeTablaEnSingular.last.forma_de_pago, usuario_actual: @usr
    refute tut.valid?, 'No detectó duplicidad'
  end

  test 'Prueba #XXX-U-032: Prueba que NO pueda editar si solo_root_ns es true [hmjr]' do
    tut = NombreDeTablaEnSingular.create forma_de_pago: @palabra, solo_root_ns: true, usuario_actual: @usr
    cam = NombreDeTablaEnSingular.find tut.id
    cam.forma_de_pago = 'cambiado'
    cam.usuario_actual = @usr
    refute cam.save, 'No detectó que solo root lo puede modificar'
  end

  # +-------------------------------------+
  # | Pruebas para Edit para usuario root |
  # +-------------------------------------+

  test 'Prueba #XXX-U-033: Probando la edición de ______ con usuario logeado [hmjr]' do
    @usr = @root
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_root
    assert tut.save, tut.errors.messages.to_yaml
  end

  test 'Prueba #XXX-U-034: Probando que no edite ______ en blanco [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_blanco
    refute tut.valid?, 'Se guardó en blanco'
  end

  test 'Prueba #XXX-U-035: Probando que no edite ______ nil [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_nulo
    refute tut.valid?, 'Se guardó siendo nil'
  end

  test 'Prueba #XXX-U-036: Probando que no edite ______ menores al mínimo de caracteres [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_1char
    refute tut.valid?, 'Se guardó siendo menor al mínimo de caracteres'
  end

  test 'Prueba #XXX-U-037: Probando que guarde ______ igual al mínimo de caracteres [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_minimo
    assert tut.valid?, 'No se guardo palabra igual al mínimo de caracteres'
  end

  test 'Prueba #XXX-U-038: Probando que guarde ______ igual al máximo de caracteres [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_maximo
    assert tut.valid?, 'No se guardo palabra igual al máximo de caracteres'
  end

  test 'Prueba #XXX-U-039: Prueba que no se guarde ______ mayor al máximo de caracteres [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_excedido
    refute tut.valid?, 'Se guardo palabra mayor al máximo de caracteres'
  end

  test 'Prueba #XXX-U-040: Prueba que elimine el espacio inicial [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_blanco_inicial
    assert_equal tut.forma_de_pago, @palabra, 'No eliminó el espacio inicial'
  end

  test 'Prueba #XXX-U-041: Prueba que elimine espacios finales [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_blanco_final
    assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios finales'
  end

  test 'Prueba #XXX-U-042: Prueba que elimine espacios iniciales y finales [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_blanco_ambos
    assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios alrededor del texto'
  end

  test 'Prueba #XXX-U-043: Prueba que se guarde en minúsculas [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update @datos_minusculas
    assert_equal tut.forma_de_pago, @palabra, 'No guardó el texto en minúsculas'
  end

  test 'Prueba #XXX-U-044: Prueba que detecte contenido duplicado [hmjr]' do
    tut = NombreDeTablaEnSingular.last
    tut.update forma_de_pago: NombreDeTablaEnSingular.first.forma_de_pago, usuario_actual: @root
    refute tut.valid?, 'No detectó duplicidad'
  end

  test 'Prueba #XXX-U-045: Prueba que pueda editar si solo_root_ns es true [hmjr]' do
    tut = NombreDeTablaEnSingular.create forma_de_pago: @palabra, solo_root_ns: true, usuario_actual: @root
    cam = NombreDeTablaEnSingular.find tut.id
    cam.forma_de_pago = 'cambiado'
    cam.usuario_actual = @root
    assert cam.save, 'No detectó que solo root lo puede modificar'
  end

end

#------------------------------------------------------------------------------
# NombreDeTablaEnSingular
#
# Name          SQL Type             Null    Default Primary
# ------------- -------------------- ------- ------- -------
# id            int(11)              false           true
# forma_de_pago varchar(10)          false           false
# solo_root_ns  tinyint(1)           false   0       false
# lock_version  int(11)              false   0       false
# created_at    datetime             false           false
# updated_at    datetime             false           false
#
#------------------------------------------------------------------------------
;

public by addicttux created Aug 13, 2015  9845  1  5  0

TEST: xxxs_test.rb

integration testing
require 'test_helper'

class NombreTablaEnSingularsTest < ActionDispatch::IntegrationTest

  setup do
    @root = users :admin
    @user = users :user
    @txt = 'nombre_tabla_en_singular'
    @palabra = 'valor'
    @cambiar = 'modificado'
    @duplicado = NombreTablaEnSingular.find(3).campo_ordenado
    @datos_user = { campo_ordenado: 'texto', solo_root_ns: false, usuario_actual: @user }
    @datos_root = { campo_ordenado: 'texto', solo_root_ns: false, usuario_actual: @root }
    @datos_user_root = { campo_ordenado: 'texto', solo_root_ns: true, usuario_actual: @user }
  end

  test 'Prueba #XXX-I-001: usuario se logea, y luego' do
    # nos logeamos como usuario
    post_via_redirect '/users/login', 'user[username]' => 'user', 'user[password]' => 'password'

    # vamos a la pagina principal
    get '/'
    assert_response :success, 'no se logeo'

    ### index
    # vamos al index de nombre_tabla_en_singular
    get nombre_tabla_en_singulars_path
    assert_response :success

    ### print
    # generamos el listado de nombre_tabla_en_singulars
    get nombre_tabla_en_singulars_listado_path
    assert_response :not_acceptable

    ### new
    # creamos un nuevo nombre_tabla_en_singular
    xhr :get, "/#{@txt}s/new"
    assert_response :success
    # capturamos los nuevos datos
    xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => @palabra, "#{@txt}[solo_root_ns]" => false }
    assert_response :success
    tut = NombreTablaEnSingular.last
    assert_equal tut.campo_ordenado, @palabra
    assert_select 'form', 0
    assert_equal css_select( '.ui.pointing.below.label.red' ).size, 0
    # capturamos los mismos datos con la finalidad de evalur que aparezca el mensaje de error por duplicidad
    xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => @duplicado, "#{@txt}[solo_root_ns]" => false }
    assert_select 'form', 1
    assert_response :success
    # capturamos con datos en blanco
    xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => '', "#{@txt}[solo_root_ns]" => false }
    assert_select 'form', 1
    assert_response :success
    # capturamos datos de 1 caracteres
    xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => 'a', "#{@txt}[solo_root_ns]" => false }
    assert_select 'form', 1
    assert_response :success

    ### edit
    # obtenemos el registro en pantalla de captura
    tut = NombreTablaEnSingular.first
    xhr :get, "/#{@txt}s/#{tut.id}/edit"
    assert_response :success
    # editamos sin cambiar valores
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => tut.campo_ordenado, "#{@txt}[solo_root_ns]" => false }
    assert_response :success
    assert_select 'form', 0
    # editamos cambiando valores
    antes = tut.campo_ordenado
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => @cambiar, "#{@txt}[solo_root_ns]" => false }
    assert_response :success
    assert_select 'form', 0
    tut = NombreTablaEnSingular.find tut.id
    assert_not_equal antes, tut.campo_ordenado
    # editamos duplicando valores
    NombreTablaEnSingular.create @datos_user
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => @duplicado }
    assert_response :success
    assert_select 'form', 1
    tut = NombreTablaEnSingular.find tut.id
    assert_not_equal @duplicado, tut.campo_ordenado
    # editamos dejando en blanco los valres
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => '' }
    assert_response :success
    assert_select 'form', 1
    # editamos con valores de 1 caracteres
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => 'u' }
    assert_response :success
    assert_select 'form', 1
    # no puede editar si solo_root_ns = true
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => 'no debe', "#{@txt}[solo_root_ns]" => true }
    assert_response :success
    assert_not_equal 'no debe', NombreTablaEnSingular.find( tut.id ).campo_ordenado

    ### delete
    # verificamos que aparezca el diálogo de confirmar para borrar
    tut = NombreTablaEnSingular.last
    xhr :get, "/#{@txt}s/#{tut.id}/confirmar_borrar"
    assert_response :success
    # eliminamos con solo_root_ns=false
    assert_difference 'NombreTablaEnSingular.count', -1 do
      xhr :delete, "/#{@txt}s/#{tut.id}"
    end
    # no debe eliminar con solo_root_ns=true
    tut = NombreTablaEnSingular.create @datos_user_root
    assert_no_difference 'NombreTablaEnSingular.count', -1 do
      xhr :delete, "/#{@txt}s/#{tut.id}"
    end
  end

  test 'Prueba #XXX-I-002: root se logea, y luego' do
    # nos logeamos como usuario
    post_via_redirect '/users/login', 'user[username]' => 'root', 'user[password]' => '5170yPOR0771c3Ya'

    # vamos a la pagina principal
    get '/'
    assert_response :success

    ### index
    # vamos al index de nombre_tabla_en_singular
    get nombre_tabla_en_singulars_path
    assert_response :success

    ### print
    # generamos el listado de nombre_tabla_en_singulars
    get nombre_tabla_en_singulars_listado_path
    assert_response :not_acceptable

    ### new
    # creamos un nuevo nombre_tabla_en_singular
    xhr :get, "/#{@txt}s/new"
    assert_response :success
    # capturamos los nuevos datos
    xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => @palabra, "#{@txt}[solo_root_ns]" => false }
    assert_response :success
    tut = NombreTablaEnSingular.last
    assert_equal tut.campo_ordenado, @palabra
    assert_select 'form', 0
    assert_equal css_select( '.ui.pointing.below.label.red' ).size, 0
    # capturamos los mismos datos con la finalidad de evalur que aparezca el mensaje de error por duplicidad
    xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => @duplicado, "#{@txt}[solo_root_ns]" => true }
    assert_select 'form', 1
    assert_response :success
    # capturamos con datos en blanco
    xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => '', "#{@txt}[solo_root_ns]" => true }
    assert_select 'form', 1
    assert_response :success
    # capturamos datos de 1 caracteres
    xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => 'a', "#{@txt}[solo_root_ns]" => true }
    assert_select 'form', 1
    assert_response :success

    ### edit
    # obtenemos el registro en pantalla de captura
    tut = NombreTablaEnSingular.first
    xhr :get, "/#{@txt}s/#{tut.id}/edit"
    assert_response :success
    # editamos sin cambiar valores
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => tut.campo_ordenado, "#{@txt}[solo_root_ns]" => tut.solo_root_ns }
    assert_response :success
    assert_select 'form', 0
    # editamos cambiando valores
    antes = tut.campo_ordenado
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => @cambiar, "#{@txt}[solo_root_ns]" => tut.solo_root_ns }
    assert_response :success
    assert_select 'form', 0
    tut = NombreTablaEnSingular.find tut.id
    assert_not_equal antes, tut.campo_ordenado
    # editamos duplicando valores
    NombreTablaEnSingular.create @datos_root
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => @duplicado }
    assert_response :success
    assert_select 'form', 1
    tut = NombreTablaEnSingular.find tut.id
    assert_not_equal @duplicado, tut.campo_ordenado
    # editamos dejando en blanco los valres
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => '' }
    assert_response :success
    assert_select 'form', 1
    # editamos con valores de 2 caracteres
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => 'u' }
    assert_response :success
    assert_select 'form', 1
    # no puede editar si solo_root_ns = true
    xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => @cambiar, "#{@txt}[solo_root_ns]" => true }
    assert_response :success
    assert_equal @cambiar, NombreTablaEnSingular.find( tut.id ).campo_ordenado

    ### delete
    # verificamos que aparezca el diálogo de confirmar para borrar
    tut = NombreTablaEnSingular.last
    xhr :get, "/#{@txt}s/#{tut.id}/confirmar_borrar"
    assert_response :success
    # eliminamos con solo_root_ns=false
    assert_difference 'NombreTablaEnSingular.count', -1 do
      xhr :delete, "/#{@txt}s/#{tut.id}"
    end
    # no debe eliminar con solo_root_ns=true
    tut = NombreTablaEnSingular.create @datos_root
    assert_difference 'NombreTablaEnSingular.count', -1 do
      xhr :delete, "/#{@txt}s/#{tut.id}"
    end
  end

end
            
;

public by addicttux created Aug 12, 2015  9962  1  5  0

TEST: xxx_controller_test.rb

functional testing
require 'test_helper'

class NombreDeLaTablaEnSingularsControllerTest < ActionController::TestCase

  setup do
    @nombre_de_la_tabla_en_singular = nombre_de_la_tabla_en_singulars :valor_tomadp_de_fixtures
    @root = users :admin
    @user = users :user
    @datos_user = {
      solo_root_ns: false,
      campo_ordenado: 'tdc' }
    @datos_root = {
      campo_ordenado: 'tdd',
      solo_root_ns: true  }
  end

  test 'Prueba #XXX-F-001: No debe de obtener index si no está logeado [hmjr]' do
    get :index
    assert_response :redirect, 'Es redirigido a la pantalla de login'
    assert_redirected_to 'http://test.host/users/login'
    assert_response :redirect
  end

  test 'Prueba #XXX-F-002: una vez logeado como user va al index [hmjr]' do
    sign_in @user
    get :index
    assert_response :success, 'El usuario no llegó a index'
    assert_not_nil assigns( :nombre_de_la_tabla_en_singulars ), 'El usuario no obtuvo el listado de NombreDeLaTablaEnSingulars'
  end

  test 'Prueba #XXX-F-003: una vez logeado como root va al index [hmjr]' do
    sign_in @root
    get :index
    assert_response :success, 'Root no llegó a index'
    assert_not_nil assigns( :nombre_de_la_tabla_en_singulars ), 'Root no obtuvo el listado de NombreDeLaTablaEnSingulars'
  end

  test 'Prueba #XXX-F-004: No debe de existir la pantalla de new para usuario [hmjr]' do
    sign_in @user
    get :new
    assert_response 303 do
      assert false, 'Existe pantalla de new para el usuario, cuando debe ser por ajax'
    end
  end

  test 'Prueba #XXX-F-005: No debe de existir la pantalla de new para root [hmjr]' do
    sign_in @root
    get :new
    assert_response 303 do
      assert false, 'Existe pantalla de new para root, cuando debe ser por ajax'
    end
  end

  test 'Prueba #XXX-F-006: Usuario no logeado no puede crear un nuevo NombreDeLaTablaEnSingular [hmjr]' do
    assert_no_difference 'NombreDeLaTablaEnSingular.count' do
      post :create, nombre_de_la_tabla_en_singular: @datos_user, format: :js
    end
  end

  test 'Prueba #XXX-F-007: Usuario logeado puede crear un nuevo NombreDeLaTablaEnSingular [hmjr]' do
    sign_in @user
    assert_difference 'NombreDeLaTablaEnSingular.count' do
      post :create, nombre_de_la_tabla_en_singular: @datos_user, format: :js
    end
    css_select '#reemplazame ui basic modal'
  end

  test 'Prueba #XXX-F-008: root puede crear un nuevo NombreDeLaTablaEnSingular [hmjr]' do
    sign_in @root
    assert_difference 'NombreDeLaTablaEnSingular.count' do
      post :create, nombre_de_la_tabla_en_singular: @datos_user, format: :js
    end
    css_select '#reemplazame ui basic modal'
  end

  test 'Prueba #XXX-F-009: Usuario no logeado no puede existir pantalla HTML de edición [hmjr]' do
    get :edit, id: @nombre_de_la_tabla_en_singular
    assert_response :redirect, 'Es redirigido a la pantalla de login'
    assert_redirected_to 'http://test.host/users/login'
    assert_response :redirect
  end

  test 'Prueba #XXX-F-010: Usuario logeado no puede existir pantalla HTML de edición [hmjr]' do
    sign_in @user
    get :edit, id: @nombre_de_la_tabla_en_singular
    assert_response :redirect, 'Es redirigido a la pantalla de index'
    assert_redirected_to 'http://test.host/en/nombre_de_la_tabla_en_singulars'
  end

  test 'Prueba #XXX-F-011: root logeado no puede existir pantalla HTML de edición [hmjr]' do
    sign_in @root
    get :edit, id: @nombre_de_la_tabla_en_singular
    assert_response :redirect, 'Es redirigido a la pantalla de index'
    assert_redirected_to 'http://test.host/en/nombre_de_la_tabla_en_singulars'
  end

  test 'Prueba #XXX-F-012: Usuario no logeado no puede update un registro existente [hmjr]' do
    tut = NombreDeLaTablaEnSingular.first
    tut.campo_ordenado = 'inválido'
    patch :update, id: tut.id, nombre_de_la_tabla_en_singular: tut, format: :js
    assert_response :unauthorized
  end

  test 'Prueba #XXX-F-013: Usuario logeado puede update un registro existente con solo_root_ns=false [hmjr]' do
    sign_in @user
    tut = NombreDeLaTablaEnSingular.create @datos_user
    tut.campo_ordenado = 'inválido'
    patch :update, id: tut.id, nombre_de_la_tabla_en_singular: tut, format: :js
    refute_equal @datos_user[:campo_ordenado], NombreDeLaTablaEnSingular.find( tut.id ).campo_ordenado
  end

  test 'Prueba #XXX-F-014: Usuario logeado no puede update un registro existente con solo_root_ns=true [hmjr]' do
    sign_in @user
    tut =NombreDeLaTablaEnSingular.create @datos_root
    tut.campo_ordenado = 'inválido'
    patch :update, id: tut.id, nombre_de_la_tabla_en_singular: tut, format: :js
    assert_equal @datos_root[:campo_ordenado], NombreDeLaTablaEnSingular.find( tut.id ).campo_ordenado
  end

  test 'Prueba #XXX-F-015: root logeado puede update un registro existente con solo_root_ns=false [hmjr]' do
    sign_in @root
    tut =NombreDeLaTablaEnSingular.create @datos_user
    tut.campo_ordenado = 'inválido'
    patch :update, id: tut.id, nombre_de_la_tabla_en_singular: tut, format: :js
    refute_equal @datos_user[:campo_ordenado], NombreDeLaTablaEnSingular.find( tut.id ).campo_ordenado
  end

  test 'Prueba #XXX-F-016: root logeado puede update un registro existente con solo_root_ns=true [hmjr]' do
    sign_in @root
    tut =NombreDeLaTablaEnSingular.create @datos_root
    tut.campo_ordenado = 'inválido'
    patch :update, id: tut.id, nombre_de_la_tabla_en_singular: tut, format: :js
    refute_equal @datos_root[:campo_ordenado], NombreDeLaTablaEnSingular.find( tut.id ).campo_ordenado
  end

  test 'Prueba #XXX-F-017: Usuario no logeado no puede borrar un registro [hmjr]' do
    tut =NombreDeLaTablaEnSingular.first
    assert_no_difference 'NombreDeLaTablaEnSingular.count' do
      delete :destroy, id: tut.id, format: :js
    end
  end

  test 'Prueba #XXX-F-018: Usuario logeado puede borrar un registro cuando solo_root_ns=false [hmjr]' do
    sign_in @user
    tut =NombreDeLaTablaEnSingular.create @datos_user
    assert_difference 'NombreDeLaTablaEnSingular.count', -1 do
      delete :destroy, id: tut.id, format: :js
    end
  end

  test 'Prueba #XXX-F-019: Usuario logeado no puede borrar un registro cuando solo_root_ns=true [hmjr]' do
    sign_in @user
    tut =NombreDeLaTablaEnSingular.create @datos_root
    assert_no_difference 'NombreDeLaTablaEnSingular.count', -1 do
      delete :destroy, id: tut.id, format: :js
    end
  end

  test 'Prueba #XXX-F-020: root logeado puede borrar un registro cuando solo_root_ns=false [hmjr]' do
    sign_in @root
    tut =NombreDeLaTablaEnSingular.create @datos_user
    assert_difference 'NombreDeLaTablaEnSingular.count', -1 do
      delete :destroy, id: tut.id, format: :js
    end
  end

  test 'Prueba #XXX-F-021: root logeado puede borrar un registro cuando solo_root_ns=true [hmjr]' do
    sign_in @root
    tut =NombreDeLaTablaEnSingular.create @datos_root
    assert_difference 'NombreDeLaTablaEnSingular.count', -1 do
      delete :destroy, id: tut.id, format: :js
    end
  end

end
;

public by addicttux created Aug 12, 2015  10978  1  5  0

Controller Template

Template para el controller con CRUD
# Controla el CRUD
#
# Por convencionalismo se omiten los métodos +index+, +new+, +update+. Ver nota sobre convencionalismos en +application_controller.rb+
#
# El método +update+ es un alias de +create+ debido a *DRYtizar* el código
#
# Se aplican 7 métodos +before_action+ como consecuencia de *DRYtizar* el código, los cuales son *privados*
class NombreDeLaTablaEnSingularsController < ApplicationController

  before_action :authenticate_user!
  before_action :set_nombre_de_la_tabla_en_singular, only: [:edit, :update, :destroy, :confirmar_borrar]
  before_action :new_nombre_de_la_tabla_en_singular, only: [:new, :create]
  before_action :crear_breadcrum, only: [:index,:new,:edit]
  before_action :asginar_captura, only: [:create,:update]
  before_action :asgina_current_user, only: [ :update, :destroy ]
  before_action :genera_listado, only: :index

  # Evitamos que en producción se vea un 404, redirigiendo culaquier petición a una página inexistente al index
  unless Rails.env.development?
    rescue_from ActionView::MissingTemplate do
      redirect_to nombre_de_la_tabla_en_singulars_path, status: 303
    end
  end

  # Lo guarda en la base de datos.
  #
  # @note Hacemos uso del método del mismo nombre definido en <tt>application_controller.rb</tt>
  def create
    super  @nombre_de_la_tabla_en_singular
  end

  alias_method :update, :create

  # Lo elimina de la base de datos
  #
  # @note Hacemos uso del método del mismo nombre definido en <tt>application_controller.rb</tt>
  def destroy
    super @nombre_de_la_tabla_en_singular
  end

  # Genera el reporte en PDF
  #
  # @note Hacemos uso del método del mismo nombre definido en <tt>application_controller.rb</tt>
  def listado_pdf
    super NombreDeLaTablaEnSingularPdf.new( NombreDeLaTablaEnSingular.all.order(:campo_ordenado), view_context )
  end

  private

  # Este método se utiliza para asignar cada valor capturado a su contraparte en la instancia de la base de datos.
  # <b>Hacemos esto para evitar un ataque de inyección de SQL</b>
  def asginar_captura
    @nombre_de_la_tabla_en_singular.campo_ordenado = params[:nombre_de_la_tabla_en_singular][:campo_ordenado]
    @nombre_de_la_tabla_en_singular.campo_segundo  = params[:nombre_de_la_tabla_en_singular][:campo_segundo]
    @nombre_de_la_tabla_en_singular.solo_root_ns   = params[:nombre_de_la_tabla_en_singular][:solo_root_ns]
  end

  # Genera el breadcrum, pasamos la ruta a +index+
  #
  # @note Hacemos uso del método del mismo nombre definido en <tt>application_controller.rb</tt>
  def crear_breadcrum
    super nombre_de_la_tabla_en_singulars_path
  end

  # Crea una nueva instancia del objeto
  def new_nombre_de_la_tabla_en_singular
    @nombre_de_la_tabla_en_singular = NombreDeLaTablaEnSingular.new
  end

  # Obtiene los datos desde la base de datos
  def set_nombre_de_la_tabla_en_singular
    @nombre_de_la_tabla_en_singular = NombreDeLaTablaEnSingular.find(params[:id])
  end

  # Genera el listado. Este método es llamado tanto de forma directa como en el filtro +before_action+
  def genera_listado
    @nombre_de_la_tabla_en_singulars = initialize_grid NombreDeLaTablaEnSingular,
                                          order: 'nombre_de_la_tabla_en_singulars.campo_ordenado',
                                          order_direction: 'desc',
                                          per_page: 10
  end

  # Asigna el usuario actual a una variable de instancia a fin de pasen los tests
  def asgina_current_user
    @nombre_de_la_tabla_en_singular.usuario_actual = current_user
  end

end            
;