Una delle corde in serie in modo che corrisponda l'espressione

Question

Il problema:

Ho una serie di promesse che si risolve a un array di stringhe . Ora il test dovrebbe passare se almeno una delle stringhe corrisponde a un'espressione regolare.

Attualmente, ho risolto utilizzando semplici concatenazione stringa:

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

Ovviamente, questo non scala bene e non è particolarmente leggibile.

la domanda:

Is è possibile risolvere utilizzando un personalizzato gelsomino matcher, o jasmine.any() o custom asymmetric equality tester?

Answer 1

Si potrebbe semplicemente utilizzare map per ottenere un elenco di boolean e poi affermare il risultato 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); 

Si potrebbe anche usare un matcher personalizzato:

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

E il matcher personalizzato dichiarata in 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 2

Come detto nei commenti, anche se inizialmente ho usato map, ridurre permetterebbe di fare ciò che è necessario, e in questa casta, almeno rende molto più senso:

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

o scrivendo la stessa cosa , ma che utilizzano ES6 funzioni di direzione:

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

Entrambi fanno la stessa cosa, la richiamata ridurre imposterà falso, fino a quando l'espressione v.match restituisce true.
Sto assumendo questo è evidente ai più, ma ho pensato di fornire entrambe le sintassi e qualche spiegazione per riferimento futuro

---

Forse questa soluzione potrebbe essere ottimizzato un po 'di più, smettere di corrispondenza il modello di una volta una singola partita è stata trovata:

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

Tutto quello che ho fatto è stato quello di utilizzare il valore di ridurre la corrente come predefinito (una volta che è stato impostato su true, non c'è nessun punto nel testare qualsiasi altro valore stringa). Per garantire che v.match valuti su un valore booleano anziché su un array, ho semplicemente utilizzato !!v.match(). Quella parte è opzionale però. Nel ES6, la stessa cosa è simile al seguente:

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

Questo potrebbe funzionare meglio con set di dati di grandi (considerando il match chiamate si fermano una volta che il primo match è stato trovato, al contrario di v.match essere chiamato ogni volta).

Answer 3

Se funziona,

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

Penso che si possa scrivere questo come segue;

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

Ed è scalabile. :)

Answer 4

Se quelli [testo1, testo2, testo3] sono testi da ElementFinder .getText() allora puoi anche provare con le condizioni attese (sai che sono un grande fan di EC giusto? :)).

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}"`); 
    }) 
}); 

Per elementi semplici: http://www.protractortest.org/#/api?view=ExpectedConditions.prototype.textToBePresentInElement

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

dati, che sfortunatamente .textToBePresentInElement funziona solo con singolo ElementFinder, ArrayElementFinder non è supportato. In tal caso, puoi creare qualcosa con .filter() e affermare che l'elenco restituito è vuoto.

Answer 5

Array.prototype.some() sembra proprio quello che stai cercando.

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

Per ulteriori informazioni https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/some