working on it ...

Filters

Explore Public Snippets

Sort by

Found 16 snippets

    public by addicttux modified Aug 27, 2015  11959  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 modified Aug 27, 2015  12005  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 modified Aug 27, 2015  10090  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 modified Aug 15, 2015  10292  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 modified Aug 13, 2015  11301  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            

    public by addicttux modified Aug 12, 2015  2335  1  3  0

    VIEWS: _form.html.haml

    = form_for(@nombre_de_la_tabla_en_singular, remote: true) do |f|
    
      .ui.two.column.centered.grid
        .ui.row
          .column
            #errores_de_captura
    
            .cuadro_cu
              .ui.form
                .ui.corner.labeled.input
                  .ui.label
                    = f.label :campo_ordenado,
                      (t('nombre_de_la_tabla_en_singulars.campo_ordenado')+'<span class="maxchars"></span>').html_safe
                  = f.text_field :campo_ordenado,
                    placeholder: t('nombre_de_la_tabla_en_singulars.campo_ordenado'),
                    autofocus: true,
                    maxlength: ,
                    size: 
                  .ui.corner.label
                    %i.asterisk.icon
                .ui.row
                  .column
                    .ui.toggle.checkbox
                      = f.check_box :booleano
                      = f.label :booleano,
                        t('nombre_de_la_tabla_en_singulars.booleano')
                .ui.row
                  .column
                    .ui.toggle.checkbox
                      = f.check_box :solo_root_ns
                      = f.label :solo_root_ns,
                        t('nombre_de_la_tabla_en_singulars.solo_root_ns')
    
              = render partial: 'shared/botones_cancelar_guardar'
    
    :coffee
      efectos_de_input()
      $('#boton_cancelar').click ->
        oculta_captura_muestra_browse()

    public by addicttux modified Aug 12, 2015  6517  0  3  0

    VIEWS: _confirmar_borrar.js.coffee

    dialogo = "<%= j( render partial: 'shared/dialogo_borrar', locals: { texto_pregunta: 'nombre_de_la_tabla_en_singulars.pregunta_borrar_html', que_se_borra: { campo_ordenado: @nombre_de_la_tabla_en_singular.campo_ordenado.titleize } } ) %>"
    mostrar_dialogo_confirmar_borrar dialogo, 'nombre_de_la_tabla_en_singulars/'+"<%= @nombre_de_la_tabla_en_singular.id %>"

    public by addicttux modified Aug 12, 2015  1921  0  3  0

    VIEWS: _genera_listado.html.haml

    = grid @nombre_de_tabla_en_singulars do |g|
    
      - g.column name: t('nombre_de_tabla_en_singulars.campo_ordenado'),
        auto_reload: true,
        attribute: 'campo_ordenado'  do |tt|
    
        - tt.campo_ordenado.titleize
      
      - g.column name: t('nombre_de_tabla_en_singulars.campo_segundo'),
        auto_reload: true,
        attribute: 'campo_segundo'  do |tt|
        
        - tt.campo_segundo.titleize
    
      - columna_de_acciones g

    public by addicttux modified Aug 12, 2015  2288  0  3  0

    VIEWS: _recargar_browse.js.coffee

    listado = "<%= j( render partial: 'genera_listado' ) %>"
    mensaje = "<div class='ui basic modal'><div class='header'><%= texto.html_safe %></div></div>"
    recargar_listado listado, mensaje

    public by addicttux modified Aug 12, 2015  191661  0  3  0

    VIEWS: create.js.coffee

    Template create.js.coffee
    mostrar_formulario_new_edit "<%= j( render( partial: 'form' ) ) %>"
    mostrar_errores_de_captura "<%= render partial: 'shared/mensaje_error_new_edit', locals: { datos: @nombre_de_la_tabla_en_singular } %>"
    • Public Snippets
    • Channels Snippets