NLP for Requirements-to-Tests Conversion: From User Stories to Automated BDD

# Using spaCy for entity extraction
import spacy

nlp = spacy.load("en_core_web_lg")
doc = nlp(user_story_text)

# Extract entities
entities = {
    "ACTOR": [],        # registered user
    "ACTION": [],       # reset, send, click, set
    "OBJECT": [],       # password, email, link
    "CONSTRAINT": [],   # 24 hours, min 8 chars, 1 uppercase, 1 number
    "SYSTEM": []        # reset page, email system
}

for ent in doc.ents:
    if ent.label_ == "PERSON":
        entities["ACTOR"].append(ent.text)
    elif ent.label_ in ["TIME", "DATE", "QUANTITY"]:
        entities["CONSTRAINT"].append(ent.text)

# Output:
{
  "ACTOR": ["registered user"],
  "ACTION": ["reset", "send", "click", "set"],
  "OBJECT": ["password", "email address", "reset link", "new password"],
  "CONSTRAINT": ["24 hours", "min 8 chars", "1 uppercase", "1 number"],
  "SYSTEM": ["reset page", "System"]
}

# Install spaCy with transformer model
pip install spacy transformers
python -m spacy download en_core_web_trf

# Load model
import spacy
nlp = spacy.load("en_core_web_trf")

# Add custom entity recognizer for domain-specific terms
from spacy.pipeline import EntityRuler

ruler = nlp.add_pipe("entity_ruler", before="ner")
patterns = [
    {"label": "UI_ELEMENT", "pattern": [{"LOWER": "button"}]},
    {"label": "UI_ELEMENT", "pattern": [{"LOWER": "form"}]},
    {"label": "UI_ELEMENT", "pattern": [{"LOWER": "page"}]},
    {"label": "ACTION", "pattern": [{"LOWER": "click"}]},
    {"label": "ACTION", "pattern": [{"LOWER": "enter"}]},
    {"label": "ACTION", "pattern": [{"LOWER": "submit"}]},
    {"label": "VALIDATION", "pattern": [{"LOWER": "validate"}]},
    {"label": "VALIDATION", "pattern": [{"LOWER": "verify"}]},
]
ruler.add_patterns(patterns)

class UserStoryParser:
    def __init__(self):
        self.nlp = spacy.load("en_core_web_trf")

    def parse_story(self, story_text):
        """Parse user story into structured format"""
        doc = self.nlp(story_text)

        parsed = {
            "actor": self._extract_actor(doc),
            "actions": self._extract_actions(doc),
            "objects": self._extract_objects(doc),
            "constraints": self._extract_constraints(doc),
            "preconditions": self._extract_preconditions(doc),
            "outcomes": self._extract_outcomes(doc)
        }

        return parsed

    def _extract_actor(self, doc):
        """Extract primary actor from 'As a...' pattern"""
        for i, token in enumerate(doc):
            if token.text.lower() == "as" and i + 1 < len(doc):
                # Find noun phrase after "as a"
                for chunk in doc.noun_chunks:
                    if chunk.start >= i and chunk.root.pos_ == "NOUN":
                        return chunk.text
        return None

    def _extract_actions(self, doc):
        """Extract verbs that represent actions"""
        actions = []
        for token in doc:
            if token.pos_ == "VERB" and token.dep_ in ["ROOT", "xcomp"]:
                # Get verb phrase
                verb_phrase = " ".join([t.text for t in token.subtree])
                actions.append({
                    "verb": token.lemma_,
                    "phrase": verb_phrase,
                    "negated": self._is_negated(token)
                })
        return actions

    def _extract_constraints(self, doc):
        """Extract constraints (time, quantity, format)"""
        constraints = []

        # Extract numerical constraints
        for ent in doc.ents:
            if ent.label_ in ["QUANTITY", "TIME", "DATE", "CARDINAL"]:
                constraints.append({
                    "type": ent.label_,
                    "value": ent.text,
                    "context": self._get_context(ent)
                })

        # Extract regex-like patterns (e.g., "min 8 chars")
        import re
        pattern_matches = re.findall(
            r'(min|max|at least|at most)\s+(\d+)\s+(\w+)',
            doc.text,
            re.IGNORECASE
        )
        for match in pattern_matches:
            constraints.append({
                "type": "NUMERIC_CONSTRAINT",
                "operator": match[0],
                "value": match[1],
                "unit": match[2]
            })

        return constraints

    def _is_negated(self, token):
        """Check if verb is negated"""
        return any(child.dep_ == "neg" for child in token.children)

    def _get_context(self, span):
        """Get surrounding context for an entity"""
        start = max(0, span.start - 3)
        end = min(len(span.doc), span.end + 3)
        return span.doc[start:end].text

