logiczne parametry SpecFlow kroki

Question

W SpecFlow, chcę sprawdzić na obecność ciąg w definicji kroku i w tej chwili robię przylegający rzeczy jak to contrived przykład:

[Given(@"Foo (bar)?")] 
public void GivenFoo(string bar) 
{ 
    if (bar == " bar") 
    { 
     // do bar 
    } 
} 

Jednak ja” Chciałbym zrobić coś takiego:

[Given(@"Foo (bar)?")] 
public void GivenFoo(bool bar) 
{ 
    if (bar) 
    { 
     // do bar 
    } 
} 

Ale nie mogę się dowiedzieć, jak to możliwe, a jeśli tak, to w jaki sposób?

Answer 1

Szukasz:

[Given(@"I do something (times) times")] 
public void GivenIDoSomething(int times) 
{ 
} 

przeciwnym razie wydaje się to wystarczyć

[Given(@"I do something twice")] 
public void GivenIDoSomethingTwice() 
{ 
} 

EDYCJA

myślę, że zamiast if stwierdzenie w kroku rzeczywiście chcesz, aby oddzielić czynności.

Answer 2

Na podstawie Twojego pytania i komentarzy do odpowiedzi Jakuba, wygląda na to, że próbujesz napisać pojedynczy krok, który może obejmować wiele podróży użytkowników w Twojej witrynie. SpecFlow nie jest do tego stworzony i prawdopodobnie jest to wskazówka, że ​​powinieneś spróbować ulepszyć strukturę twoich scenariuszy/funkcji.

Aby odpowiedzieć bezpośrednio na twoje pytanie, nie wierzę, że istnieje sposób na dedukcję wartości boolowskich w oparciu o istnienie pewnych ciągów w definicji kroku.

Jeśli chcesz przetrwać tę trasę, Twój oryginalny przykład jest prawdopodobnie najlepszym rozwiązaniem.

Zaleca się jednak, aby nie stosować podejścia, a zamiast tego przyjrzeć się restrukturyzacji definicji kroków, aby połączyć je w łańcuchy i ponownie wykorzystać w różnych scenariuszach. Naprawdę staram się wymyślić przykładową definicję kroku, która pasowałaby do twojego rozwiązania.

Przykładem podejścia wieloetapowej mógłby wyglądać następująco:

Given I have logged in as an existing user //1 
And I have started my 6-step registration process //2 
And I have filled in valid address values on step 1 //3 
And I have left the fields blank on step 2 //4 
... etc 
When I save my registration 

i Twoich kroków byłoby:

1. Przejdź do strony logowania, należy zalogować się jako ważny użytkownik
2. Nawiguj do kroku 1
3. wypełnij pola z poprawnymi danymi wejściowymi, kliknij "Dalej"
4. kliknij "dalej"

Trzeba tylko upewnić się, że każdy krok jest tak niezależny od innych, jak to możliwe, więc można zastąpić jeden krok nieco innym (dla nowego scenariusza) bez wpływu na pozostałe.

Dzięki takiemu podejściu nadal można skończyć ze złożonymi (i potencjalnie dość gadatliwymi) scenariuszami, ale uważam, że jest to lepsze rozwiązanie niż staranie się sprytnie i spakowanie aż do definicji jednego kroku. Prawdopodobnie skończy się to scenariuszami, które są nieczytelne, a kod prawdopodobnie będzie trudny do odczytania/utrzymania.

Answer 3

Zdecydowanie możesz robić tego rodzaju rzeczy, używając metody StepArgumentTransformation. Nadal musisz napisać logikę parsera, ale możesz ją zamaskować w metodę, której jedynym celem jest wykonanie tego parsowania.

Przykładowy plik cecha:

Feature: I win if I am Batman 

Scenario: Happy 
    Given I am the Batman 
    Then I defeat the Joker 

Scenario: Sad 
    Given I am not the Batman 
    Then I am defeated by the Joker 

Specflow Wiązania (C#):

[Binding] 
public class IWinIfIAmBatmanFeature 
{ 
    private bool iAmBatman; 

    [StepArgumentTransformation(@"(am ?.*)")] 
    public bool AmToBool(string value) 
    { 
     return value == "am"; 
    } 

    [Given(@"I (.*) the Batman")] 
    public void WhoAmI(bool amIBatman) 
    { 
     iAmBatman = amIBatman; 
    } 

    [StepArgumentTransformation(@"(defeat|am defeated by)")] 
    public bool WinLoseToBool(string value) 
    { 
     return value == "defeat"; 
    } 

    [Then(@"I (.*) the Joker")] 
    public void SuccessCondition(bool value) 
    { 
     Assert.AreEqual(iAmBatman, value); 
    } 
} 

Kluczowym czynnikiem jest to, że mecz regex w klauzuli Given towarzyszą transformacji krok argumentów. Tak więc w I (.*) the Batman, jeśli przechwycenie pasuje do wyrażenia regularnego w argumencie dla StepArgumentTransformation, tak jak ma to miejsce w przypadku atrybutu AmToBool, jest to przekształcenie, które zostanie użyte.