javascript - validacion - Una de las cadenas en conjunto para que coincida con una expresión

validar formulario html5

Question

El problema:

Tengo una serie de promesas que se resuelven en una serie de cadenas . Ahora la prueba debería pasar si al menos una de las cadenas coincide con una expresión regular.

Actualmente, lo resuelvo usando una simple concatenación de cadenas:

protractor.promise.all([text1, text2, text3]).then(function (values) {
    expect(values[0] + values[1] + values[2]).toMatch(/expression/);
});

Obviamente, esto no se escala bien y no es particularmente legible.

La pregunta:

¿Es posible resolverlo usando un jasmin matcher personalizado o jasmine.any() o un probador de igualdad asimétrico personalizado ?

Answer 1

Si esto funciona,

protractor.promise.all([text1, text2, text3]).then(function (values) {
    expect(values[0] + values[1] + values[2]).toMatch(/expression/);
});

Creo que puedes escribir esto de la siguiente manera;

protractor.promise.all([text1, text2, text3]).then(function (values) {
    expect(values.join('''')).toMatch(/expression/);
});

Y es escalable. :)

Answer 2

Si esos [texto1, texto2, texto3] son ​​textos de ElementFinder .getText() entonces también puedes probar con las condiciones esperadas (sabes que soy un gran admirador de EC ¿verdad? :)).

describe(''test'', function () {

    it(''test'', function () {
        var EC = protractor.ExpectedConditions;
        browser.get(''http://www.protractortest.org/testapp/ng1/#/form'');

        var textToContain = ''Check''; //Notice, that this is not ''equals'', this is ''contains''
        var elementTextToCheck1 = EC.textToBePresentInElement($(''#checkboxes h4''), textToContain); // Here it will be true : Checkboxes
        var elementTextToCheck2 = EC.textToBePresentInElement($(''#animals h4''), textToContain); //false
        var elementTextToCheck3 = EC.textToBePresentInElement($(''#transformedtext h4''), textToContain); //false

        var oneElementShouldContainText = EC.or(elementTextToCheck1, elementTextToCheck2, elementTextToCheck3);

        expect(oneElementShouldContainText()).toBeTruthy(`At least one element should contain "${textToContain}"`);
    })
});

Para elementos simples: http://www.protractortest.org/#/api?view=ExpectedConditions.prototype.textToBePresentInElement

Para textArea, entradas: http://www.protractortest.org/#/api?view=ExpectedConditions.prototype.textToBePresentInElementValue

Tenga en cuenta que desafortunadamente .textToBePresentInElement solo funciona con ElementFinder, ArrayElementFinder no es compatible. Pero en ese caso puede hacer algo con .filter() y afirmar que la lista devuelta está vacía.

Answer 3

Simplemente puede usar el map para obtener una lista de boolean y luego afirmar el resultado con toContain(true) :

var all = protractor.promise.all;
var map = protractor.promise.map;

expect(map(all([text1, text2, text3]), RegExp.prototype.test, /expression/)).toContain(true);

También puede usar un marcador personalizado:

expect(all([text1, text2, text3])).toContainPattern(/expression/);

Y el matcher personalizado declarado en beforeEach :

beforeEach(function() {
  jasmine.addMatchers({
    toContainPattern: function() {
      return {
        compare: function(actual, regex) {
          return {
            pass: actual.some(RegExp.prototype.test, regex), 
            message: "Expected [" + actual + "] to have one or more match with " + regex
          };
        }
      };
    }
  });
});

Answer 4

Array.prototype.some() parece a lo que realmente está buscando.

protractor.promise.all([text1, text2, text3]).then(function (values) {
    expect(values.some(v => v.match(/expression/)).toBe(true);
});

Para obtener más información, https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/some

Answer 5

Como dije en los comentarios, aunque inicialmente uso el map , reducir te permitirá hacer lo que necesites, y en esta casta al menos tiene mucho más sentido:

protractor.promise.all([text1, text2, text3]).then(function (values) {
    expect(
        values.reduce(function(p, v) {
            return v.match(/expression/) || p;
        }, false)
    ).toBe(true);
});

O escribiendo lo mismo, pero usando las funciones de flecha ES6:

protractor.promise.all([text1, text2, text3]).then(function(values) {
    exptect(
        values.reduce( (p, v) => v.match(/expression/) || p, false )
    ).toBe(true);
});

Ambos hacen lo mismo, la devolución de llamada v.match se establecerá en falso de forma predeterminada, hasta que la expresión v.match evalúe como verdadera.
Supongo que esto es obvio para la mayoría de las personas, pero pensé que proporcionaría ambas sintaxis y alguna explicación para referencia futura.

Quizás esta solución podría optimizarse un poco más, para detener la coincidencia del patrón una vez que se ha encontrado una coincidencia única:

protractor.promise.all([text1, text2, text3]).then(function (values) {
    expect(
        values.reduce(function(p, v) {
            return p || !!v.match(/expression/);
        }, false)
    ).toBe(true);
});

Todo lo que hice fue usar el valor de reducción actual como predeterminado (una vez que se ha establecido en verdadero, no tiene sentido probar cualquier otro valor de cadena). Para asegurar que v.match evalúe un booleano en lugar de una matriz, ¡acabo de usar !!v.match() . Esa parte es opcional sin embargo. En ES6, lo mismo se ve así:

protractor.promise.all([text1, text2, text3]).then(function(values) {
    exptect(
        values.reduce( (p, v) => p || !!v.match(/expression/), false )
    ).toBe(true);
});

Esto podría funcionar mejor con grandes conjuntos de datos (teniendo en cuenta que las llamadas de match se detienen una vez que se encontró la primera coincidencia, en lugar de v.match cada vez).