# Usage
parser = UserStoryParser()
result = parser.parse_story("""
As a registered user, I want to reset my password via email
so that I can regain access if I forget my credentials.

Acceptance Criteria:
- User enters email address on reset page
- System sends reset link valid for 24 hours
- New password must contain min 8 chars, 1 uppercase, 1 number
""")

print(result)
# Output:
{
  "actor": "a registered user",
  "actions": [
    {"verb": "reset", "phrase": "reset my password", "negated": False},
    {"verb": "enter", "phrase": "enters email address", "negated": False},
    {"verb": "send", "phrase": "sends reset link", "negated": False}
  ],
  "constraints": [
    {"type": "TIME", "value": "24 hours", "context": "link valid for 24 hours"},
    {"type": "NUMERIC_CONSTRAINT", "operator": "min", "value": "8", "unit": "chars"}
  ],
  "objects": ["password", "email", "reset link", "email address"],
  "outcomes": ["regain access"]
}

from transformers import BertTokenizer, BertForSequenceClassification
from transformers import Trainer, TrainingArguments
import torch

# Load pre-trained BERT
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained(
    'bert-base-uncased',
    num_labels=5  # Action types: CREATE, READ, UPDATE, DELETE, VALIDATE
)

# Prepare training data
training_examples = [
    {"text": "User creates new account", "label": 0},  # CREATE
    {"text": "System displays user profile", "label": 1},  # READ
    {"text": "User updates password", "label": 2},  # UPDATE
    {"text": "Admin deletes user", "label": 3},  # DELETE
    {"text": "System validates email format", "label": 4},  # VALIDATE
    # ... hundreds more examples
]

class RequirementsDataset(torch.utils.data.Dataset):
    def __init__(self, texts, labels, tokenizer):
        self.encodings = tokenizer(texts, truncation=True, padding=True)
        self.labels = labels

    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        item['labels'] = torch.tensor(self.labels[idx])
        return item

    def __len__(self):
        return len(self.labels)

# Create dataset
texts = [ex["text"] for ex in training_examples]
labels = [ex["label"] for ex in training_examples]
dataset = RequirementsDataset(texts, labels, tokenizer)

# Training configuration
training_args = TrainingArguments(
    output_dir='./requirements-classifier',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset
)

# Fine-tune
trainer.train()

class IntentRecognizer:
    def __init__(self, model_path):
        self.tokenizer = BertTokenizer.from_pretrained(model_path)
        self.model = BertForSequenceClassification.from_pretrained(model_path)
        self.model.eval()

        self.intent_labels = [
            "CREATE", "READ", "UPDATE", "DELETE", "VALIDATE",
            "NAVIGATE", "SEARCH", "FILTER", "AUTHENTICATE", "AUTHORIZE"
        ]

    def recognize_intent(self, sentence):
        """Classify intent of requirement sentence"""
        inputs = self.tokenizer(
            sentence,
            return_tensors="pt",
            truncation=True,
            padding=True
        )

        with torch.no_grad():
            outputs = self.model(**inputs)
            predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)

        intent_idx = predictions.argmax().item()
        confidence = predictions[0][intent_idx].item()

        return {
            "intent": self.intent_labels[intent_idx],
            "confidence": confidence,
            "all_probabilities": {
                label: prob.item()
                for label, prob in zip(self.intent_labels, predictions[0])
            }
        }

