Abstract

This implementation is an attempt to demonstrate use of AI to help automate Quality Assurance (QA) testing. This is a system that uses Groq API, LangChain, and Streamlit to automatically create test cases from requirements documents. The system has three AI agents: one summarizes requirements documents, another creates test scenarios in Gherkin format, and a third generates executable Selenium test code. This automation helps QA teams work faster and more consistently, allowing them to focus on more important tasks instead of writing test cases manually, like, validating AI-generated tests and developing testing strategies.

Methodology

The foundation of our system is a function that interfaces with the Groq API:

def simple_AI_Function_Agent(prompt, model="llama-3.3-70b-versatile"):
    try:
        client = Groq(
            api_key=os.getenv("GROQ_API_KEY")
        )
        chat_completion = client.chat.completions.create(
            messages=[
                {
                    "role": "user",
                    "content": prompt,
                }
            ],
            model=model,
        )
        response = chat_completion.choices[0].message.content
        return response
    except Exception as e:
        return f"An unexpected error occurred: {e}"

This function serves as the communication channel between our application and the LLM, allowing us to leverage powerful language models for specialized QA tasks.

Workflow Orchestrator

The main function that ties our agents together is convert_requirements_to_testcases():

def convert_requirements_to_testcases(requirements_doc, 
                                     workflow_type="Complete Workflow (Summary → Gherkin → Selenium)",
                                     model="llama-3.3-70b-versatile"):
    # Complete workflow logic
    prompt = "Generate a concise, point-wise summary of the following requirements document: \n\n" + requirements_doc
    summary = simple_AI_Function_Agent(prompt, model)
    
    prompt = "Create comprehensive testcases in Gherkin format using this summary: \n\n" + summary
    gherkin_testcases = simple_AI_Function_Agent(prompt, model)
    
    prompt = "Create Selenium testcases in Python for each scenario: \n\n" + gherkin_testcases
    selenium_testcases = simple_AI_Function_Agent(prompt, model)
    
    result = f"## Summary\n\n{summary}\n\n## Gherkin Testcases\n\n{gherkin_testcases}\n\n## Selenium Testcases\n\n{selenium_testcases}"
    
    return result

This orchestrator function handles different workflow configurations, allowing users to generate just summaries, only Gherkin test cases, only Selenium scripts, or the complete end-to-end process.

User Interface with Streamlit

The Streamlit-based UI makes this technology accessible to QA professionals without requiring programming knowledge:

# Main window
generate_button = st.button("Generate Testcases")

if generate_button and requirements_docs_content:
    with st.chat_message("assistant"):
        with st.spinner("Processing requirements..."):
            workflow = st.session_state.selected_workflow
            model = st.session_state.selected_model
            # Call the function
            result = convert_requirements_to_testcases(
                requirements_docs_content,
                workflow_type=workflow,
                model=model
            )
            st.markdown(result)

The UI allows users to:

** Upload requirements documents in various formats (TXT, PDF, DOCX)
** Select from different AI models based on their needs
** Choose specific workflow steps to execute
** View and save the generated outputs

Benefits of This Approach

1. Speed: What might take hours or days manually can be accomplished in minutes
2. Consistency: The AI applies the same level of attention to every requirement
3. Adaptability: The system can process various document formats and handle different types of requirements
4. Scalability: As requirements grow, the system scales without additional human resources
5. Model flexibility: Users can select from various LLMs based on their specific needs

Results

As we look toward the future, it’s clear that AI will continue to transform the QA landscape. However, this doesn’t mean human QA professionals will become obsolete. Instead, their roles will evolve to focus more on:

1. Validating and refining AI-generated test cases
2. Developing more sophisticated testing strategies
3. Focusing on exploratory testing and edge cases
4. Interpreting test results and making quality recommendations

The combination of human expertise and AI automation represents the most promising path forward for software quality assurance. By offloading routine test case creation to AI agents, QA teams can elevate their focus to higher-value activities that truly require human judgment and creativity.

As we embrace these technologies, the question becomes not whether AI will change QA practices, but how quickly teams will adapt to harness its full potential. Those who successfully integrate AI agents into their workflows will gain a significant competitive advantage in delivering higher quality software more efficiently than ever before.

Github Repository Path