working on it ...

Filters

Explore Public Snippets

Sort by

Found 7,474 snippets matching: testing

    public by sukhjinderkahlon  326312  7  5  0

    How to Work with Excel Files Using Apache POI

    This code will work as a utility to read and write excel files using Apache POI Library. 3.13
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    import org.apache.poi.hssf.usermodel.HSSFCell;
    import org.apache.poi.hssf.usermodel.HSSFRow;
    import org.apache.poi.hssf.usermodel.HSSFSheet;
    import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    import org.apache.poi.xssf.usermodel.XSSFCell;
    import org.apache.poi.xssf.usermodel.XSSFRow;
    import org.apache.poi.xssf.usermodel.XSSFSheet;
    import org.apache.poi.xssf.usermodel.XSSFWorkbook;
    
    public class ExcelUtils {
    
    	private static HSSFSheet ExcelWSheet;
    	private static HSSFWorkbook ExcelWBook;
    	private static HSSFCell Cell;
    
    	private static HSSFRow Row;
    	
    	private static String filePath;
    	public static void setExcelFile(String Path,String SheetName) throws Exception {
    
    			try {
    
       			// Open the Excel file
    				filePath=Path;
    
    			FileInputStream ExcelFile = new FileInputStream(Path);
    
    			// Access the required test data sheet
    
    			ExcelWBook = new HSSFWorkbook(ExcelFile);
    
    			ExcelWSheet = ExcelWBook.getSheet(SheetName);
    			
    
    			} catch (Exception e){
    
    				throw (e);
    
    			}
    
    	}
    
    	//This method is to read the test data from the Excel cell, in this we are passing parameters as Row num and Col num
    
        public static String getCellData(int RowNum, int ColNum) throws Exception{
    
    			try{
    
      			Cell = ExcelWSheet.getRow(RowNum).getCell(ColNum);
    
      			String CellData = Cell.getStringCellValue();
    
      			return CellData;
    
      			}catch (Exception e){
    
    				return"";
    
      			}
    
        }
    
    
        
      //This method is to write in the Excel cell, Row num and Col num are the parameters
    
    	public static void setCellData(String Result,  int RowNum, int ColNum) throws Exception	{
    
    			try{
    
      			Row  = ExcelWSheet.getRow(RowNum);
    
    			Cell = Row.getCell(ColNum, Row.RETURN_BLANK_AS_NULL);
    
    			if (Cell == null) {
    
    				Cell = Row.createCell(ColNum);
    
    				Cell.setCellValue(Result);
    
    				} else {
    
    					Cell.setCellValue(Result);
    
    				}
    
      // Constant variables Test Data path and Test Data file name
    
      				FileOutputStream fileOut = new FileOutputStream(filePath);
    
      				ExcelWBook.write(fileOut);
    
      				fileOut.flush();
    
    					fileOut.close();
    
    				}catch(Exception e){
    
    					throw (e);
    
    			}
    
    		}
    
    	
    }
              

    public by missinglink  55430  1  3  0

    A static OSM pbf fixture for testing purposes

    A static OSM pbf fixture for testing purposes: pbf-fixture.md
    download here: http://peter.johnson.s3.amazonaws.com/somes.osm.pbf
    
    A static OSM pbf extract for testing purposes which contains the following data:
    
    ```bash
    $ osmconvert --out-statistics somes.pbf 
    lon min: 174.8607050
    lon max: 174.8701924
    lat min: -41.2637515
    lat max: -41.2488235
    nodes: 1494
    ways: 77
    relations: 6
    node id min: 36910427
    node id max: 2683704198
    way id min: 5243611
    way id max: 262717543
    relation id min: 1941184
    relation id max: 3529329
    keyval pairs max: 42
    keyval pairs max object: node 1052815087
    noderefs max: 305
    noderefs max object: way 5243611
    relrefs max: 3
    relrefs max object: relation 2927601
    ```
    
    For those who are interested, the data comes from [Somes Island](http://en.wikipedia.org/wiki/Matiu_/_Somes_Island) in the Wellington Harbour, New Zealand and was generated 23 Sept 2014
    
    

    public by cghersi  4144  1  7  0

    Testing script for Stored Procedures

    This script helps developers test the performance of a stored procedure or block of code. Although it was written specifically to assist me in comparing stored procedures, it can easily be modified for other testing purposes. The script expects two tables, 'Seq1' and 'Seq2' to exist, and be of the structure as listed in the header comment of the
    /*************************************************************************************************
    ** File: "20090217 - testing script.sql"
    ** Desc: This is a more generalized script to run performance testing on the sequence 
    ** comparison code. It can be modified to test any other spds. This script requires
    ** the existence of two tables, Seq1 and Seq2, which should have the following structure:
    ** 
    ** CREATE TABLE Seq1 (
    **   CodeLineTxt varchar(max), /* stores the original line of code */
    **   CodeLineNum int not null identity(1,1), /* stores the line number */
    **   MatchLineNum int /* stores the matching line of code from spd #2 */
    ** )
    ** 
    ** Return values: report & results
    ** 
    ** Called by: 
    ** 
    ** Parameters:
    ** Input
    ** ----------
    ** none
    **
    ** Output
    ** -----------
    ** none
    **
    ** Auth: Jesse McLain
    ** Email: jesse@jessemclain.com
    ** Web: www.jessemclain.com
    ** Blog: http://jessesql.blogspot.com/2009/02/comparing-spds-part-3-performance.html
    **
    ** Date: 02/16/2008
    **
    ***************************************************************************************************
    ** Change History
    ***************************************************************************************************
    ** Date:    Author:         Description:
    ** -------- --------        -------------------------------------------
    ** 20080216 Jesse McLain    Created script
    **************************************************************************************************/
    
    SET NOCOUNT ON
    
    DECLARE @RunsPerInputSize int         ; SET @RunsPerInputSize = 1      /* #runs of @InputSize to execute */
    DECLARE @InputSizeIncrement int       ; SET @InputSizeIncrement = 50   /* @InputSize to increment btwn outer runs */
    DECLARE @TotalNumberIncrements int    ; SET @TotalNumberIncrements = 1 /* #increments to execute */
    
    DECLARE @StartTime datetime           ; SET @StartTime = GETDATE()
    DECLARE @StopTime datetime            ; SET @StopTime = GETDATE()
    DECLARE @Seq1 varchar(max)            ; SET @Seq1 = 'Test Sequence "'
    DECLARE @Seq2 varchar(max)            ; SET @Seq2 = 'Test Sequence "'
    DECLARE @TestValue varchar(2)         ; SET @TestValue = ''             /* holder to load values into seq tables */
    DECLARE @InputSize int                ; SET @InputSize = 0              /* input size for the current run */
    DECLARE @InputValueIdx int            ; SET @InputValueIdx = 1          /* counter */
    DECLARE @RunIdx int                   ; SET @RunIdx = 1                 /* counter */
    DECLARE @IncrIdx int                  ; SET @IncrIdx = 1                /* counter */
    DECLARE @Seq1Size int
    DECLARE @Seq2Size int
    DECLARE @Seq1Sizea int
    DECLARE @Seq2Sizea int
    DECLARE @PcntMatch decimal(9, 2)
    
    CREATE TABLE #PerformanceResults (
      InputSize int,
      RunStart datetime,
      RunDone datetime,
      PcntMatch decimal(9, 2)
    )
    
    /* the straight-forward approach to testing would be to start at the smallest
    input size, run through as many runs as we need for that, move on to the next
    input size, test that, until we test the max input size. We don't do that here.
    The problem with that approach is that if there's an external process running
    during the testing of an input size, the results for that size might be false.
    The approach here is to test the min size once, then the next largest size, 
    until the max size is tested, then start all over and repeat until we've tested
    each inputsize as many as "@RunsPerInputSize" times. */
    
    SET @RunIdx = 1
    /* outer loop to increment the number of runs per input size */
    WHILE @RunIdx <= @RunsPerInputSize
    BEGIN
      SET @IncrIdx = 1
      /* inner loop to increment each input size */
      WHILE @IncrIdx <= @TotalNumberIncrements
      BEGIN
        PRINT 'Testing size ' + LTRIM(STR(@IncrIdx)) + '/' + LTRIM(STR(@TotalNumberIncrements))
         + ', for run ' + LTRIM(STR(@RunIdx)) + '/' + LTRIM(STR(@RunsPerInputSize))
     
        SET @InputSize = @IncrIdx * @InputSizeIncrement
     
     
        /* insert rows into test table 1 */
        TRUNCATE TABLE Seq1
        SET @InputValueIdx = 1
        WHILE @InputValueIdx <= @InputSize
        BEGIN
          SET @TestValue = CHAR(FLOOR(RAND() * 10) + 65) + CHAR(FLOOR(RAND() * 10) + 65)
          INSERT INTO Seq1 (CodeLineTxt) VALUES (@TestValue)
          SET @Seq1 = @Seq1 + @TestValue
          SET @InputValueIdx = @InputValueIdx + 1
        END
        UPDATE Seq1 SET MatchLineNum = 0
        SET @Seq1 = @Seq1 + '"'
    
    
        /* insert rows into test table 2 */
        TRUNCATE TABLE Seq2
        SET @InputValueIdx = 1
        WHILE @InputValueIdx <= @InputSize
        BEGIN
          SET @TestValue = CHAR(FLOOR(RAND() * 10) + 65) + CHAR(FLOOR(RAND() * 10) + 65)
          INSERT INTO Seq2 (CodeLineTxt) VALUES (@TestValue)
          SET @Seq2 = @Seq2 + @TestValue
          SET @InputValueIdx = @InputValueIdx + 1
        END
        UPDATE Seq2 SET MatchLineNum = 0
        SET @Seq2 = @Seq2 + '"'
    
    
        /* wrap the executing code around timers to test */
        SET @StartTime = GETDATE()
      
        EXEC spd_SequenceCompare
    
        SET @StopTime = GETDATE()
    
    
        /* record results */
        SELECT @Seq1Size = COUNT(*) FROM Seq1
        SELECT @Seq2Size = COUNT(*) FROM Seq2
      
        SELECT @Seq1Sizea = COUNT(*) FROM Seq1 T1 WHERE MatchLineNum <> 0
        SELECT @Seq2Sizea = COUNT(*) FROM Seq2 T1 WHERE MatchLineNum <> 0
      
        SET @PcntMatch = 100.0 * (@Seq1Sizea / (1.0 * @Seq1Size) + @Seq2Sizea / (1.0 * @Seq2Size)) / 2
    
        INSERT INTO #PerformanceResults (InputSize, RunStart, RunDone, PcntMatch)
        VALUES (@InputSize, @StartTime, @StopTime, @PcntMatch)
     
        SET @IncrIdx = @IncrIdx + 1
      END
    
      SET @RunIdx = @RunIdx + 1
    END
    
    SELECT 
      InputSize, 
      NumberOfRuns = COUNT(*),
      AverageRunTime = AVG(CONVERT(decimal(9, 2), CONVERT(varchar(max), DATEDIFF(ss, RunStart, RunDone))
       + '.' + CONVERT(varchar(max), DATEDIFF(ms, RunStart, RunDone)))),
      AveragePercentMatch = AVG(PcntMatch)
    FROM #PerformanceResults
    GROUP BY InputSize
    
    
    DROP TABLE #PerformanceResults
    
    SET NOCOUNT OFF

    public by sukhjinderkahlon  3366  1  5  0

    Java Property File Reader

    This code will read properties files in java.
    package Helper.Functions;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.util.Properties;
    
    public class PropertyFileReader {
    	public static String GetValue(String key)
    	{
    		// Read from properties file
    		File file = new File("src\\main\\resources\\constants.properties");
    
    		FileInputStream fileInput = null;
    		try {
    			fileInput = new FileInputStream(file);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		Properties prop = new Properties();
    
    		//load properties file
    		try {
    			prop.load(fileInput);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    
    		//Get Data from File
    		String str = prop.getProperty(key);
    		// return the value
    		return strL;
    	}
    
    }
    

    public by vanarchi  2106  1  4  0

    Add SLF4J logger and setter for testing purpose

    private Logger logger = LoggerFactory.getLogger(getClass());
    	
    	public void setLogger(Logger logger) {
    		this.logger = logger;
    	}

    public by JKCPR  802  0  5  1

    unit testing - mocking server responses with sinonjs

    {
        setUp: function () {
            this.server = sinon.fakeServer.create();
        },
    
        tearDown: function () {
            this.server.restore();
        },
    
        "test should fetch comments from server" : function () {
            this.server.respondWith("GET", "/some/article/comments.json",
                                    [200, { "Content-Type": "application/json" },
                                     '[{ "id": 12, "comment": "Hey there" }]']);
    
            var callback = sinon.spy();
            myLib.getCommentsFor("/some/article", callback);
            this.server.respond();
    
            sinon.assert.calledWith(callback, [{ id: 12, comment: "Hey there" }]));
        }
    }		

    public by frosit  1161  1  4  0

    Magento testing scenarios

    Magento testing scenarios: magento-testing-scenarios.md
    # Magento testing scenarios
    *For use after an upgrade to verify the correct working of Magento*
    
    ![SHIP IT](http://media.giphy.com/media/143vPc6b08locw/giphy.gif)
    
    # Frontend
    
    ## General
     - Activate all logs on the server (PHP, MySQL, Magento, mail, etc)
     - Check meta tags in HTML
     - Check favicon
     - Check merging of CSS
     - Check merging of JS
     - Check Google Analytics
     - Check for Javascript errors in Console
     - Check header - all blocks present?
     - Check footer - all blocks present?
     - Check homepage
     - Test newsletter subscription block
         - For new subscriber
         - For existing subscriber
    
    ## Catalog
     - Click through all category pages and check for;
         - Layered navigation showing and working correctly
         - Sorting working correctly
         - Pager working correctly
         - Check breadcrumbs
     - Open at least 30 product pages and check for;
         - Correct price
         - Add to cart button
         - Configurable options, if applicable
         - Images
     - Check working of search
     - Check working of Advanced Search
    
    ## Checkout
    
    ### Cart
     - Add item to cart
     - Add multiple items to cart
     - Test Remove item button
     - Test Update shopping cart button
     - Test Clear shopping cart button
     - Check correct price
     - Check correct totals (discount/tax/etc)
     - Test Proceed to checkout button
     - Check pop-out shopping cart in top right, if applicable
     
    ### Onepage
     - Check if login works
     - Place a lot of orders;
         - Multiple products
         - With discounts
         - Let the transaction fail to see how Magento handles canceled orders
         - Try all combinations of payment methods & shipping methods
         - Try guest checkouts as well as logged-in checkouts
     - Check if all fields that should be collapsed are collapsed
     
    ### OneStepCheckout
     - All shipping methods available?
     - All payment methods available?
     - All enabled countries correct?
     - Are the AJAX filled fields loading correctly?
     - Does the login link work?
     - No license warning showing?
    
    ## My Account
     - Login & logout
     - Are the correct My Accounts options showing?
     - Reorder an order
     - Add/edit address
     - Subscribe / unsubscribe for newsletter
    
    # Extensions
    - Walk through all extensions and find out what their purpose is. This takes up the most of the work, but most extensions will have test cases that coincide with above test cases. For example; by placing an order you'll probably also test whether the order is sent to the warehouse or financial management system.
    
    #Backend
     - Clear cache
     - Reindex all indexers
     - Place an order through the backend
     - Create a customer through the backend
     - Open all pages to see whether exceptions occur
     - Check all configuration options for all extensions in the backend
     - Check tax setting
     - Check transactional emails
     - Check attributes and attribute sets
    
     
    # Misc
     - Check if crontab is set, start cron.php manually and check cron_schedule for errors
     - Shell scripts
     - After all previous test assignments, check all log files (Magento logs, PHP logs, MySQL logs, email logs)
    
    

    public by azazqadir  288  0  3  0

    Laravel Browser Testing: https://www.cloudways.com/blog/laravel-dusk-testing-todo-app/

    Laravel Browser Testing: https://www.cloudways.com/blog/laravel-dusk-testing-todo-app/: AppServiceProvider.php
    use Laravel\Dusk\DuskServiceProvider;
    
    public function register()
    {
        if ($this->app->environment('local', 'testing')) {
            $this->app->register(DuskServiceProvider::class);
        }
    }
    
    

    public by lbottaro  11080  5  10  4

    Dalekjs - Simple automated web test

    This snippet is a simple test for web page using Dalekjs testing tool. Here I import functions from a 'functions' file (placed in the same dir of this file, called functions.js). The test will execute three tests, 'Snip2code footer', 'LogOut' and 'Sign Up'. More info about dalekjs tool here Site: dalekjs.com
    //var S2CSettings = require('s2c_settings');
    var S2Cfns = require('./s2c_functions');
    var domain = "http://www.snip2code.com/"
    var appName = "Snip2Code"
    
    module.exports = {
    'Snip2code footer': function (test) {
      test
    	.open(domain)
    	.assert.url(domain, 'URL is as expected')
        .assert.title().is('Snip2Code', 'It has title')
    	.assert.exists('a[href="/Static/ToS"]', 'ToS exists')
    	.assert.exists('a[href="/Static/Privacy"]', 'Privacy exists')
    	.assert.exists('a[href="/Static/AboutUs"]', 'AboutUs exists')
    	.assert.exists('a[href="mailto:info@snip2code.com"]', 'Mailto exists')
    	.assert.exists('a[href="/Static/Downloads"]', 'Downloads exists')
    	.assert.exists('a[href="http://blog.snip2code.com"]', 'Blog exists')
    	.assert.exists('a[href="/Static/Docs"]', 'API exists')
        .done();
    },
    'Logout': S2Cfns.S2CLogout.bind(S2Cfns, domain),
    'Sign Up': function (test) {
      test
    	.open(domain)
    	.click('#signupBigBt')
    	.assert.title().is('Snip2Code - Sign Up', 'Sign Up is loaded')
    	.assert.url().to.contain(domain + 'Access/Signup', 'URL is as expected')
    	.type('#EMail', 'email@test.com')
    	.type('#Username', 'Pinkman')
    	.type('#Password', 'Walt')
    	.wait(5000)
        .done();
    }
    };  

    public by addicttux  12030  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 Snippets
    • Channels Snippets