# Usage
recognizer = IntentRecognizer('./requirements-classifier')

result = recognizer.recognize_intent(
    "System validates email format before submission"
)

print(result)
# Output:
{
  "intent": "VALIDATE",
  "confidence": 0.94,
  "all_probabilities": {
    "CREATE": 0.01,
    "READ": 0.02,
    "UPDATE": 0.01,
    "DELETE": 0.00,
    "VALIDATE": 0.94,
    "NAVIGATE": 0.01,
    ...
  }
}

from transformers import BertForTokenClassification

class RequirementEntityExtractor:
    def __init__(self, model_path):
        self.tokenizer = BertTokenizer.from_pretrained(model_path)
        self.model = BertForTokenClassification.from_pretrained(model_path)

        # Entity labels for requirements
        self.labels = [
            "O",           # Outside
            "B-ACTOR",     # Beginning of Actor
            "I-ACTOR",     # Inside Actor
            "B-ACTION",    # Action
            "I-ACTION",
            "B-OBJECT",    # Object
            "I-OBJECT",
            "B-CONSTRAINT",# Constraint
            "I-CONSTRAINT",
            "B-SYSTEM",    # System component
            "I-SYSTEM"
        ]

    def extract_entities(self, text):
        """Extract entities from requirement text"""
        inputs = self.tokenizer(
            text,
            return_tensors="pt",
            truncation=True,
            padding=True,
            return_offsets_mapping=True
        )

        with torch.no_grad():
            outputs = self.model(**inputs)
            predictions = torch.argmax(outputs.logits, dim=2)

        # Convert token predictions to entities
        tokens = self.tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
        pred_labels = [self.labels[p] for p in predictions[0].tolist()]

        entities = self._group_entities(tokens, pred_labels)
        return entities

    def _group_entities(self, tokens, labels):
        """Group B-X and I-X tokens into entities"""
        entities = []
        current_entity = None

        for token, label in zip(tokens, labels):
            if token in ["[CLS]", "[SEP]", "[PAD]"]:
                continue

            if label.startswith("B-"):
                if current_entity:
                    entities.append(current_entity)
                current_entity = {
                    "type": label[2:],
                    "text": token.replace("##", "")
                }
            elif label.startswith("I-") and current_entity:
                current_entity["text"] += " " + token.replace("##", "")
            else:
                if current_entity:
                    entities.append(current_entity)
                    current_entity = None

        if current_entity:
            entities.append(current_entity)

        return entities

# Usage
extractor = RequirementEntityExtractor('./requirements-ner-model')

entities = extractor.extract_entities(
    "As a registered user, I want to reset my password via email"
)

print(entities)
# Output:
[
  {"type": "ACTOR", "text": "registered user"},
  {"type": "ACTION", "text": "reset"},
  {"type": "OBJECT", "text": "password"},
  {"type": "SYSTEM", "text": "email"}
]

