Regex Spiel in Gurke, aber nicht erfassen

Question

Ich benutze specflow, um meine Browser-Tests schreiben mit Gherkin Syntax. Ich habe eine Schrittdefinition, in der ich zwei verschiedene Schritte zusammenführen, aber nicht erfassen möchte. Für zB:

Scenario: 
    Given I have some stuff 
    And I click on the configure user 
    And I configure user 
    And I set the user <config> to <value> 
    Then I should see user configuration is updated 

Scenario: 
    Given I have some stuff 
    And I click on the configure admin 
    And I configure admin 
    And I set the admin <config> to <value> 
    Then I should see user configuration is updated 

Der Schritt Definition regex für And I set the admin <config> to <value> wäre so etwas wie:

Given(@"And I set the admin (.*) to (.*)") 
public void AndISetTheAdminConfigToValue(string config, string value) 
{ 
    // implementation 
} 

Und für And I set the user <config> to <value> wäre wie:

Given(@"And I set the admin (.*) to (.*)") 
public void AndISetTheUserConfigToValue(string config, string value) 
{ 
    // implementation 
} 

Die Umsetzung der beiden Stufen gleich sind. Also, was ich möchte, ist tun:

Given(@"And I set the user|admin (.*) to (.*)") 
public void AndISetTheConfigToValue(string config, string value) 
{ 
    // implementation 
} 

Der obige Code wird nicht funktionieren wie config und value Parameter leere Zeichenkette wird als user und admin als ersten 2 Parameter erfasst werden.

Gibt es eine Möglichkeit, etwas wie oben zu tun, ohne die Regex-Übereinstimmungen im Parameter zu erfassen?

Ich weiß, dass ich das Szenario einfach umschreiben kann, um wie folgt das Problem zu lösen. Aber ich bin nur neugierig.

Scenario: 
    Given I have some stuff 
    And I click on the configure admin 
    And I configure admin 
    And I set the <config> to <value> 
    Then I should see user configuration is updated 

Answer 1

Mit was AlSki als Basis zur Verfügung gestellt hat:

eine optionale Gruppe verwenden würde auch hier eine Option sein:

[Given(@"I set the (?:user|admin) (.*) to (.*)"] 
public void ISetTheConfigValue(string config, string value) 

Das bedeutet, dass Sie keinen Parameter angeben müssen, den Sie nie verwenden werden.

Ich würde empfehlen, die lästige (.*) Regex loszuwerden, die alles und alles, was Sie dort hineinpassen übereinstimmen - ein Problem später, wenn Sie einen Schritt wollen, die die Privilegien, die der Benutzer haben kann greifen (als Beispiel)):

Given I set the user JohnSmith to an admin with example privileges

So würde ich dies persönlich benutze:

[Given(@'I set the (?:user|admin) "([^"]*)" to "([^"]*)"'] 
public void ISetTheConfigValue(string config, string value) 

Welche passen würde:

Given I set the user "JohnSmith" to "SysAdmin" 
And I set the admin "JaneDoe" to "User" 

Aber würde

Given I set the user JohnSmith to an admin with example privileges 

Answer 2

Zunächst vorsichtig sein, mehr (.*) s in der gleichen Bindung, wie sie zu fangen, die falschen Muster führen können.

Ohne ich bin mir ziemlich sicher zu prüfen, ob es möglich ist, mehrere Bindungen auf dem Verfahren, solange sie die gleiche Parameteranzahl, dh

[Given("I set the user (.*) to (.*)"] 
[Given("I set the admin (.*) to (.*)"] 
public void ISetTheConfigValue(string config, string value) 

Alternativ zur Verfügung zu stellen, können Sie immer einen Dummy-Parameter hinzufügen ,

[Given("I set the (user|admin) (.*) to (.*)"] 
public void ISetTheConfigValue(string _, string config, string value)