An introduction to Test-First Behavior-Driven Development, and acceptance testing with Gherkin, with some real-life Gherkin examples. Content created for C# code, but the principles do apply to other languages/environments.
This presentation introduces the principles of high-quality programming code construction during the software development process. The quality of the code is discussed in its most important characteristics – correctness, readability and maintainability. The principles of construction of high-quality class hierarchies, classes and methods are explained. Two fundamental concepts – “loose coupling” and “strong cohesion” are defined and their effect on the construction of classes and subroutines is discussed. Some advices for correctly dealing with the variables and data are given, as well as directions for correct naming of the variables and the rest elements of the program. Best practices for organization of the logical programming constructs are explained. Attention is given also to the “refactoring” as a technique for improving the quality of the existing code. The principles of good formatting of the code are defined and explained. The concept of “self-documenting code” as a programming style is introduced.
Presentation I gave at the Houston TechFest Sept 2009. This presentation goes over Extension Methods, Lambdas, Expression Trees, and Fluent Interfaces. I also show examples from popular frameworks using these techniques.
The document discusses refactoring as a process of improving code quality without changing external behavior. It is not about adding features or fixing bugs, but improving code structure and design to make it easier to maintain and change. Refactoring aims to improve code readability, efficiency, and flexibility by techniques like simplifying conditionals, extracting methods, and reducing dependencies between code elements. The impact of changes must be minimized by refactoring private elements before public ones. Tests are crucial to ensure refactoring does not introduce errors. Code is refactored when it shows signs of deterioration like duplication, overcomplexity, or tight coupling between modules.
This document discusses system design and decomposing systems into subsystems. It makes three key points:
1) System design is difficult because the solution domain is changing rapidly and design knowledge has a short half-life of 3-5 years. This makes the design window challenging.
2) To bridge the gap between a problem and existing system, the document recommends using the "divide and conquer" approach of identifying major design goals and modeling the system as a set of subsystems that address these goals.
3) Good subsystem design principles include having high coherence (related classes) and low coupling (independence) between subsystems. This can be achieved by minimizing inter-subsystem interactions and calls and ensuring subsystems
This document discusses using domain-specific languages (DSLs) for test automation. It defines DSLs as programming languages focused on a particular domain, like SQL or CSS. For testing, a DSL can be used to define test cases in a readable way. The example shows implementing a Python-based internal DSL to test a unique report. Test cases are defined via method chaining, like test.user('a').view('asset'), avoiding copying lots of test data each time. DSLs can improve test coverage by making test definition and maintenance easier.
The document discusses the process of mapping object models to code. It describes four types of transformations: model transformation, forward engineering, reverse engineering, and refactoring. Model transformations optimize the object design model, such as collapsing objects or delaying expensive computations. Forward engineering implements the object design model in a programming language by mapping inheritance, associations, contracts, and object models to tables. The document provides examples of each type of transformation.
Dev labs alliance top 20 basic java interview questions for sdetDevLabs Alliance
The document provides 20 basic Java interview questions for software development engineers. It covers topics like access specifiers, object-oriented programming principles, the differences between inner classes and subclasses, final keyword usage, abstract classes vs interfaces, local vs instance variables, constructor types, exception handling, threads, method overloading and overriding, collections, and checked vs unchecked exceptions.
DevLabs Alliance Top 20 Software Testing Interview Questions for SDET - by De...DevLabs Alliance
The document provides an overview of 20 common interview questions for software development engineers in test (SDETs). It defines key terms like SDET, test plan, test case, test scenario, and discusses differences between related areas like quality assurance and quality control, and verification and validation. Sample questions cover topics like test life cycle phases, test case vs test scenario, types of testing like alpha and beta testing, and defect management.
This presentation introduces the principles of high-quality programming code construction during the software development process. The quality of the code is discussed in its most important characteristics – correctness, readability and maintainability. The principles of construction of high-quality class hierarchies, classes and methods are explained. Two fundamental concepts – “loose coupling” and “strong cohesion” are defined and their effect on the construction of classes and subroutines is discussed. Some advices for correctly dealing with the variables and data are given, as well as directions for correct naming of the variables and the rest elements of the program. Best practices for organization of the logical programming constructs are explained. Attention is given also to the “refactoring” as a technique for improving the quality of the existing code. The principles of good formatting of the code are defined and explained. The concept of “self-documenting code” as a programming style is introduced.
Presentation I gave at the Houston TechFest Sept 2009. This presentation goes over Extension Methods, Lambdas, Expression Trees, and Fluent Interfaces. I also show examples from popular frameworks using these techniques.
The document discusses refactoring as a process of improving code quality without changing external behavior. It is not about adding features or fixing bugs, but improving code structure and design to make it easier to maintain and change. Refactoring aims to improve code readability, efficiency, and flexibility by techniques like simplifying conditionals, extracting methods, and reducing dependencies between code elements. The impact of changes must be minimized by refactoring private elements before public ones. Tests are crucial to ensure refactoring does not introduce errors. Code is refactored when it shows signs of deterioration like duplication, overcomplexity, or tight coupling between modules.
This document discusses system design and decomposing systems into subsystems. It makes three key points:
1) System design is difficult because the solution domain is changing rapidly and design knowledge has a short half-life of 3-5 years. This makes the design window challenging.
2) To bridge the gap between a problem and existing system, the document recommends using the "divide and conquer" approach of identifying major design goals and modeling the system as a set of subsystems that address these goals.
3) Good subsystem design principles include having high coherence (related classes) and low coupling (independence) between subsystems. This can be achieved by minimizing inter-subsystem interactions and calls and ensuring subsystems
This document discusses using domain-specific languages (DSLs) for test automation. It defines DSLs as programming languages focused on a particular domain, like SQL or CSS. For testing, a DSL can be used to define test cases in a readable way. The example shows implementing a Python-based internal DSL to test a unique report. Test cases are defined via method chaining, like test.user('a').view('asset'), avoiding copying lots of test data each time. DSLs can improve test coverage by making test definition and maintenance easier.
The document discusses the process of mapping object models to code. It describes four types of transformations: model transformation, forward engineering, reverse engineering, and refactoring. Model transformations optimize the object design model, such as collapsing objects or delaying expensive computations. Forward engineering implements the object design model in a programming language by mapping inheritance, associations, contracts, and object models to tables. The document provides examples of each type of transformation.
Dev labs alliance top 20 basic java interview questions for sdetDevLabs Alliance
The document provides 20 basic Java interview questions for software development engineers. It covers topics like access specifiers, object-oriented programming principles, the differences between inner classes and subclasses, final keyword usage, abstract classes vs interfaces, local vs instance variables, constructor types, exception handling, threads, method overloading and overriding, collections, and checked vs unchecked exceptions.
DevLabs Alliance Top 20 Software Testing Interview Questions for SDET - by De...DevLabs Alliance
The document provides an overview of 20 common interview questions for software development engineers in test (SDETs). It defines key terms like SDET, test plan, test case, test scenario, and discusses differences between related areas like quality assurance and quality control, and verification and validation. Sample questions cover topics like test life cycle phases, test case vs test scenario, types of testing like alpha and beta testing, and defect management.
Feedback on Part 1 of the Software Engineering Large PracticalStephen Gilmore
This document summarizes feedback from the first part of a software engineering practical project. It discusses issues seen in student submissions, such as Java syntax errors, incomplete functionality, and problems with XML documents. It also provides examples of user interfaces and additional features students have implemented. The document encourages students to pay careful attention to instructions, use logging for development, and notes changes to the sample data file.
The document provides feedback on Part 1 of a computer science practical. It summarizes submissions for Part 1, including operating systems used. It addresses some common problems and uncertainties students had, such as compilation errors, unfamiliar aspects of Objective-C, and error messages. It also provides clarification on issues like imports, method implementations, and pointer conversions.
This document discusses the importance of clean code and naming conventions. It argues that naming everything properly, including namespaces, classes, functions and variables, is crucial because people will read code far more than they write it. Descriptive names communicate intent and enable code to be understood without comments. Common naming issues like 'Util' classes and generic names are addressed. The document emphasizes that functions should be named for what they do, with boolean functions starting with 'has' or 'is'. Setters should not return anything other than the object or null.
The document discusses software testing, including definitions of key terms like failure, error, and fault. It covers different types of testing like unit testing, integration testing, and acceptance testing. It also discusses techniques for fault avoidance, detection, and tolerance. Black-box and white-box testing approaches are explained. Finally, it provides an overview of the JUnit testing framework in Java.
Software Craftsmanship emphasizes not just working software but well-crafted software, steadily adding value through change. Code smells are indicators that code may need refactoring to improve design. Common code smells include lost intent where code purpose is unclear, duplicated code, long methods, large classes, and primitive obsession where code is too simplistic. Refactoring helps reduce technical debt by improving code design without changing functionality.
This document discusses test-driven development (TDD) and behavior-driven development (BDD). It defines TDD as a process of writing automated tests before code to define desired functionality, then writing minimum code to pass tests and refactoring. BDD combines TDD techniques with domain-driven design and focuses on user stories over functions to promote communication. The document provides an example of using BDD to generate scenarios for a life insurance risk example, and shows how TestBox can be used to write automated tests based on those scenarios.
This document is from a computer science practical session on arrays in Objective-C. It discusses creating and initializing arrays, sorting arrays, handling memory management of arrays, and using mutable arrays. The document provides code examples for creating arrays, adding and retrieving elements, sorting arrays, and updating mutable arrays. It also discusses best practices for memory management when using arrays.
1. Object modeling is a key activity in analysis that involves identifying important classes, attributes, methods, and associations from use cases and domain knowledge.
2. Class identification can be done through syntactic analysis of use cases using techniques like Abbott's method of mapping parts of speech to model elements.
3. Different roles like analysts, designers, and implementors have varying needs from class diagrams depending on the development phase and tasks. The level of detail needed increases from analysis to implementation.
Refactoring: Improve the design of existing codeValerio Maggio
Refactoring: Improve the design of existing code
Software Engineering class on main refactoring techniques and bad smells reported in the famous Fawler's book on this topic!
This document introduces refactoring as a way to improve the design of existing code while preserving its observable behavior. It discusses how refactoring can make code more robust, simple and flexible by addressing issues like fragility, complexity and rigidity. The refactoring process involves choosing a code smell to address, selecting a refactoring technique, applying the change, and verifying with tests. Applying refactoring in small steps can yield great results in making code easier to understand and cheaper to modify. Recommended books and online resources on refactoring techniques are also provided.
Book review: Working Effectively with Legacy Code, by Michael C. Feathers
Agenda
- The mechanics of change
- Changing software
- Dependency breaking techniques
This session is for developers who need to work on code projects that where written without good unit-testing.
The document provides an overview of the GoF design patterns including the types (creational, structural, behavioral), examples of common patterns like factory, abstract factory, singleton, adapter, facade, iterator, observer, and strategy, and UML diagrams illustrating how the patterns can be implemented. Key aspects of each pattern like intent, relationships, pros and cons are discussed at a high level. The document is intended to introduce software engineers to design patterns and how they can be applied.
The document discusses strategies for working with legacy code, which is code inherited from previous developers or older versions that often lacks tests and good documentation. It defines legacy code and outlines challenges like poor structure, dependencies, and lack of tests. It then provides approaches for modifying legacy code like identifying what to change and test, breaking dependencies, writing tests, and refactoring code in small, tested increments. Specific tactics are presented like using seams, sprouting methods, and interfaces to break dependencies and allow testing legacy code. The importance of understanding the system and increasing test coverage before making changes is emphasized.
1. The document discusses the code review process and provides guidance on how to effectively conduct code reviews. It suggests reviewing code from a top-down perspective, starting with high-level architecture and design before examining lower-level implementation details.
2. Key aspects that should be reviewed include problem solution, public APIs, database schema, object-oriented design, method signatures, classes and methods, views, test coverage, and code style. Areas like performance, security, and vulnerabilities should also be evaluated.
3. An effective code review process establishes a review culture that is polite, acknowledges good work, and saves reviewers' and authors' time.
The document discusses test-driven development (TDD) and behavior-driven development (BDD). It clarifies that TDD is a design activity, not just about testing, and explains the benefits of TDD such as reducing speculative code and improving quality. It then covers BDD concepts like outside-in development, interaction-based testing, and using mock objects. The document provides examples of testing frameworks like RSpec and practices for writing better tests and mocks.
This document provides an overview of design patterns, including their definition, origins, properties, types, and examples. It discusses common design patterns like Singleton, Observer, Strategy, Adapter, Facade, and Proxy. For each pattern, it describes the context, problem, forces, solution, and examples. The document also covers challenges of applying patterns and developing new patterns.
The document discusses design patterns and how they can be used to simplify complex object models. It introduces the composite, adapter, bridge, and facade patterns. The composite pattern models tree structures and allows components to be treated uniformly. The adapter pattern allows classes with incompatible interfaces to work together. The bridge pattern decouples an abstraction from its implementation. The facade pattern provides a simplified interface to a subsystem. Design patterns use inheritance and delegation to provide flexible, reusable solutions to common programming problems.
The document summarizes the design and implementation of a new programming language called newt. Key points include:
- newt aims to provide tight feedback loops through static typing and fast failure on semantic errors. It has succinct syntax while avoiding surprising behavior.
- The language is implemented in C++ and includes features like primitive types, arrays, records, functions, and automated testing.
- Challenges included generalizing type specifiers and making functions truly first-class. Future work includes collections, polymorphism, and syntax sugar.
This document summarizes key aspects of system design for addressing concurrency. It discusses identifying threads of control from sequence diagrams and assigning inherently concurrent objects to different threads. Race conditions that can occur with concurrent threads are explained. Examples are provided to illustrate problems that can arise and how synchronization of threads can solve them. Questions for identifying concurrency in a system are outlined. Implementing concurrency using physical or logical threads is described. Deployment and component diagrams for modeling hardware/software mapping and dependencies between system components are introduced.
Introduction to Behavior Driven Development Robin O'Brien
This document provides an introduction to Behaviour Driven Development (BDD). It discusses that BDD aims to bridge communication gaps between developers and clients by using examples written in a common language. It also provides a practical example of setting up BDD with JBehave and Java in IntelliJ IDEA, including creating a story file, steps class, and linking class. The document demonstrates how BDD allows describing desired system behaviors in a way that is understandable to both technical and non-technical stakeholders.
TDD is now mainstream but a lot people don't know or don't remember what is its purpose. TDD is about software design not testing or catching bug. TDD helps developers to shape and create software with "good" design, what is a "good" design is something that we will discuss in the topic.
Feedback on Part 1 of the Software Engineering Large PracticalStephen Gilmore
This document summarizes feedback from the first part of a software engineering practical project. It discusses issues seen in student submissions, such as Java syntax errors, incomplete functionality, and problems with XML documents. It also provides examples of user interfaces and additional features students have implemented. The document encourages students to pay careful attention to instructions, use logging for development, and notes changes to the sample data file.
The document provides feedback on Part 1 of a computer science practical. It summarizes submissions for Part 1, including operating systems used. It addresses some common problems and uncertainties students had, such as compilation errors, unfamiliar aspects of Objective-C, and error messages. It also provides clarification on issues like imports, method implementations, and pointer conversions.
This document discusses the importance of clean code and naming conventions. It argues that naming everything properly, including namespaces, classes, functions and variables, is crucial because people will read code far more than they write it. Descriptive names communicate intent and enable code to be understood without comments. Common naming issues like 'Util' classes and generic names are addressed. The document emphasizes that functions should be named for what they do, with boolean functions starting with 'has' or 'is'. Setters should not return anything other than the object or null.
The document discusses software testing, including definitions of key terms like failure, error, and fault. It covers different types of testing like unit testing, integration testing, and acceptance testing. It also discusses techniques for fault avoidance, detection, and tolerance. Black-box and white-box testing approaches are explained. Finally, it provides an overview of the JUnit testing framework in Java.
Software Craftsmanship emphasizes not just working software but well-crafted software, steadily adding value through change. Code smells are indicators that code may need refactoring to improve design. Common code smells include lost intent where code purpose is unclear, duplicated code, long methods, large classes, and primitive obsession where code is too simplistic. Refactoring helps reduce technical debt by improving code design without changing functionality.
This document discusses test-driven development (TDD) and behavior-driven development (BDD). It defines TDD as a process of writing automated tests before code to define desired functionality, then writing minimum code to pass tests and refactoring. BDD combines TDD techniques with domain-driven design and focuses on user stories over functions to promote communication. The document provides an example of using BDD to generate scenarios for a life insurance risk example, and shows how TestBox can be used to write automated tests based on those scenarios.
This document is from a computer science practical session on arrays in Objective-C. It discusses creating and initializing arrays, sorting arrays, handling memory management of arrays, and using mutable arrays. The document provides code examples for creating arrays, adding and retrieving elements, sorting arrays, and updating mutable arrays. It also discusses best practices for memory management when using arrays.
1. Object modeling is a key activity in analysis that involves identifying important classes, attributes, methods, and associations from use cases and domain knowledge.
2. Class identification can be done through syntactic analysis of use cases using techniques like Abbott's method of mapping parts of speech to model elements.
3. Different roles like analysts, designers, and implementors have varying needs from class diagrams depending on the development phase and tasks. The level of detail needed increases from analysis to implementation.
Refactoring: Improve the design of existing codeValerio Maggio
Refactoring: Improve the design of existing code
Software Engineering class on main refactoring techniques and bad smells reported in the famous Fawler's book on this topic!
This document introduces refactoring as a way to improve the design of existing code while preserving its observable behavior. It discusses how refactoring can make code more robust, simple and flexible by addressing issues like fragility, complexity and rigidity. The refactoring process involves choosing a code smell to address, selecting a refactoring technique, applying the change, and verifying with tests. Applying refactoring in small steps can yield great results in making code easier to understand and cheaper to modify. Recommended books and online resources on refactoring techniques are also provided.
Book review: Working Effectively with Legacy Code, by Michael C. Feathers
Agenda
- The mechanics of change
- Changing software
- Dependency breaking techniques
This session is for developers who need to work on code projects that where written without good unit-testing.
The document provides an overview of the GoF design patterns including the types (creational, structural, behavioral), examples of common patterns like factory, abstract factory, singleton, adapter, facade, iterator, observer, and strategy, and UML diagrams illustrating how the patterns can be implemented. Key aspects of each pattern like intent, relationships, pros and cons are discussed at a high level. The document is intended to introduce software engineers to design patterns and how they can be applied.
The document discusses strategies for working with legacy code, which is code inherited from previous developers or older versions that often lacks tests and good documentation. It defines legacy code and outlines challenges like poor structure, dependencies, and lack of tests. It then provides approaches for modifying legacy code like identifying what to change and test, breaking dependencies, writing tests, and refactoring code in small, tested increments. Specific tactics are presented like using seams, sprouting methods, and interfaces to break dependencies and allow testing legacy code. The importance of understanding the system and increasing test coverage before making changes is emphasized.
1. The document discusses the code review process and provides guidance on how to effectively conduct code reviews. It suggests reviewing code from a top-down perspective, starting with high-level architecture and design before examining lower-level implementation details.
2. Key aspects that should be reviewed include problem solution, public APIs, database schema, object-oriented design, method signatures, classes and methods, views, test coverage, and code style. Areas like performance, security, and vulnerabilities should also be evaluated.
3. An effective code review process establishes a review culture that is polite, acknowledges good work, and saves reviewers' and authors' time.
The document discusses test-driven development (TDD) and behavior-driven development (BDD). It clarifies that TDD is a design activity, not just about testing, and explains the benefits of TDD such as reducing speculative code and improving quality. It then covers BDD concepts like outside-in development, interaction-based testing, and using mock objects. The document provides examples of testing frameworks like RSpec and practices for writing better tests and mocks.
This document provides an overview of design patterns, including their definition, origins, properties, types, and examples. It discusses common design patterns like Singleton, Observer, Strategy, Adapter, Facade, and Proxy. For each pattern, it describes the context, problem, forces, solution, and examples. The document also covers challenges of applying patterns and developing new patterns.
The document discusses design patterns and how they can be used to simplify complex object models. It introduces the composite, adapter, bridge, and facade patterns. The composite pattern models tree structures and allows components to be treated uniformly. The adapter pattern allows classes with incompatible interfaces to work together. The bridge pattern decouples an abstraction from its implementation. The facade pattern provides a simplified interface to a subsystem. Design patterns use inheritance and delegation to provide flexible, reusable solutions to common programming problems.
The document summarizes the design and implementation of a new programming language called newt. Key points include:
- newt aims to provide tight feedback loops through static typing and fast failure on semantic errors. It has succinct syntax while avoiding surprising behavior.
- The language is implemented in C++ and includes features like primitive types, arrays, records, functions, and automated testing.
- Challenges included generalizing type specifiers and making functions truly first-class. Future work includes collections, polymorphism, and syntax sugar.
This document summarizes key aspects of system design for addressing concurrency. It discusses identifying threads of control from sequence diagrams and assigning inherently concurrent objects to different threads. Race conditions that can occur with concurrent threads are explained. Examples are provided to illustrate problems that can arise and how synchronization of threads can solve them. Questions for identifying concurrency in a system are outlined. Implementing concurrency using physical or logical threads is described. Deployment and component diagrams for modeling hardware/software mapping and dependencies between system components are introduced.
Introduction to Behavior Driven Development Robin O'Brien
This document provides an introduction to Behaviour Driven Development (BDD). It discusses that BDD aims to bridge communication gaps between developers and clients by using examples written in a common language. It also provides a practical example of setting up BDD with JBehave and Java in IntelliJ IDEA, including creating a story file, steps class, and linking class. The document demonstrates how BDD allows describing desired system behaviors in a way that is understandable to both technical and non-technical stakeholders.
TDD is now mainstream but a lot people don't know or don't remember what is its purpose. TDD is about software design not testing or catching bug. TDD helps developers to shape and create software with "good" design, what is a "good" design is something that we will discuss in the topic.
This document discusses ways to raise the bar of software development by combining it with other disciplines. It proposes 6 intersections between software design and other fields: 1) Software Design and UX, 2) Other design disciplines, 3) Materials Science, 4) Math, 5) Engineering principles of built-in self-testing, and 6) Reaching out to scientists. It argues that considering ideas from other domains could improve software design and help address challenges like dependencies in legacy code. The document also suggests ways to fundamentally change development by precisely defining requirements and generating code from them.
The document discusses the BCC Software Test Engineer Certification Program. It provides an overview of the program, including required courses that cover topics like introduction to testing, scripting, database testing, and test automation. It emphasizes building a solid foundation in software testing fundamentals before taking advanced classes. The certification can be completed in a quarter but most students take longer. The program aims to provide students with skills that are in high demand at local companies.
Transferring Software Testing Tools to PracticeTao Xie
ACM SIGSOFT Webinar co-presented by Nikolai Tillmann (Microsoft), Judith Bishop (Microsoft Research), Pratap Lakshman (Microsoft), Tao Xie (University of Illinois at Urbana-Champaign) http://www.sigsoft.org/resources/webinars.html
Lightening Talk I gave at Inaka in April 2014.
I was in charge of investigating test-driven development for our iOS mobile team. Since I realized it was such a big concept, after having gathered enough information and having played with it enough, I decided to introduce my fellows on the topic by presenting it in a formal talk with slides. The aim was teaching them a different way of developing, which, for us, at that moment, was completely new and controversial.
Test-Driven Developments are Inefficient; Behavior-Driven Developments are a ...Abdelkrim Boujraf
The document discusses the authors' experience with different testing strategies at their company StratEx. They initially used Selenium for UI testing but found it did not help when they frequently changed screens. They then investigated Test-Driven Development (TDD) but found it inefficient, as tests are also code that must be written and maintained. Behavior-Driven Development (BDD) showed more promise as it focuses on functionality rather than architecture and bridges communication between users and developers. However, no methodology fully describes large, complex systems. The search for the best testing approach is ongoing.
This document provides sample interview questions and answers for a QA (Quality Assurance) job. It discusses common questions asked about a candidate's experience, their work on past projects like writing test plans and test cases, knowledge of software development processes, and technical testing terms. The document emphasizes practicing answers aloud to feel comfortable during an interview.
Алексей Ященко и Ярослав Волощук "False simplicity of front-end applications"Fwdays
It’s easy to underestimate a front-end project's complexity, which leads to shallow and thus incorrect implementation. Attempts to fix this problem result in uncontrolled complexity growth and undefined behavior in corner cases.
We'll discuss ways of revealing the inherent complexity of a problem and dealing with it both on theoretical and practical levels.
Code review is an inspection process where developers examine code samples to identify and fix defects. It helps ensure good code quality by allowing experienced developers to share knowledge with less experienced ones. Benefits include more stable products with fewer bugs due to improved code structure, standards and focus on new features rather than fixing issues. Issues that can arise include developers not following through on review comments, lack of buy-in, unrealistic expectations and peer fear. Various review types and tools can help address these issues.
This document provides 5 insights to revolutionize software testing: 1) There are two types of code (experience and infrastructure) that require different testing approaches; 2) Testing should focus on capabilities rather than features; 3) Focus on testing techniques rather than individual test cases; 4) Testing should improve development rather than just find bugs; 5) Testing needs innovation to engage talent and avoid repetitive work. The author advocates shifting testing strategy to higher levels of abstraction and partnering with development to build quality in from the start.
1) The document discusses the software development method which includes 6 key phases: requirement gathering, system analysis, system design, coding, testing, and deployment.
2) It provides details on each phase, including requirement gathering and analysis to define requirements, system analysis to divide the system into modules, system design to design the software architecture, coding to develop the software, testing to identify bugs, and deployment to launch the software.
3) It also discusses related topics like problem analysis, pseudocode, algorithms, and flowcharts which are techniques used during the software development process.
This document discusses Behavior Driven Development (BDD) using Cucumber for Java. It explains that BDD combines test-driven development, domain-driven design, and use of a common language to specify functionality in a way that is readable to both technical and non-technical stakeholders. Cucumber allows writing specifications in a Given/When/Then format that can be parsed and executed as tests. It provides an example specification and Java code to implement it. Benefits of the BDD approach include improved communication, reduced rework, and better maintained regression tests.
This document discusses Behavior Driven Development (BDD) using Cucumber for Java. It explains that BDD combines test-driven development, domain-driven design, and other good practices to develop software using a common language that is readable to both business and technical stakeholders. Cucumber allows writing automated tests in a format of Given-When-Then scenarios that can be parsed and executed to verify the system behaves as specified. The document provides an example scenario written in the Cucumber format and demonstrates how to write Java code to implement the steps and make the test pass.
This document discusses Behavior Driven Development (BDD) using Cucumber for Java. It explains that BDD combines test-driven development, domain-driven design, and use of a common language to specify functionality in a way that is readable to both technical and non-technical stakeholders. Cucumber allows writing specifications in a Given/When/Then format that can be parsed and executed as tests. Steps are defined in code to implement the specifications. This allows automated testing of functionality based on business-readable specifications.
This document discusses Behavior Driven Development (BDD) using Cucumber for Java. It explains that BDD combines test-driven development, domain-driven design, and use of a common language to specify functionality in a way that is readable to both technical and non-technical stakeholders. Cucumber allows writing specifications in a Given/When/Then format that can be parsed and executed as tests. It provides an example specification and Java code to implement it. Benefits of the BDD approach include improved communication, reduced rework, and better maintained regression tests.
This document discusses Behavior Driven Development (BDD) using Cucumber for Java. It explains that BDD combines test-driven development, domain-driven design, and use of a common language to specify functionality in a way that is readable to both technical and non-technical stakeholders. Cucumber allows writing specifications in a Given/When/Then format that can be parsed and executed as tests. It provides an example specification and Java code to implement it. Benefits of the BDD approach include improved communication, reduced rework, and better maintained regression tests.
This document discusses Behavior Driven Development (BDD) using Cucumber for Java. It explains that BDD combines test-driven development, domain-driven design, and other good practices to develop software using a common language that is readable to both business and technical stakeholders. Cucumber allows writing automated tests in a format of Given-When-Then scenarios that can be parsed and executed to verify the system behaves as specified. The document provides an example scenario written in the Cucumber format and demonstrates how to write Java code to implement the steps and make the test pass.
This document discusses Behavior Driven Development (BDD) using Cucumber for Java. It explains that BDD combines test-driven development, domain-driven design, and use of a common language to specify functionality in a way that is readable to both technical and non-technical stakeholders. Cucumber allows writing specifications in a Given/When/Then format that can be parsed and executed as tests. It provides an example specification and Java code to implement it. Benefits of the BDD approach include improved communication, reduced rework, and better maintained regression tests.
Introduction of Cybersecurity with OSS at Code Europe 2024Hiroshi SHIBATA
I develop the Ruby programming language, RubyGems, and Bundler, which are package managers for Ruby. Today, I will introduce how to enhance the security of your application using open-source software (OSS) examples from Ruby and RubyGems.
The first topic is CVE (Common Vulnerabilities and Exposures). I have published CVEs many times. But what exactly is a CVE? I'll provide a basic understanding of CVEs and explain how to detect and handle vulnerabilities in OSS.
Next, let's discuss package managers. Package managers play a critical role in the OSS ecosystem. I'll explain how to manage library dependencies in your application.
I'll share insights into how the Ruby and RubyGems core team works to keep our ecosystem safe. By the end of this talk, you'll have a better understanding of how to safeguard your code.
HCL Notes and Domino License Cost Reduction in the World of DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
Best 20 SEO Techniques To Improve Website Visibility In SERPPixlogix Infotech
Boost your website's visibility with proven SEO techniques! Our latest blog dives into essential strategies to enhance your online presence, increase traffic, and rank higher on search engines. From keyword optimization to quality content creation, learn how to make your site stand out in the crowded digital landscape. Discover actionable tips and expert insights to elevate your SEO game.
Skybuffer AI: Advanced Conversational and Generative AI Solution on SAP Busin...Tatiana Kojar
Skybuffer AI, built on the robust SAP Business Technology Platform (SAP BTP), is the latest and most advanced version of our AI development, reaffirming our commitment to delivering top-tier AI solutions. Skybuffer AI harnesses all the innovative capabilities of the SAP BTP in the AI domain, from Conversational AI to cutting-edge Generative AI and Retrieval-Augmented Generation (RAG). It also helps SAP customers safeguard their investments into SAP Conversational AI and ensure a seamless, one-click transition to SAP Business AI.
With Skybuffer AI, various AI models can be integrated into a single communication channel such as Microsoft Teams. This integration empowers business users with insights drawn from SAP backend systems, enterprise documents, and the expansive knowledge of Generative AI. And the best part of it is that it is all managed through our intuitive no-code Action Server interface, requiring no extensive coding knowledge and making the advanced AI accessible to more users.
Have you ever been confused by the myriad of choices offered by AWS for hosting a website or an API?
Lambda, Elastic Beanstalk, Lightsail, Amplify, S3 (and more!) can each host websites + APIs. But which one should we choose?
Which one is cheapest? Which one is fastest? Which one will scale to meet our needs?
Join me in this session as we dive into each AWS hosting service to determine which one is best for your scenario and explain why!
GraphRAG for Life Science to increase LLM accuracyTomaz Bratanic
GraphRAG for life science domain, where you retriever information from biomedical knowledge graphs using LLMs to increase the accuracy and performance of generated answers
Driving Business Innovation: Latest Generative AI Advancements & Success StorySafe Software
Are you ready to revolutionize how you handle data? Join us for a webinar where we’ll bring you up to speed with the latest advancements in Generative AI technology and discover how leveraging FME with tools from giants like Google Gemini, Amazon, and Microsoft OpenAI can supercharge your workflow efficiency.
During the hour, we’ll take you through:
Guest Speaker Segment with Hannah Barrington: Dive into the world of dynamic real estate marketing with Hannah, the Marketing Manager at Workspace Group. Hear firsthand how their team generates engaging descriptions for thousands of office units by integrating diverse data sources—from PDF floorplans to web pages—using FME transformers, like OpenAIVisionConnector and AnthropicVisionConnector. This use case will show you how GenAI can streamline content creation for marketing across the board.
Ollama Use Case: Learn how Scenario Specialist Dmitri Bagh has utilized Ollama within FME to input data, create custom models, and enhance security protocols. This segment will include demos to illustrate the full capabilities of FME in AI-driven processes.
Custom AI Models: Discover how to leverage FME to build personalized AI models using your data. Whether it’s populating a model with local data for added security or integrating public AI tools, find out how FME facilitates a versatile and secure approach to AI.
We’ll wrap up with a live Q&A session where you can engage with our experts on your specific use cases, and learn more about optimizing your data workflows with AI.
This webinar is ideal for professionals seeking to harness the power of AI within their data management systems while ensuring high levels of customization and security. Whether you're a novice or an expert, gain actionable insights and strategies to elevate your data processes. Join us to see how FME and AI can revolutionize how you work with data!
This presentation provides valuable insights into effective cost-saving techniques on AWS. Learn how to optimize your AWS resources by rightsizing, increasing elasticity, picking the right storage class, and choosing the best pricing model. Additionally, discover essential governance mechanisms to ensure continuous cost efficiency. Whether you are new to AWS or an experienced user, this presentation provides clear and practical tips to help you reduce your cloud costs and get the most out of your budget.
Programming Foundation Models with DSPy - Meetup SlidesZilliz
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
Monitoring and Managing Anomaly Detection on OpenShift.pdfTosin Akinosho
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
A Comprehensive Guide to DeFi Development Services in 2024Intelisync
DeFi represents a paradigm shift in the financial industry. Instead of relying on traditional, centralized institutions like banks, DeFi leverages blockchain technology to create a decentralized network of financial services. This means that financial transactions can occur directly between parties, without intermediaries, using smart contracts on platforms like Ethereum.
In 2024, we are witnessing an explosion of new DeFi projects and protocols, each pushing the boundaries of what’s possible in finance.
In summary, DeFi in 2024 is not just a trend; it’s a revolution that democratizes finance, enhances security and transparency, and fosters continuous innovation. As we proceed through this presentation, we'll explore the various components and services of DeFi in detail, shedding light on how they are transforming the financial landscape.
At Intelisync, we specialize in providing comprehensive DeFi development services tailored to meet the unique needs of our clients. From smart contract development to dApp creation and security audits, we ensure that your DeFi project is built with innovation, security, and scalability in mind. Trust Intelisync to guide you through the intricate landscape of decentralized finance and unlock the full potential of blockchain technology.
Ready to take your DeFi project to the next level? Partner with Intelisync for expert DeFi development services today!
Your One-Stop Shop for Python Success: Top 10 US Python Development Providersakankshawande
Simplify your search for a reliable Python development partner! This list presents the top 10 trusted US providers offering comprehensive Python development services, ensuring your project's success from conception to completion.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
How to Interpret Trends in the Kalyan Rajdhani Mix Chart.pdfChart Kalyan
A Mix Chart displays historical data of numbers in a graphical or tabular form. The Kalyan Rajdhani Mix Chart specifically shows the results of a sequence of numbers over different periods.
3. “
”
BDD is a second-generation, outside-in, pull-based, multiple-
stakeholder, multiple-scale, high-automation, agile methodology. It
describes a cycle of interactions with well-defined outputs, resulting
in the delivery of working, tested software that matters.
Dan North at the 2009 Agile specifications, BDD and Testing eXchange
Ah, okay, now I understand it all.
11. How does a unit test look like?
• The AAA of unit tests:
• Setup
• Three stages:
• Arrange: do the necessary setup for the test, set prerequisites
• Act: do the actual testing
• Assert: verify the returned result
• Teardown
12. Unit Test Doubts
• When to test?
• Test First
• Test Last
• What to test?
• Separating units
• How to test?
• Inversion of Dependency, Dependency Injection, Mocking
13. Is Code Quality the Only Gain?
• Not with Test First TDD!
• You can use tests to specify how your code should work.
• Specification by Example:
“Specifications are supposed to be general, to cover all cases. Examples only
highlight a few points, you have to infer the generalizations yourself.”
• However – examples can be coded and validated easily.
14. An Example of Specification by Example
namespace RecentlyUsedList {
[TestFixture]
public class A_new_list {
[Test]
public void Is_empty() { … }
}
}
15. An Example of Specification by Example
namespace RecentlyUsedList {
[TestFixture]
public class An_empty_list {
[Test]
public void Retains_a_single_addition() { … }
[Test]
public void Retains_unique_additions_in_reverse_order() { … }
}
}
16. An Example of Specification by Example
namespace RecentlyUsedList {
[TestFixture]
public class A_non-empty_list {
[Test]
public void Is_unchanged_when_the_head_item_is_readded() { … }
[Test]
public void Moves_non-head_item_to_head_when_it_is_readded() { … }
}
}
17. An Example of Specification by Example
namespace RecentlyUsedList {
[TestFixture]
public class Any_list_rejects {
[Test]
public void Addition_of_null_items() { … }
[Test]
public void Indexing_past_its_end() { … }
[Test]
public void Negative_indexing() { … }
}
}
18. Test First Style
• Simple rules:
1. A non-compiling unit test is considered a failed unit test.
2. Never write production code without having a failing test that necessitates writing that
code.
3. Never write more production code than what is minimally required to fix your failing
test.
4. When a unit test fails, you don’t commit anything to the system until the failing unit
test is passing again.
20. Test First Cycle
1. Add a new unit test
2. Run all unit tests to see the test fail
3. Write your code
1. Write a small segment of the test code
2. Run all unit tests to see the test fail
3. Write production code to have your test pass
4. Run all tests to see them all pass
5. Refactor your production code
6. Run all tests to seem the all pass
22. Continuous Running of Unit Tests
• Visual Studio Enterprise: Live Unit testing
• NCrunch
• (Severe performance impact)
23. So, we are writing Test First Code
• Our coverage is at about 100%
• There is nothing else to test
• Everything works perfectly
• And we have arrived to the promised land of good quality code.
26. Unit testing is for devs
• Software is a holistic system – the whole is more than the sum of the
components.
• The fact that some parts work perfectly in separation does not mean that
they work perfectly together as well.
• Unit testing only guarantees code quality improvements, but might not
provide benefits solution-wise.
• The whole process cannot be tested as the business / the customer / the
product owner are not involved.
30. Higher level testing problems
• System level functions are difficult to define
• Software Requirements Specification:
• A lengthy document
• Suitable for a waterfall model – but not a good fit for an agile model
31. But we have already solved this issue…
• With User Stories. Right? Well… sort of.
• How does a User Story look like?
• As a [user type]
• I want to [task to perform]
• In order to / so that I [benefit/value]
32. User Story Example
• User story:
• As an Administrator
I want to be able to create User Accounts
in order to grant users access to the system.
• Yeah, seems simple enough…
33. Acceptance Criteria Example
1. If I am an Administrator, I can create User Accounts.
2. I can create a User Account by entering the following information about the User:
a. Name,
b. Email address,
c. Phone Number
d. License Number (Power/Basic/None),
e. Account Status (Active/Inactive),
f. Reports to (from a list of “Active” Users)
3. I cannot assign a new User to report to an “Inactive” User
4. I cannot assign a new User to report to a User if it creates a cyclical relationship (e.g., User 1 reports to User 2 who reports to User 1)
5. The system notifies me that it sent an email to the new User’s email address, containing a system-generated initial password and instructions
for the person to log in and change their password.
6. I am able to verify with the intended recipient of the email that it was received.
38. Language Imperfections
• “A common risk with software development includes
communication breakdowns between Developers and
Business Stakeholders.”
• Text and/or speech is sometimes incapable of conveying
clear, undisputable meaning.
• Or at least it is really difficult to achieve it.
• Acceptance criteria as plain text usually falls short.
This is not a test pyramid
39. “
”
The only way to rectify our reasonings is to make them as
tangible as those of the Mathematicians, so that we can find
our error at a glance, and when there are disputes among
persons, we can simply say: ‘Let us calculate, without further ado, to
see who is right.’
Wilhelm Leibniz: The Art of Discovery (1685)
See also:
John Wilkins: An Essay towards a Real Character and Philosophical Language (1668)
Umberto Eco: The Search for a Perfect Language (1995)
40. What can a developer implement?
• Specification by Example
• Remember the AAA of unit testing? We’d need something similar.
41. “
”
“A ubiquitous language is a (semi-)formal language that is shared by all
members of a software development team — both software developers and
non-technical personnel.
[…]
The language in question is both used and developed by all team members as
a common means of discussing the domain of the software in question.”
Eric Evans: Domain-Driven Design: Tackling Complexity in the Heart of Software
Ubiquitous Language
43. DDD
Okay, then, what is DDD?
“an approach to software development for complex needs by connecting the
implementation to an evolving model”
Okay, then, what is a “domain”?
It is “application domain”, a “domain of discourse”, a “problem sphere”, or a “universe”. It is the
sphere of knowledge on the problem that our software is aiming to solve.
Great. What is this model you speak of?
A system of abstractions (a set of entities and business rules) that describes selected
aspects of a domain and can be used to solve problems related to that domain.
44. So, let’s borrow this concept from DDD…
… and use it in TDD for higher level tests!
46. GWT is AAA
• Arrange ~= Given
• Act ~= When
• Assert ~= Then
Given that I have Arranged the system for the test
When I perform the tested Action
Then I can Assert the conditions that pass the test
48. How are Acceptance Tests different from Unit
Tests?
• They test the same things
• Only less granularly: they hide implementation details that programmers (and Unit
Tests) should be concerned with, but business (and Acceptance Tests) should not.
• Acceptance Tests is a subset of Unit Tests (remember the test pyramid?)
49. AAA for the Business
• Specification in plain English for the business people
• Specification that can be implemented for the developer
50. Gherkin Specification
Feature: Calculator
As a math idiot
I want to be told the sum of two numbers
in order to avoid silly mistakes
Scenario: Add two numbers
Given I have entered 50 into the calculator
And I have pressed the “Add” button
And I have entered 70 into the calculator
When I press the “Equals” button
Then I should see the result “120” on the screen
52. Language for Developers
public class CalculatorTestSteps
{
[Given(@”I have entered (.*) into the calculator”)]
public void GivenIHaveEnteredIntoTheCalculator(int v)
{
// …
}
// …
}
53. How does this resolve linguistic ambiguity?
• It creates a common language between People Who Know What The
Software Should Do (PO, BA, tester)and the People Who Know How To
Write The Software (developer).
54. Okay, but what is the magic behind it all?
• The power of mathematics™!
• As Gherkin specifications are actually nothing, but…
55. Finite-State Machines
• We have a set of States, and a set of Actions (State Transitions)
• We start from a State, and performing an Action we arrive to another State
• A simple example is…
56. … a coin-operated turnstile
• We have two states:
• Open
• Locked
• We have two actions:
• Insert coin
• Push arm
57. State transitions
• We start the system in the “Locked” state
• Inserting a coin:
• In the “Locked” state moves the system to the “Open” state
• In the “Open” state leaves the system in the “Open” state
• Pushing the arm:
• In the “Locked” state keeps the system in the “Locked” state
• In the “Open” state moves the system to the “Locked” state
58. So how is a Gherkin a FSM?
Given I have entered 50 into the calculator
And I have pressed the “Add” button
And I have entered 70 into the calculator
When I press the “Equals” button
Then I should see the result “120” on the screen
Given I am in state S1
When I receive event E1
Then I transition to state S2
59. Back to Resolving Linguistic Ambiguity
• Acceptance criteria is written in Acceptance Test form, using Gherkin.
• My implementation task is complete when my Acceptance Tests are green.
• The PO should write the “happy path” (positive test cases), the tester should
write the “unhappy paths” (negative test cases) – usually together with the
developer.
• This is ATDD – Acceptance-Test-Driven Development.
63. “
”
I’m glad that you’ve asked that question…
A List of Most Common Lies of the World, entry #3:
64. “
”
BDD is a second-generation, outside-in, pull-based, multiple-
stakeholder, multiple-scale, high-automation, agile methodology. It
describes a cycle of interactions with well-defined outputs, resulting
in the delivery of working, tested software that matters.
Dan North at the 2009 Agile specifications, BDD and Testing eXchange
Ah, okay, now I really understand it all.
67. Let me rephrase it…
“behavior-driven development is a software development process that […]
combines the general techniques and principles of test-driven development
with ideas from domain-driven design and object-oriented analysis and
design to provide software development and management teams with
shared tools and a shared process to collaborate on software development.”
68. So basically…
• BDD = Agile + TDD + ATDD?
• Sort of.
• What else?
• High automation (CI, CD, auto-testing).
• Tooling (C#: SpecFlow by TechTalk)
69. Okay, does it then tell me when to run my
Acceptance Tests?
• Of course it does!
• It tells you to run them when you run your Unit Tests
• That is, any time you build
• On the CI machine
• Or locally.
70. Okay, but I really want to understand that
quote…
Well, if you insist…
71. “
”
BDD is a second-generation, outside-in, pull-based, multiple-
stakeholder, multiple-scale, high-automation, agile methodology. It
describes a cycle of interactions with well-defined outputs, resulting
in the delivery of working, tested software that matters.
Dan North at the 2009 Agile specifications, BDD and Testing eXchange
• Second-generation: Has more in common with Lean and Kanban than with XP and Scrum
• Outside-in: focuses on satisfying the needs of stakeholders
• Pull-based: tasks are not allocated by the management, stories are created on-demand
• Multiple-stakeholder, multiple-scale: yeah, makes sense
• High automation: CI, CD, running tests automatically, tests act as acceptance criteria
72. How should I imagine developing in BDD?
• Well, it’s basically ATDD, so you use the ATDD cycle.
• Let me see a demo!
75. Feature: Accessing user management
As a maintenance user
I want to be able to access user management in standalone mode
so that I can grant or revoke access to specific parts of the system.
Background:
Given the following "offline" users exist
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
And I am logged out
And the "Header Panel" is visible
76. Scenario: User management menu item appears for an administrator user
When I log in as "Mia"
Then the "User Management Menu Item" is visible
Scenario: User management is not visible when no user is logged in
Then the "User Management Menu Item" is not visible
Scenario: User management menu item doesn't appear for supervisor user
When I log in as "Sophie"
Then the "User Management Menu Item" is not visible
Scenario: User management menu item doesn't appear for operator user
When I log in as "Olivia"
Then the "User Management Menu Item" is not visible
77. Scenario: Clicking on the User Management menu item opens the User Management dialog
When I log in as "Mia"
And I click the "User Management Menu Item"
Then the "User Management Dialog" opens
Scenario: Pressing the Exit button closes the User management dialog
When I log in as "Mia"
And I click the "User Management Menu Item"
And I click the "Exit Button"
Then the "User Management Dialog" closes
And the "Main Menu Screen" is displayed
78. Feature: Adding a new user
As a maintenance user
I want to be able to add new users
so that I can grant access to specific parts of the system.
Background:
Given the following "offline" users exist
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
And I am logged in as "Mia"
And the "User Management Dialog" is displayed
And the following users are displayed
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
And no user is selected
79. Scenario: Pressing the Add New User button opens the Add New User dialog
When I click the "Add New User Button"
Then the "Add New User Dialog" is displayed
Scenario: Attempting to create a new user with an empty UserName
shows an error message
When I click the "Add New User Button"
And I enter the following user data
| UserName | Description | UserLevel |
| | A new operator user | Operator |
And I confirm the "Add New User Dialog"
Then an "Error Dialog" is displayed
And the displayed error message is "User name must not be empty!"
80. Scenario: Adding a new user creates a new user in the system
When I click the "Add New User Button"
And I enter the following user data
| UserName | Description | UserLevel |
| Oliver | A new operator user | Operator |
And I confirm the "Add New User Dialog"
Then the "Add New User Dialog" closes
And the "User Management Dialog" is displayed
And the following users are displayed
| UserName | Description | UserLevel |
| Oliver | A new operator user | Operator |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
81. Scenario: Canceling the addition of a new user does not modify the user list
When I click the "Add New User Button"
And I enter the following user data
| UserName | Description | UserLevel |
| Oliver | A new operator user | Operator |
And I cancel the "Add New User Dialog"
Then the "Add New User Dialog" closes
And the "User Management Dialog" is displayed
And the following users are displayed
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
82. Feature: Deleting an existing user
As a maintenance user
I want to be able to delete existing users
so that I can revoke their access to the system.
Background:
Given the following "offline" users exist
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
And I am logged in as "Mia"
And the "User Management Dialog" is displayed
And the following users are displayed
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
And "Sophie" is selected
83. Scenario: Deleting an existing user removes the selected user
When I click the "Delete User Button"
And I confirm the "Confirm User Deletion Dialog"
Then the following users are displayed
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Mia | A maintenance user | Security |
Scenario: Canceling the deletion of an existing user does not modify the user list
When I click the "Delete User Button"
And I cancel the "Confirm User Deletion Dialog"
Then the following users are displayed
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
84. Feature: User management dialog buttons
As a maintenance user
I want my selection on the user list to influence the buttons I can press
so that I can see at a glance what are the available actions with the
current selection.
Background:
Given the following "offline" users exist
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
And I am logged in as "Mia"
And the "User Management Dialog" is displayed
And the following users are displayed
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
85. Scenario: User management list button statuses are correct when no user is selected
When I clear the user selection
Then the "Add New User Button" is enabled
And the "Exit Button" is enabled
But the "Edit User Button" is disabled
And the "Delete User Button" is disabled
Scenario: User management list button statuses are correct when a user is selected
When I select "Sophie"
Then the "Add New User Button" is disabled
But the "Exit Button" is enabled
And the "Edit User Button" is enabled
And the "Delete User Button" is enabled
86. Feature: User listing
As a maintenance user
I want to be able to see a list of users that can access my system
so that I can see or edit their data.
Background:
Given the following "offline" users exist
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
And I am logged in as "Mia"
And the "Header Panel" is visible
87. Scenario: User management shows list of standalone users
When I click the "User Management menu item"
Then the "User Management Dialog" is displayed
And the following users are displayed
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
Scenario: No user is selected on the User Management Dialog when it initially opens
When I click the "User Management menu item"
Then the "User Management Dialog" is displayed
And no user is selected
88. Feature: Editing an existing user
As a maintenance user
I want to be able to edit existing users
so that I can modify their details.
Background:
Given the following "standalone" users exist
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
And I am logged in as "Mia"
And the "User Management Dialog" is displayed
And the following users are displayed
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |
And "Sophie" is selected
89. Scenario: Pressing the Edit User button opens the Edit User dialog
When I click the "Edit User Button"
Then the "Edit User Dialog" is displayed
And the following user data is displayed
| UserName | Description | UserLevel |
| Sophie | A supervisor user | Supervisor |
90. Scenario: Editing user data of an existing user modifies the selected user
When I click the "Edit User Button"
And I modify the "User Name" field to "Sophia"
And I modify the "Description" field to "An ex-supervisor user"
And I modify the "User Level" field to "Operator"
And I confirm the "Edit User Dialog"
Then the "Edit User Dialog" closes
And the "User Management Dialog" is displayed
And the following users are displayed
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophia | An ex-supervisor user | Operator |
| Mia | A maintenance user | Security |
91. Scenario: Canceling editing of an existing user does not modify the user list
When I click the "Edit User Button"
And I modify the "User Name" field to "Sophia"
And I modify the "Description" field to "An ex-supervisor user"
And I modify the "User Level" field to "Operator"
And I cancel the "Edit User Dialog"
Then the "Edit User Dialog" closes
And the "User Management Dialog" is displayed
And the following users are displayed
| UserName | Description | UserLevel |
| Olivia | An operator user | Operator |
| Sophie | A supervisor user | Supervisor |
| Mia | A maintenance user | Security |