class ScenarioGenerator:
    def __init__(self):
        self.templates = {
            "CREATE": [
                "POSITIVE: {actor} successfully creates {object}",
                "NEGATIVE: {actor} fails to create {object} with invalid {field}",
                "EDGE: {actor} creates {object} with minimum valid data",
                "EDGE: {actor} creates {object} with maximum valid data",
                "SECURITY: Unauthorized user attempts to create {object}"
            ],
            "UPDATE": [
                "POSITIVE: {actor} successfully updates {object}",
                "NEGATIVE: {actor} fails to update non-existent {object}",
                "NEGATIVE: {actor} fails to update {object} with invalid data",
                "CONCURRENCY: Two users update same {object} simultaneously"
            ],
            "DELETE": [
                "POSITIVE: {actor} successfully deletes {object}",
                "NEGATIVE: {actor} fails to delete non-existent {object}",
                "SECURITY: Unauthorized user attempts to delete {object}",
                "CASCADE: Deleting {object} removes related dependencies"
            ],
            "VALIDATE": [
                "POSITIVE: {object} passes validation with valid {constraint}",
                "NEGATIVE: {object} fails validation with invalid {constraint}",
                "BOUNDARY: {object} validation at min/max {constraint} values"
            ]
        }

    def generate_scenarios(self, parsed_requirement):
        """Generate test scenarios from parsed requirement"""
        intent = parsed_requirement["intent"]
        actor = parsed_requirement["actor"]
        objects = parsed_requirement["objects"]
        constraints = parsed_requirement["constraints"]

        scenarios = []

        # Get templates for this intent
        templates = self.templates.get(intent, [])

        for obj in objects:
            for template in templates:
                scenario = template.format(
                    actor=actor,
                    object=obj,
                    field=self._extract_fields(constraints),
                    constraint=self._format_constraints(constraints)
                )
                scenarios.append({
                    "description": scenario,
                    "type": self._extract_type(template),
                    "priority": self._calculate_priority(template, constraints)
                })

        return scenarios

    def _extract_type(self, template):
        """Extract scenario type from template"""
        if template.startswith("POSITIVE"):
            return "positive"
        elif template.startswith("NEGATIVE"):
            return "negative"
        elif template.startswith("EDGE"):
            return "edge"
        elif template.startswith("SECURITY"):
            return "security"
        else:
            return "other"

    def _calculate_priority(self, template, constraints):
        """Calculate priority based on template and constraints"""
        priority = 3  # Medium by default

        if template.startswith("POSITIVE"):
            priority = 1  # High
        elif template.startswith("SECURITY"):
            priority = 1  # High
        elif len(constraints) > 0:
            priority = 2  # Medium-high for constrained scenarios

        return priority

    def _extract_fields(self, constraints):
        """Extract field names from constraints"""
        fields = [c.get("unit", "field") for c in constraints]
        return fields[0] if fields else "data"

    def _format_constraints(self, constraints):
        """Format constraints as readable string"""
        if not constraints:
            return "data"
        return ", ".join([f"{c.get('value', '')} {c.get('unit', '')}"
                         for c in constraints])

# Usage
generator = ScenarioGenerator()

parsed = {
    "intent": "CREATE",
    "actor": "registered user",
    "objects": ["password"],
    "constraints": [
        {"value": "8", "unit": "characters", "operator": "min"},
        {"value": "1", "unit": "uppercase"},
        {"value": "1", "unit": "number"}
    ]
}

scenarios = generator.generate_scenarios(parsed)

for scenario in scenarios:
    print(f"[{scenario['type'].upper()}] {scenario['description']}")

# Output:
# [POSITIVE] registered user successfully creates password
# [NEGATIVE] registered user fails to create password with invalid characters
# [EDGE] registered user creates password with minimum valid data
# [EDGE] registered user creates password with maximum valid data
# [SECURITY] Unauthorized user attempts to create password

from transformers import T5Tokenizer, T5ForConditionalGeneration

class MLScenarioGenerator:
    def __init__(self, model_path="t5-base"):
        """Initialize T5 model for scenario generation"""
        self.tokenizer = T5Tokenizer.from_pretrained(model_path)
        self.model = T5ForConditionalGeneration.from_pretrained(model_path)

    def generate_scenarios(self, requirement_text, num_scenarios=5):
        """Generate test scenarios from requirement using T5"""

        # Prepare input
        input_text = f"generate test scenarios: {requirement_text}"
        inputs = self.tokenizer(
            input_text,
            return_tensors="pt",
            max_length=512,
            truncation=True
        )

        # Generate multiple scenarios with beam search
        outputs = self.model.generate(
            inputs.input_ids,
            max_length=150,
            num_beams=num_scenarios * 2,
            num_return_sequences=num_scenarios,
            temperature=0.7,
            top_k=50,
            top_p=0.95,
            early_stopping=True
        )

        # Decode scenarios
        scenarios = []
        for output in outputs:
            scenario_text = self.tokenizer.decode(output, skip_special_tokens=True)
            scenarios.append({
                "description": scenario_text,
                "confidence": self._calculate_confidence(output)
            })

        return scenarios

    def _calculate_confidence(self, output_ids):
        """Calculate confidence score for generated scenario"""
        # Simple confidence based on output length and token probabilities
        return min(1.0, len(output_ids) / 100)

# Fine-tuning example (requires training data)
def fine_tune_scenario_generator(training_data):
    """
    Fine-tune T5 on requirement-to-scenario pairs

    training_data format:
    [
        {
            "input": "User Story: As a user, I want to login...",
            "output": "Test: Verify successful login with valid credentials"
        },
        ...
    ]
    """
    from transformers import Trainer, TrainingArguments

    tokenizer = T5Tokenizer.from_pretrained("t5-base")
    model = T5ForConditionalGeneration.from_pretrained("t5-base")

    # Prepare dataset
    inputs = [f"generate test scenarios: {item['input']}"
              for item in training_data]
    outputs = [item['output'] for item in training_data]

    input_encodings = tokenizer(inputs, truncation=True, padding=True)
    target_encodings = tokenizer(outputs, truncation=True, padding=True)

    # Training setup
    training_args = TrainingArguments(
        output_dir="./scenario-generator",
        num_train_epochs=5,
        per_device_train_batch_size=8,
        save_steps=1000,
        logging_steps=100
    )

    # Train
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=create_dataset(input_encodings, target_encodings)
    )

    trainer.train()
    return model

# Usage
generator = MLScenarioGenerator()

scenarios = generator.generate_scenarios("""
User Story: As a registered user, I want to reset my password via email
so that I can regain access if I forget my credentials.

Acceptance Criteria:
- User enters email address on reset page
- System sends reset link valid for 24 hours
- New password must be minimum 8 characters with 1 uppercase and 1 number
""", num_scenarios=5)

for i, scenario in enumerate(scenarios, 1):
    print(f"{i}. {scenario['description']} (confidence: {scenario['confidence']:.2f})")

# Output:
# 1. Verify user can successfully reset password with valid email (confidence: 0.89)
# 2. Verify reset link expires after 24 hours (confidence: 0.85)
# 3. Verify password validation rejects passwords shorter than 8 characters (confidence: 0.82)
# 4. Verify password validation requires at least 1 uppercase letter (confidence: 0.81)
# 5. Verify system prevents password reset for non-existent email (confidence: 0.78)

Feature: Password Reset
  As a registered user
  I want to reset my password via email
  So that I can regain access if I forget my credentials

  Background:
    Given I am a registered user
    And I have access to my email

  Scenario: Successful password reset
    Given I am on the password reset page
    When I enter my email address "user@example.com"
    And I click the "Send Reset Link" button
    Then I should see a confirmation message
    And I should receive a password reset email
    When I click the reset link in the email
    And I enter a new password "NewPass123"
    And I confirm the new password "NewPass123"
    And I click the "Reset Password" button
    Then I should see a success message
    And I should be able to login with the new password

  Scenario: Reset link expiration
    Given I have requested a password reset
    And 25 hours have passed
    When I click the reset link
    Then I should see an error message "Link expired"

class GherkinGenerator:
    def __init__(self):
        self.step_templates = {
            "GIVEN": {
                "navigate": "I am on the {page}",
                "logged_in": "I am logged in as {actor}",
                "data_exists": "{object} exists with {attributes}",
                "state": "the system is in {state} state"
            },
            "WHEN": {
                "click": "I click the \"{element}\" {element_type}",
                "enter": "I enter \"{value}\" in the \"{field}\" field",
                "select": "I select \"{option}\" from \"{dropdown}\"",
                "submit": "I submit the {form_name} form",
                "navigate": "I navigate to {page}"
            },
            "THEN": {
                "see_message": "I should see a {message_type} message \"{message}\"",
                "see_element": "I should see the \"{element}\" {element_type}",
                "redirect": "I should be redirected to {page}",
                "data_saved": "{object} should be saved with {attributes}",
                "validation_error": "I should see a validation error for \"{field}\""
            }
        }

    def generate_feature(self, user_story, scenarios):
        """Generate complete Gherkin feature file"""

        feature = f"""Feature: {user_story['title']}
  {user_story['description']}

"""

        # Add background if common preconditions exist
        background = self._generate_background(scenarios)
        if background:
            feature += f"{background}\n\n"

        # Generate scenarios
        for scenario in scenarios:
            feature += self._generate_scenario(scenario) + "\n\n"

        return feature

    def _generate_scenario(self, scenario_data):
        """Generate single Gherkin scenario"""

        scenario = f"  Scenario: {scenario_data['name']}\n"

        # Given steps (preconditions)
        for given in scenario_data.get('preconditions', []):
            scenario += f"    Given {self._format_step(given, 'GIVEN')}\n"

        # When steps (actions)
        for when in scenario_data.get('actions', []):
            scenario += f"    When {self._format_step(when, 'WHEN')}\n"

        # Then steps (assertions)
        for then in scenario_data.get('outcomes', []):
            scenario += f"    Then {self._format_step(then, 'THEN')}\n"

        return scenario

    def _format_step(self, step_data, step_type):
        """Format step using templates"""
        template_key = step_data.get('template', 'default')
        template = self.step_templates[step_type].get(template_key, "{text}")

        return template.format(**step_data.get('params', {}))

    def _generate_background(self, scenarios):
        """Extract common preconditions as Background"""
        # Find steps common to all scenarios
        common_steps = self._find_common_steps(scenarios)

        if not common_steps:
            return None

        background = "  Background:\n"
        for step in common_steps:
            background += f"    Given {step}\n"

        return background

    def _find_common_steps(self, scenarios):
        """Find steps present in all scenarios"""
        if not scenarios:
            return []

        first_preconditions = set(
            self._step_to_string(s)
            for s in scenarios[0].get('preconditions', [])
        )

        for scenario in scenarios[1:]:
            scenario_preconditions = set(
                self._step_to_string(s)
                for s in scenario.get('preconditions', [])
            )
            first_preconditions &= scenario_preconditions

        return list(first_preconditions)

    def _step_to_string(self, step):
        """Convert step data to string for comparison"""
        return f"{step.get('template', '')}:{step.get('params', {})}"

# Advanced: NLP-to-Gherkin Pipeline
class NLPToGherkinPipeline:
    def __init__(self):
        self.parser = UserStoryParser()
        self.intent_recognizer = IntentRecognizer('./models/intent-classifier')
        self.scenario_generator = ScenarioGenerator()
        self.gherkin_generator = GherkinGenerator()

    def convert_to_gherkin(self, user_story_text):
        """Complete pipeline: User Story → Gherkin"""

        # Step 1: Parse user story
        parsed = self.parser.parse_story(user_story_text)

        # Step 2: Recognize intents
        intents = []
        for action in parsed['actions']:
            intent = self.intent_recognizer.recognize_intent(action['phrase'])
            intents.append(intent)

        # Step 3: Generate test scenarios
        test_scenarios = []
        for intent in intents:
            scenarios = self.scenario_generator.generate_scenarios({
                "intent": intent['intent'],
                "actor": parsed['actor'],
                "objects": parsed['objects'],
                "constraints": parsed['constraints']
            })
            test_scenarios.extend(scenarios)

        # Step 4: Convert to structured format for Gherkin
        gherkin_scenarios = self._structure_for_gherkin(
            parsed,
            test_scenarios
        )

        # Step 5: Generate Gherkin
        user_story_info = {
            "title": "Password Reset",
            "description": user_story_text
        }

        feature_file = self.gherkin_generator.generate_feature(
            user_story_info,
            gherkin_scenarios
        )

        return feature_file

    def _structure_for_gherkin(self, parsed, scenarios):
        """Convert scenarios to Gherkin-ready structure"""
        gherkin_scenarios = []

        for scenario in scenarios:
            gherkin_scenario = {
                "name": scenario['description'],
                "preconditions": self._extract_preconditions(parsed),
                "actions": self._extract_actions(parsed),
                "outcomes": self._extract_outcomes(scenario)
            }
            gherkin_scenarios.append(gherkin_scenario)

        return gherkin_scenarios

    def _extract_preconditions(self, parsed):
        """Extract Given steps from parsed data"""
        preconditions = []

        if parsed.get('actor'):
            preconditions.append({
                "template": "logged_in",
                "params": {"actor": parsed['actor']}
            })

        return preconditions

    def _extract_actions(self, parsed):
        """Extract When steps from parsed data"""
        actions = []

        for action in parsed.get('actions', []):
            actions.append({
                "template": self._map_action_to_template(action['verb']),
                "params": self._extract_action_params(action)
            })

        return actions

    def _extract_outcomes(self, scenario):
        """Extract Then steps from scenario"""
        # Based on scenario type
        if scenario['type'] == 'positive':
            return [{
                "template": "see_message",
                "params": {
                    "message_type": "success",
                    "message": "Operation completed successfully"
                }
            }]
        elif scenario['type'] == 'negative':
            return [{
                "template": "validation_error",
                "params": {"field": "input"}
            }]
        else:
            return []

    def _map_action_to_template(self, verb):
        """Map verb to Gherkin template"""
        mapping = {
            "click": "click",
            "enter": "enter",
            "submit": "submit",
            "select": "select",
            "navigate": "navigate"
        }
        return mapping.get(verb, "default")

    def _extract_action_params(self, action):
        """Extract parameters for action step"""
        # Simplified - in production, use more sophisticated extraction
        return {
            "element": action.get('phrase', ''),
            "element_type": "button"
        }

# Usage
pipeline = NLPToGherkinPipeline()

gherkin = pipeline.convert_to_gherkin("""
As a registered user, I want to reset my password via email
so that I can regain access if I forget my credentials.

Acceptance Criteria:
- User enters email address on reset page
- System sends reset link valid for 24 hours
- New password must be minimum 8 characters with 1 uppercase and 1 number
""")

print(gherkin)

from jira import JIRA
import requests

class JiraTestIntegration:
    def __init__(self, jira_url, api_token):
        self.jira = JIRA(server=jira_url, token_auth=api_token)
        self.nlp_pipeline = NLPToGherkinPipeline()

    def process_user_story(self, issue_key):
        """Process Jira user story and create test cases"""

        # Fetch user story from Jira
        issue = self.jira.issue(issue_key)

        user_story = {
            "title": issue.fields.summary,
            "description": issue.fields.description,
            "acceptance_criteria": self._extract_acceptance_criteria(issue)
        }

        # Generate test scenarios using NLP
        full_text = f"{user_story['description']}\n\n{user_story['acceptance_criteria']}"
        scenarios = self.nlp_pipeline.convert_to_gherkin(full_text)

        # Create test cases in Jira (using X-Ray or Zephyr)
        test_cases = self._create_test_cases(issue_key, scenarios)

        # Link tests to user story
        self._link_tests_to_story(issue_key, test_cases)

        return test_cases

    def _extract_acceptance_criteria(self, issue):
        """Extract acceptance criteria from Jira issue"""
        # Check custom field or parse from description
        ac_field = getattr(issue.fields, 'customfield_10100', None)
        if ac_field:
            return ac_field

        # Parse from description if using "AC:" marker
        description = issue.fields.description or ""
        if "Acceptance Criteria:" in description:
            parts = description.split("Acceptance Criteria:")
            return parts[1] if len(parts) > 1 else ""

        return ""

    def _create_test_cases(self, story_key, gherkin_scenarios):
        """Create test cases in Jira X-Ray"""
        test_cases = []

        # Parse Gherkin to extract scenarios
        scenarios = self._parse_gherkin(gherkin_scenarios)

        for scenario in scenarios:
            # Create test issue
            test_issue = self.jira.create_issue(
                project='TEST',
                summary=f"Test: {scenario['name']}",
                description=self._format_test_description(scenario),
                issuetype={'name': 'Test'},
                customfield_10200=scenario['gherkin']  # Gherkin field in X-Ray
            )

            test_cases.append(test_issue.key)

        return test_cases

    def _link_tests_to_story(self, story_key, test_keys):
        """Create 'Tests' links from user story to test cases"""
        for test_key in test_keys:
            self.jira.create_issue_link(
                type="Tests",
                inwardIssue=test_key,
                outwardIssue=story_key
            )

    def _parse_gherkin(self, gherkin_text):
        """Parse Gherkin text into scenarios"""
        scenarios = []
        current_scenario = None

        for line in gherkin_text.split('\n'):
            line = line.strip()

            if line.startswith('Scenario:'):
                if current_scenario:
                    scenarios.append(current_scenario)
                current_scenario = {
                    "name": line.replace('Scenario:', '').strip(),
                    "steps": [],
                    "gherkin": ""
                }
            elif current_scenario and line:
                current_scenario['steps'].append(line)
                current_scenario['gherkin'] += line + '\n'

        if current_scenario:
            scenarios.append(current_scenario)

        return scenarios

    def _format_test_description(self, scenario):
        """Format scenario as test description"""
        description = f"**Test Scenario**: {scenario['name']}\n\n"
        description += "**Steps**:\n"
        for step in scenario['steps']:
            description += f"- {step}\n"
        return description

# Usage
integration = JiraTestIntegration(
    jira_url='https://yourcompany.atlassian.net',
    api_token='your_api_token'
)

# Process user story and auto-generate tests
test_cases = integration.process_user_story('PROJ-123')
print(f"Created {len(test_cases)} test cases: {test_cases}")

# Output:
# Created 5 test cases: ['TEST-456', 'TEST-457', 'TEST-458', 'TEST-459', 'TEST-460']

import requests

class TestRailIntegration:
    def __init__(self, base_url, username, api_key):
        self.base_url = base_url
        self.auth = (username, api_key)
        self.headers = {'Content-Type': 'application/json'}

    def create_test_cases_from_gherkin(self, project_id, suite_id, gherkin_text):
        """Create test cases in TestRail from Gherkin scenarios"""

        scenarios = self._parse_gherkin(gherkin_text)
        test_case_ids = []

        for scenario in scenarios:
            # Create test case
            case_data = {
                'title': scenario['name'],
                'template_id': 2,  # Test Case (Steps) template
                'type_id': 1,  # Automated
                'priority_id': 2,  # Medium
                'custom_steps_separated': self._convert_to_testrail_steps(
                    scenario['steps']
                )
            }

            response = requests.post(
                f"{self.base_url}/index.php?/api/v2/add_case/{suite_id}",
                auth=self.auth,
                headers=self.headers,
                json=case_data
            )

            if response.status_code == 200:
                test_case_ids.append(response.json()['id'])

        return test_case_ids

    def _convert_to_testrail_steps(self, gherkin_steps):
        """Convert Gherkin steps to TestRail step format"""
        steps = []

        for step in gherkin_steps:
            if step.startswith('Given') or step.startswith('When'):
                steps.append({
                    'content': step,
                    'expected': ''
                })
            elif step.startswith('Then'):
                if steps:
                    steps[-1]['expected'] = step.replace('Then ', '')
                else:
                    steps.append({
                        'content': '',
                        'expected': step.replace('Then ', '')
                    })

        return steps

# Usage
testrail = TestRailIntegration(
    base_url='https://yourcompany.testrail.io',
    username='user@example.com',
    api_key='your_api_key'
)

case_ids = testrail.create_test_cases_from_gherkin(
    project_id=1,
    suite_id=10,
    gherkin_text=generated_gherkin
)

# Use GPT-4 for scenario generation without training
import openai

def generate_scenarios_gpt4(user_story):
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{
            "role": "system",
            "content": "You are a QA expert. Generate comprehensive test scenarios from user stories in Gherkin format."
        }, {
            "role": "user",
            "content": f"Generate test scenarios for:\n{user_story}"
        }],
        temperature=0.3
    )
    return response.choices[0].message.content