1.2 10 1.2 1 10 mods info:srw/schema/1/mods-v3.5 xml 1create higher-quality software by writing tests first with solid and hexagonal architecture /Mellor, Alan,author.texttextbookenkPackt Publishing202320221st ed.single uniteng

electronic resource

remote

1 online resource (348 pages)

computer

online resource

Drive development with automated tests and gain the confidence you need to write high-quality software Key Features Get up and running with common design patterns and TDD best practices Learn to apply the rhythms of TDD - arrange, act, assert and red, green, refactor Understand the challenges of implementing TDD in the Java ecosystem and build a plan Book Description Test-driven development enables developers to craft well-designed code and prevent defects. It's a simple yet powerful tool that helps you focus on your code design, while automatically checking that your code works correctly. Mastering TDD will enable you to effectively utilize design patterns and become a proficient software architect. The book begins by explaining the basics of good code and bad code, bursting common myths, and why Test-driven development is crucial. You'll then gradually move toward building a sample application using TDD, where you'll apply the two key rhythms -- red, green, refactor and arrange, act, assert. Next, you'll learn how to bring external systems such as databases under control by using dependency inversion and test doubles. As you advance, you'll delve into advanced design techniques such as SOLID patterns, refactoring, and hexagonal architecture. You'll also balance your use of fast, repeatable unit tests against integration tests using the test pyramid as a guide. The concluding chapters will show you how to implement TDD in real-world use cases and scenarios and develop a modern REST microservice backed by a Postgres database in Java 17. By the end of this book, you'll be thinking differently about how you design code for simplicity and how correctness can be baked in as you go. What you will learn Discover how to write effective test cases in Java Explore how TDD can be incorporated into crafting software Find out how to write reusable and robust code in Java Uncover common myths about TDD and understand its effectiveness Understand the accurate rhythm of implementing TDD Get to grips with the process of refactoring and see how it affects the TDD process Who this book is for This book is for expert Java developers and software architects crafting high-quality software in Java. Test-Driven Development with Java can be picked up by anyone with a strong working experience in Java who is planning to use Test-driven development for their upcoming projects.Cover -- Title Page -- Copyright and Credit -- Dedicated -- Contributors -- Table of Contents -- Preface -- Part 1: How We Got to TDD -- Chapter 1: Building the Case for TDD -- Writing code badly -- Understanding why bad code is written -- Recognizing bad code -- Bad variable names -- Bad function, method, and class names -- Error-prone constructs -- Coupling and cohesion -- Decreasing team performance -- Diminishing business outcomes -- Summary -- Questions and answers -- Further reading -- Chapter 2: Using TDD to Create Good Code -- Designing good quality code -- Say what you mean, mean what you say -- Take care of the details in private -- Avoid accidental complexity -- Revealing design flaws -- Analyzing the benefits of writing tests before production code -- Preventing logic flaws -- Protecting against future defects -- Documenting our code -- Summary -- Questions and answers -- Further reading -- Chapter 3: Dispelling Common Myths about TDD -- Writing tests slows me down -- Understanding the benefits of slowing down -- Overcoming objections to tests slowing us down -- Tests cannot prevent every bug -- Understanding why people say tests cannot catch every bug -- Overcoming objections to not catching every bug -- How do you know the tests are right? -- Understanding the concerns behind writing broken tests -- Providing reassurance that we test our tests -- TDD guarantees good code -- Understanding problem-inflated expectations -- Managing your expectations of TDD -- Our code is too complex to test -- Understanding the causes of untestable code -- Reframing the relationship between good design and simple tests -- Managing legacy code without tests -- I don't know what to test until I write the code -- Understanding the difficulty of starting with testing -- Overcoming the need to write production code first -- Summary.Questions and answers -- Further reading -- Part 2: TDD Techniques -- Chapter 4: Building an Application Using TDD -- Technical requirements -- Preparing our development environment -- Installing the IntelliJ IDE -- Setting up the Java project and libraries -- Introducing the Wordz application -- Describing the rules of Wordz -- Exploring agile methods -- Reading user stories - the building block of planning -- Combining agile development with TDD -- Summary -- Questions and answers -- Further reading -- Chapter 5: Writing Our First Test -- Technical requirements -- Starting TDD: Arrange-Act-Assert -- Defining the test structure -- Working backward from outcomes -- Increasing workflow efficiency -- Defining a good test -- Applying the FIRST principles -- Using one assert per test -- Deciding on the scope of a unit test -- Catching common errors -- Asserting exceptions -- Only testing public methods -- Preserving encapsulation -- Learning from our tests -- A messy Arrange step -- A messy Act step -- A messy Assert step -- Limitations of unit tests -- Code coverage - an often-meaningless metric -- Writing the wrong tests -- Beginning Wordz -- Summary -- Questions and answers -- Chapter 6: Following the Rhythms of TDD -- Technical requirements -- Following the RGR cycle -- Starting on red -- Keep it simple - moving to green -- Refactoring to clean code -- Writing our next tests for Wordz -- Summary -- Questions and answers -- Further reading -- Chapter 7: Driving Design - TDD and SOLID -- Technical requirements -- Test guide - we drive the design -- SRP - simple building blocks -- Too many responsibilities make code harder to work with -- Ability to reuse code -- Simplified future maintenance -- Counter-example - shapes code that violates SRP -- Applying SRP to simplify future maintenance -- Organizing tests to have a single responsibility.DIP - hiding irrelevant details -- Applying DI to the shapes code -- LSP - swappable objects -- Reviewing LSP usage in the shapes code -- OCP - extensible design -- Adding a new type of shape -- ISP - effective interfaces -- Reviewing ISP usage in the shapes code -- Summary -- Questions and answers -- Chapter 8: Test Doubles - Stubs and Mocks -- Technical requirements -- The problems collaborators present for testing -- The challenges of testing unrepeatable behavior -- The challenges of testing error handling -- Understanding why these collaborations are challenging -- The purpose of test doubles -- Making the production version of the code -- Using stubs for pre-canned results -- When to use stub objects -- Using mocks to verify interactions -- Understanding when test doubles are appropriate -- Avoiding the overuse of mock objects -- Don't mock code you don't own -- Don't mock value objects -- You can't mock without dependency injection -- Don't test the mock -- When to use mock objects -- Working with Mockito - a popular mocking library -- Getting started with Mockito -- Writing a stub with Mockito -- Writing a mock with Mockito -- Blurring the distinction between stubs and mocks -- Argument matchers - customizing behavior of test doubles -- Driving error handling code with tests -- Testing an error condition in Wordz -- Summary -- Questions and answers -- Further reading -- Chapter 9: Hexagonal Architecture -Decoupling External Systems -- Technical requirements -- Why external systems are difficult -- Environmental problems bring trouble -- Accidentally triggering real transactions from tests -- What data should we expect? -- Operating system calls and system time -- Challenges with third-party services -- Dependency inversion to the rescue -- Generalizing this approach to the hexagonal architecture.Overview of the hexagonal architecture's components -- The golden rule - the domain never connects directly to adapters -- Why the hexagon shape? -- Abstracting out the external system -- Deciding what our domain model needs -- Writing the domain code -- Deciding what should be in our domain model -- Using libraries and frameworks in the domain model -- Deciding on a programming approach -- Substituting test doubles for external systems -- Replacing the adapters with test doubles -- Unit testing bigger units -- Unit testing entire user stories -- Wordz - abstracting the database -- Designing the repository interface -- Designing the database and random numbers adapters -- Summary -- Questions and answers -- Further reading -- Chapter 10: FIRST Tests and the Test Pyramid -- Technical requirements -- The test pyramid -- Unit tests - FIRST tests -- Integration tests -- What should an integration test cover? -- Testing database adapters -- Testing web services -- Consumer-driven contract testing -- End-to-end and user acceptance tests -- Acceptance testing tools -- CI/CD pipelines and test environments -- What is a CI/CD pipeline? -- Why do we need continuous integration? -- Why do we need continuous delivery? -- Continuous delivery or continuous deployment? -- Practical CI/CD pipelines -- Test environments -- Testing in production -- Wordz - integration test for our database -- Fetching a word from the database -- Summary -- Questions and answers -- Further reading -- Chapter 11: Exploring TDD with Quality Assurance -- TDD - its place in the bigger quality picture -- Understanding the limits of TDD -- No more need for manual testing? -- Manual exploratory - discovering the unexpected -- Code review and ensemble programming -- User interface and user experience testing -- Testing the user interface -- Evaluating the user experience.Security testing and operations monitoring -- Incorporating manual elements into CI/CD workflows -- Summary -- Questions and answers -- Further reading -- Chapter 12: Test First, Test Later, Test Never -- Adding tests first -- Test-first is a design tool -- Tests form executable specifications -- Test-first provides meaningful code coverage metrics -- Beware of making a code coverage metric a target -- Beware of writing all tests upfront -- Writing tests first helps with continuous delivery -- We can always test it later, right? -- Test-later is easier for a beginner to TDD -- Test-later makes it harder to test every code path -- Test-later makes it harder to influence the software design -- Test-later may never happen -- Tests? They're for people who can't write code! -- What happens if we do not test during development? -- Testing from the inside out -- Testing from the outside in -- Defining test boundaries with hexagonal architecture -- Inside-out works well with the domain model -- Outside-in works well with adapters -- User stories can be tested across the domain model -- Summary -- Questions and answers -- Further reading -- Part 3: Real-World TDD -- Chapter 13: Driving the Domain Layer -- Technical requirements -- Starting a new game -- Test-driving starting a new game -- Tracking the progress of the game -- Triangulating word selection -- Playing the game -- Designing the scoring interface -- Triangulating game progress tracking -- Ending the game -- Responding to a correct guess -- Triangulating the game over due to too many incorrect guesses -- Triangulating response to guess after game over -- Reviewing our design -- Summary -- Questions and answers -- Further reading -- Chapter 14: Driving the Database Layer -- Technical requirements -- Installing the Postgres database -- Creating a database integration test.Creating a database test with DBRider.Alan Mellor.Includes index.Mellor Alan: Alan Mellor is an academy lead at BJSS, training the next generation of consulting software engineers, and the author of Java OOP Done Right: Create object-oriented code you can be proud of with modern Java. Alan started with a Sinclair ZX81 computer with 1K of RAM and is very happy to have better computers now. Alan's work includes industrial control in C, web applications for e-commerce, gaming, and banking in Java and Go, and document warehousing in C++. His most visible code is part of Nokia Bounce and the RAF Red Arrows flight simulator if you go back far enough.Java (Computer program language)Computer softwareDevelopment.Computer softwareTesting.QA76 .M455 2023929.605ISBN 9781803236230ISBN 180323623X9781803237961180323796110.0000/97818032379611357534122rdaMiAaPQ23020420230204184834.0almatuudk_9923197706502884Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl (Revision 1.119 2018/06/21)eng info:srw/schema/1/mods-v3.5 xml 2Homès, Bernard.texttextbookxxWiley20242nd ed.single uniteng

electronic resource

remote

1 online resource (388 pages)

computer

online resource

Software testing has greatly evolved since the first edition of this book in 2011. Testers are now required to work in "agile" teams and focus on automating test cases. It has thus been necessary to update this work, in order to provide fundamental knowledge that testers should have to be effective and efficient in today's world. This book describes the fundamental aspects of testing in the different lifecycles, and how to implement and benefit from reviews and static analysis. Multiple other techniques are approached, such as equivalence partitioning, boundary value analysis, use case testing, decision tables and state transitions. This second edition also covers test management, test progress monitoring and incident management, in order to ensure that the testing information is correctly provided to the stakeholders. This book provides detailed course-study material for the 2023 version of the ISTQB Foundation level syllabus, including sample questions to help prepare for exams.Cover -- Title Page -- Copyright Page -- Contents -- Preface -- Glossary -- Chapter 1. Fundamentals of Testing -- 1.1. What is testing? -- 1.1.1. Software and systems context -- 1.1.2. Causes of software defects -- 1.1.3. Role of testing in software development, maintenance and operations -- 1.1.4. Tests and quality -- 1.1.5. Terminology. -- 1.2. What is testing? -- 1.2.1. Origin of defects -- 1.2.2. Common goals of testing -- 1.2.3. Examples of objectives for testing -- 1.2.4. Test and debugging -- 1.3. Paradoxes and main principles -- 1.3.1. Testing identifies the presence of defects -- 1.3.2. Exhaustive testing is impossible -- 1.3.3. Early testing -- 1.3.4. Defect clustering -- 1.3.5. Pesticide paradox -- 1.3.6. Testing is context dependent -- 1.3.7. Absence-of-errors fallacy -- 1.4. Test activities, testware and test roles -- 1.4.1. Planning -- 1.4.2. Monitoring and control -- 1.4.3. Test analysis and design -- 1.4.4. Test implementation -- 1.4.5. Test execution -- 1.4.6. Reporting -- 1.4.7. Test completion activities -- 1.4.8. The value of traceability -- 1.4.9. Impact of context on the test process -- 1.5. Roles in testing -- 1.6. Essential skills and "good practices" in testing -- 1.6.1. Generic skills -- 1.6.2. Specific skills -- 1.6.3. Whole team approach -- 1.6.4. Independence of testing -- 1.6.5. Levels of independence -- 1.6.6. Adapt to objectives -- 1.6.7. Destructive or constructive? -- 1.6.8. People skills -- 1.6.9. Change of perspective -- 1.7. Testers and code of ethics (FL 1.6) -- 1.7.1. Public -- 1.7.2. Client and employer -- 1.7.3. Product -- 1.7.4. Judgment -- 1.7.5. Management -- 1.7.6. Profession -- 1.7.7. Colleagues -- 1.7.8. Self -- 1.8. Sample exam questions -- Chapter 2. Testing Throughout the Software Life Cycle -- 2.1. Testing through the software development life cycle -- 2.1.1. Sequential models.2.1.2. Iterative models -- 2.1.3. Incremental model -- 2.1.4. RAD -- 2.1.5. Agile models -- 2.1.6. Selection of a development model -- 2.1.7. Positioning tests -- 2.1.8. Test-first and shift-left approaches -- 2.2. Test levels and test types -- 2.2.1. Component-level testing or component tests -- 2.2.2. Integration-level testing or integration tests -- 2.2.3. System tests -- 2.2.4. Acceptance tests -- 2.2.5. Other levels -- 2.3. Types of tests -- 2.3.1. Functional tests -- 2.3.2. Nonfunctional tests -- 2.3.4. Tests associated with changes -- 2.3.5. Comparisons and examples -- 2.4. Test and maintenance -- 2.4.1. Maintenance context -- 2.4.2. Evolutive maintenance -- 2.4.3. Corrective maintenance -- 2.4.4. Retirement and replacement -- 2.4.5. Regression test policies -- 2.4.6. SLA validation and acceptance -- 2.5. Oracles -- 2.5.1. Problems with oracles -- 2.5.2. Sources of oracles -- 2.5.3. Oracle usage -- 2.6. Process improvements -- 2.6.1. Objectives -- 2.6.2. Measurements -- 2.6.3. Retrospectives and improvements -- 2.7. Specific cases -- 2.7.1. Performance tests -- 2.7.2. Maintainability tests -- 2.8. Sample exam questions -- Chapter 3. Static Testing -- 3.1. Static techniques and the test process -- 3.2. Review process -- 3.2.1. Types of reviews -- 3.2.2. Roles and responsibilities during reviews -- 3.2.3. Phases of reviews -- 3.2.4. Success factors for reviews -- 3.2.5. Comparison of the types of reviews -- 3.3. Static analysis by tools -- 3.3.1. Types of static analysis -- 3.3.2. Types of defects that can be identified -- 3.3.3. Data flow analysis -- 3.4. Added value of static activities -- 3.5. Sample exam questions -- Chapter 4. Test Design Techniques -- 4.1. The test development process -- 4.1.1. Terminology -- 4.1.2. Traceability -- 4.2. Categories of test design techniques -- 4.2.1. Black box, white box or gray box.4.2.2. Experience-based techniques -- 4.2.3. Test characteristics -- 4.2.4. Limitations and assumptions -- 4.3. Black-box techniques -- 4.3.1. Equivalence partitioning -- 4.3.2. Boundary value analysis -- 4.3.3. Decision tables -- 4.3.4. Other combinational techniques -- 4.3.5. State transition testing -- 4.3.6. Use case testing -- 4.3.7. Limitations and assumptions -- 4.4. Structure-based techniques -- 4.4.1. Statement testing and coverage -- 4.4.2. Decision testing and coverage -- 4.4.3. Other structure-based techniques -- 4.4.4. MC/DC coverage -- 4.4.5. Limitations and assumptions of structure-based testing -- 4.4.6. Coverage level and exit criteria -- 4.5. Experience-based technique -- 4.5.1. Attacks -- 4.5.2. Defect taxonomies -- 4.5.3. Error guessing and ad hoc testing -- 4.5.4. Exploratory testing -- 4.5.5. Limitations and assumptions -- 4.6. Collaboration-based test approaches -- 4.6.1. Collaborative user stories -- 4.6.2. Acceptance criteria -- 4.6.3. Acceptance test-driven development -- 4.7. Choosing test techniques -- 4.8. Sample exam questions -- Chapter 5. Test Management -- 5.1. Test organization -- 5.1.1. Independence levels -- 5.1.2. Roles and responsibilities -- 5.1.3. Human and contractual aspects -- 5.2. Test planning and estimation -- 5.2.1. Planning and evaluation activities -- 5.2.2. Test planning activities -- 5.2.3. Test documentation -- 5.2.4. Entry and exit criteria for test activities -- 5.3. Test progress monitoring and control (FL 5.3) -- 5.4. Reporting -- 5.4.1. What to report, to whom and how? -- 5.4.2. Statistics and graphs -- 5.5. Transverse processes and activities -- 5.5.1. Test data definition -- 5.5.2. Configuration management (FL 5.4) -- 5.5.3. Change management -- 5.6. Risk management (FL 5.2) -- 5.6.1. Principles of risk management -- 5.6.2. Project risks and product risks.5.6.3. Introduction to risk management -- 5.7. Defect management (FL 5.5) -- 5.7.1. Introduction to defect management -- 5.7.2. Defect identification -- 5.7.3. Actions applied to defects -- 5.7.4. Defect disposition -- 5.8. Sample exam questions -- Chapter 6. Tools Support for Testing -- 6.1. Types of test tools -- 6.1.1. Test tool classification -- 6.1.2. Tools supporting test management -- 6.1.3. Tools supporting requirement management -- 6.1.4. Tools supporting static tests -- 6.1.5. Modeling tools -- 6.1.6. Tools supporting test design and test data creation -- 6.1.7. Tools supporting test execution -- 6.1.8. Tools supporting test environment management -- 6.1.9. Tools supporting test data comparison -- 6.1.10. Tools supporting test coverage measurement -- 6.1.11. Other test supporting tools -- 6.2. Assumptions and limitations of test tools -- 6.2.1. Advantages and risks of the tools -- 6.2.2. Specific considerations for some tools -- 6.3. Selecting and introducing tools in an organization -- 6.3.1. Main principles -- 6.3.2. Tool selection process -- 6.3.3. Test tool implementation -- 6.3.4. To build or to buy test tools? -- 6.4. Sample exam questions -- Chapter 7. Mock Exam -- Chapter 8. Templates and Models -- 8.1. Master test plan -- 8.2. Test plan -- 8.2.1. Test plan as per IEEE 829-1998 -- 8.2.2. Test plan as per IEEE 829-2008 -- 8.3. Test design document -- 8.3.1. Test design specifications as per IEEE 829-1998 -- 8.3.2. Test design document as per IEEE 829-2008 -- 8.4. Test case -- 8.4.1. Test case document as per IEEE 829-1998 -- 8.4.2. Test case document as per IEEE 829-2008 -- 8.5. Test procedure -- 8.5.1. Test procedure document as per IEEE 829-1998 -- 8.5.2. Test procedure document as per IEEE 829-2008 -- 8.6. Test log -- 8.6.1. Test log as per IEEE 829-1998 -- 8.6.2. Test log as per IEEE 829-2008 -- 8.7. Defect report.8.7.1. Defect report as per IEEE 829-1998 -- 8.7.2. Defect report as per IEEE 829-2008 -- 8.8. Test report -- 8.8.1. Test report as per IEEE 829-1998 -- 8.8.2. Interim test report as per IEEE 829-2008 -- 8.8.3. Level test report as per IEEE 829-2008 -- 8.8.4. Master test report as per IEEE 829-2008 -- Chapter 9. Answers to the Questions -- 9.1. Answers to the end-of-chapter questions -- 9.2. Correct answers to the sample paper questions -- References -- Index -- Other titles from ISTE in Computer Engineering -- EULA.Computer softwareTesting.QA76.76.T48005.1ISBN 9781786309822ISBN 1786309823978139429897613942989789781394298952139429895114778197751436834467rdaMiAaPQ24060120251214173404.0almatuudk_9923118648102884Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl (Revision 1.119 2018/06/21)eng info:srw/schema/1/mods-v3.5 xml 3a practical handbook /Rogers, Lauren,editor.textbibliographytextenkDuxford, England :Woodhead Publishing,2017.©201720172017single uniteng

electronic resource

remote

1 online resource (501 pages) : color illustrations, tables.

computer

online resource

Front Cover -- Discrimination Testing in Sensory Science -- Related Titles -- Discrimination Testing in Sensory Science -- Copyright -- Dedication -- Contents -- List of Contributors -- Preface -- Acknowledgments -- I - Introduction to Discrimination Testing -- 1 - Introduction and History of Sensory Discrimination Testing -- REFERENCES -- FURTHER READING -- 2 - Statistics for Use in Discrimination Testing -- 1. BUSINESS RISK -- 1.1 Conventional Hypothesis Testing -- 1.1.1 The p-Value -- 1.1.2 Type I and Type II Errors -- 1.1.3 The Momentary Proportion of Discriminators -- 1.1.4 Sensory Tests for Difference in Tests Without Chance Bounds -- 1.1.5 Statistical Significance Is Not Practical Significance -- 1.1.6 Sensory Tests for Equivalency or Noninferiority -- 1.2 Reframing the Hypothesis Test Using Likelihood or Bayesian Inference -- 2. DATA ARISING FROM SENSORY DISCRIMINATION TEST METHODS -- 2.1 Classification of Methods -- 2.2 Importance of Experimental Design on Analysis -- 3. ANALYSIS OF DATA ARISING FROM TESTS WITH A CHANCE BOUND (E.G., TRIANGLE TEST) -- 3.1 Unreplicated Data -- 3.2 Replicated Data -- 3.3 Statistical Power -- 4. ANALYSIS OF DATA ARISING FROM SIMPLE CLASSIFICATION TASKS WITHOUT A CHANCE BOUND (E.G., A-NOT-A TEST) -- 4.1 Unreplicated Data -- 4.2 Replicated Data -- 4.3 Statistical Power -- 5. ANALYSIS OF DATA ARISING FROM DIFFERENCE FROM CONTROL/DEGREE OF DIFFERENCE TEST METHODS -- 6. ANALYSIS OF DATA ARISING FROM A RANKING TEST METHOD -- 7. EVALUATING SENSORY EQUIVALENCY -- 7.1 Equivalence Testing for Data Arising From Tests With a Correct Response -- 7.2 Equivalence Testing for Data Arising From Tests That Do Not Have a Correct Response -- 8. CONTEXTUALIZING SENSORY DISCRIMINATION RESULTS TO MAKE BUSINESS DECISIONS -- 9. SUMMARY -- 10. RECOMMENDED READING -- ACKNOWLEDGMENTS -- REFERENCES.3 - Deciding Which Test to Use in Discrimination Testing -- 1. THE OBJECTIVE/BUSINESS NEED -- 2. CONSIDERING ALL POSSIBLE TEST METHODS -- 3. GENERATING A HYPOTHESIS -- 4. THE ACTION STANDARD AND POSSIBLE OUTCOMES -- 5. ASSESSORS AND STATISTICAL POWER -- 5.1 Assessor Type -- 5.2 Assessor Numbers -- 5.3 Statistical Power -- 6. BUDGET -- 7. PRODUCT CONSIDERATIONS -- 7.1 Quantity of Sample Available -- 7.2 Carriers/Substrate-Complex Products -- 8. WHEN NOT TO USE DISCRIMINATION TESTING -- 9. SUMMARY -- REFERENCES -- FURTHER READING -- 4 - Applications and Limitations of Discrimination Testing -- 1. INTRODUCTION -- 2. CATEGORIZING DISCRIMINATION TESTS WITHIN SENSORY METHODOLOGY -- 3. APPLICATIONS OF DISCRIMINATION TESTS -- 3.1 Discrimination Testing in Quality Control -- 3.2 Discrimination Testing in Product Development -- 3.3 Other Applications (Special Cases) of Discrimination Tests -- 4. LIMITATIONS OF DISCRIMINATION TESTS -- 5. USING CONSUMERS IN DISCRIMINATION TESTS -- 6. APPLICATIONS AND LIMITATIONS OF COMMONLY USED DISCRIMINATION TESTS -- 6.1 Triangle Test -- 6.1.1 Applications -- 6.1.2 Limitations -- 6.2 Duo-Trio Test -- 6.2.1 Applications -- 6.2.2 Limitations -- 6.3 A-not-A -- 6.3.1 Applications -- 6.3.2 Limitations -- 6.4 Two-Out-of-Five Test -- 6.4.1 Applications -- 6.4.2 Limitations -- 6.5 Paired Comparison Tests -- 6.5.1 2-AFC -- 6.5.2 Same-Different Test -- 6.5.3 Applications -- 6.5.4 Limitations -- 6.6 Tetrad -- 6.6.1 Applications -- 6.6.2 Limitations -- 6.7 Difference From Control -- 6.7.1 Applications -- 6.7.2 Limitations -- 6.8 Ranking -- 6.8.1 Applications -- 6.8.2 Limitations -- 6.9 ABX -- 6.9.1 Applications -- 6.9.2 Limitations -- 7. CONCLUSION -- ACKNOWLEDGMENTS -- REFERENCES -- II - Methods and Analysis in Discrimination Testing: Practical Guidance.5 - Paired Comparison/Directional Difference Test/2-Alternative Forced Choice (2-AFC) Test, Simple Difference Test/ ... -- 1. INTRODUCTION -- 1.1 Overview of the Types of Paired Comparison Test -- 1.2 Application of the Test -- 1.3 Forced Choice Versus Nonforced Choice -- 1.4 Response Bias -- 1.5 One-Sided Versus Two-Sided -- 1.6 Test Sensitivity -- 1.7 Testing Difference Versus Similarity -- 1.8 Replication -- 2. SAME-DIFFERENT TEST: COMPARING TWO SAMPLES -- 2.1 Objective -- 2.2 Method Outline -- 2.3 Example of Questionnaire -- 2.4 Experimental Design -- 2.5 Assessors -- 2.6 Test Environment -- 2.7 Test Protocol -- 2.8 Data Analysis -- 2.9 Case Studies -- 3. DIRECTIONAL PAIRED COMPARISON: COMPARING TWO SAMPLES -- 3.1 Objective -- 3.2 Method Outline -- 3.3 Example of Questionnaire -- 3.4 Experimental Design -- 3.5 Assessors -- 3.6 Test Environment -- 3.7 Test Protocol -- 3.8 Data Analysis -- 3.9 Case Studies -- 4. MULTIPLE PAIRED COMPARISON: COMPARING MULTIPLE SAMPLES -- 4.1 Objective -- 4.2 Method Outline -- 4.3 Example of Questionnaire -- 4.4 Experimental Design -- 4.5 Assessors -- 4.6 Test Environment -- 4.7 Test Protocol -- 4.8 Data Analysis -- 4.9 Case Studies -- REFERENCES -- 6 - A-Not-A Test -- 1. WHAT IS THE A-NOT-A TEST? -- 2. PROCEDURE -- 2.1 Familiarization -- 2.2 Testing -- 2.3 Type of Assessors -- 3. WHEN TO USE THE A-NOT-A TEST -- 4. ANALYSIS OF A-NOT-A RESULTS -- 4.1 Chi-Squared Model -- 4.1.1 Note on Replicated Testing -- 4.2 Thurstonian Distance -- 4.2.1 Decision Rule for the "A-Not-A" -- 4.3 R-Index -- 5. CONCLUSION -- 6. CASE STUDY -- REFERENCES -- FURTHER READING -- 7 - Triangle Test -- 1. TEST PRINCIPLE -- 2. WHY AND WHEN TO USE IT -- 3. ADVANTAGES AND DISADVANTAGES -- 4. TERMS AND DEFINITIONS (BS ISO 4120) -- 4.1 Risks -- 4.1.1 Alpha Risk (α Risk) -- 4.1.2 Beta Risk (β Risk) -- 4.2 N -- 4.3 Pd -- 4.4 Action Standard.5. SETTING UP THE TEST -- 5.1 Panelists' Instructions -- 5.2 Palate Cleansers -- 5.3 "No-Difference" Option -- 5.4 Retasting Products -- 5.5 Additional Information Given to Panelists -- 5.6 Testing Environment -- 5.7 Action Standard -- 6. ASSESSORS -- 6.1 Health -- 6.2 Motivation -- 6.3 Experience Versus Inexperience -- 6.4 Training -- 6.5 Information Given -- 6.6 Number of Assessors to Invite -- 6.7 Replication -- 7. PRODUCT PREPARATION AND SERVING -- 8. TEST LAYOUT -- 8.1 Practical Example of Procedure to Set Up the Test -- 9. ANALYSIS AND REPORTING -- 9.1 Difference Testing -- 9.2 Similarity Testing -- REFERENCES -- FURTHER READING -- 8 - Two-Out-of-Five Test -- 1. INTRODUCTION -- 2. EXPERIMENTAL DESIGN -- 3. DATA ANALYSIS -- 4. ANALYSIS INTERPRETATION -- 5. TWO-OUT-OF-FIVE METHOD IN USE -- 6. HANDY HINTS -- 7. CASE STUDY 1 -- 8. CASE STUDY 2 -- REFERENCES -- 9 - Tetrad Test -- 1. WHY THE UPSURGE IN POPULARITY OF THE TETRAD? -- 2. WHEN TO USE A TETRAD -- 3. SETTING YOUR OBJECTIVE -- 4. ASSESSORS -- 5. SETTING UP THE TEST -- 5.1 Samples -- 5.2 Test Environment -- 5.3 Experimental Design -- 5.4 Test Instructions -- 5.5 Data Analysis and Interpretation -- 5.6 Reporting -- 6. CASE STUDY -- REFERENCES -- 10 - Duo-Trio -- 1. INTRODUCTION -- 2. ORIGIN -- 3. PRINCIPLE OF THE TEST -- 4. ASSESSORS -- 5. FACILITIES AND BEST PRACTICE -- 6. WHY CHOOSE A DUO-TRIO TEST -- 7. DUO-TRIO ADDITIONAL RESEARCH -- 8. STATISTICS-DEFINITIONS -- 9. CASE STUDIES -- REFERENCES -- FURTHER READING -- 11 - Difference From Control (DFC) Test -- 1. METHOD OUTLINE -- 2. WHY AND WHEN TO USE THIS METHOD -- 2.1 Consumer Testing -- 2.2 Quality Control and Quality Assurance -- 2.3 Shelf Life -- 2.4 Nonhomogeneous Samples -- 2.5 Fatigue -- 2.6 Threshold Testing -- 2.7 Product Claims -- 2.8 Screening -- 3. ADVANTAGES -- 4. DISADVANTAGES -- 5. TEST PROCEDURE -- 6. TEST LAYOUT AND SETUP.6.1 Sample Layout and Questionnaire Example -- 6.2 Sample Presentation -- 6.3 Presentation Order -- 6.4 Sample Labeling -- 6.5 Sample Assessment Procedure -- 6.6 Palate Cleanser -- 6.7 Degree of Difference Scale -- 7. ASSESSORS -- 7.1 Assessor Selection -- 7.2 Level of Training Required -- 7.3 Number of Assessors -- 8. NUMBER OF SAMPLES -- 9. PRACTICALITIES -- 10. REPORTING -- 11. CONSTRAINTS -- 12. CASE STUDIES -- REFERENCES -- 12 - Ranking Test -- 1. METHOD OUTLINE -- 2. WHY AND WHEN TO USE THIS METHOD -- 2.1 Trained Panel Testing-Assessment of Sensory Attributes -- 2.1.1 Panel Screening -- 2.1.2 Panel Training -- 2.1.3 Assessment of Panel Performance -- 2.1.4 Sample Assessment -- 2.2 Consumer Testing -- 2.3 Presorting Samples -- 2.4 Effect of Packaging -- 2.5 Threshold Testing -- 2.6 Working With Young Children -- 3. ADVANTAGES -- 4. DISADVANTAGES -- 5. TEST PROCEDURE -- 5.1 Test Layout and Setup -- 5.2 Sample Layout and Questionnaire Example -- 5.3 Sample Presentation -- 5.4 Presentation Order -- 5.4.1 Complete Block Design -- 5.4.2 Balanced Incomplete Block Design -- 5.5 Sample Labeling -- 5.6 Sample Assessment Procedure -- 5.7 Palate Cleanser -- 6. ASSESSORS -- 6.1 Assessor Selection -- 6.2 Level of Training Required -- 6.3 Number of Assessors (BS ISO 8587:2006+A1:2013, 2013) -- 7. NUMBER OF SAMPLES -- 8. PRACTICALITIES -- 9. REPORTING -- 10. CONSTRAINTS -- 11. OTHER USES -- 11.1 Flash Profiling -- 11.2 Rank-Rating -- 12. CASE STUDIES -- REFERENCES -- 13 - ABX Discrimination Task -- 1. INTRODUCTION -- 2. METHOD OUTLINE -- 3. A BRIEF HISTORY -- 4. ADVANTAGES AND DISADVANTAGES OF THE ABX DISCRIMINATION TASK -- 5. ABX DISCRIMINATION TASK METHODOLOGY -- 5.1 Products and Assessors -- 5.2 Experimental Design -- 5.3 Booth Setup and Running the Test -- 5.4 Reducing Carryover Effects Between Samples -- 5.5 To Retest or Not to Retest?.5.6 A Few Practicalities When Running the Test.edited by Lauren Rogers.Includes bibliographical references at the end of each chapters and index.TestingHandbooks, manuals, etc.Sensory discriminationTesting.TA410 .D573 2017620.110287612.8ISBN 0-08-101009-50-08-101116-4rdaMiAaPQ17072720240506012508.0edoccha_9960161216002883Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl (Revision 1.119 2018/06/21)eng info:srw/schema/1/mods-v3.5 xml 4Master End-To-End Web Application Testing Automation to Accelerate Your QA Process with Cypress (English Edition).Skadorva, Vitaly.texttextElectronic books.bookxxDelhi :Orange Education PVT Ltd,2023.©2023.20231st ed.single uniteng

electronic resource

remote

1 online resource (424 pages)

computer

online resource

Dive into the world of automated web testing with "Ultimate Web Automation Testing with Cypress." From foundational concepts to advanced techniques, the book equips professionals with the skills to seamlessly integrate Cypress into their workflow. Starting with setup and basic tests, it progresses to cover end-to-end, component, API, and data-driven testing with practical examples and best practices. Further, it explores advanced topics like custom commands, plugins, Cypress Cloud, Smart Orchestration and Flaky Test Management. The book also unveils the integration with GitHub, GitLab, and Cucumber, and concludes with CI/CD implementation using Docker and Jenkins Pipelines, along with effective reporting techniques. By the end, you will have a profound understanding of Cypress, empowering you to excel in web application testing and advance your careers in the competitive software testing industry.Intro -- Cover Page -- Title Page -- Copyright Page -- Dedication Page -- About the Author -- About the Technical Reviewer -- Acknowledgements -- Preface -- Errata -- Table of Contents -- 1. Getting Started with Cypress Testing -- Introduction -- Structure -- Introduction to Cypress -- Overview of Cypress -- Advantages of Cypress -- Integration with Modern Web Technologies and Frameworks -- Benefits of using Cypress for automation testing -- Real-time reloading and time-travel debugging -- Automatic waiting and retries -- Simple and easy-to-understand API -- Built-in parallelization and dashboard features -- Integration with CI/CD tools -- Wide range of plugins and community support -- Difference between Cypress and Selenium -- Architecture: Cypress's direct browser access versus Selenium's WebDriver-based approach -- Language Support: JavaScript in Cypress versus multiple languages in Selenium -- Automatic waiting and command retries in Cypress -- Speed and performance comparison -- Ease of setup and learning curve -- Key features of Cypress 12 -- Multiple origins testing with 'cy.origin()' -- Browser context preservation with `cy.session()` -- Test isolation -- Fix for dreaded detached DOM errors -- Conclusion -- Further Reading -- 2. Setting Up the Development Environment -- Introduction -- Structure -- Installing Node.js -- NPM (Node Package Manager) -- Yarn -- Installing Cypress -- Configuring Cypress -- Project structure -- Creating your first Cypress project -- Conclusion -- Further Readings -- 3. Writing Your First Test -- Introduction -- Structure -- Introducing the Cypress Test Runner -- Writing a simple test case -- Using Cypress commands -- Navigating commands -- Querying DOM commands -- Action commands -- Assertion commands -- Network requests commands -- Cookies and local storage commands -- Using Cypress assertions.BDD assertions -- TDD assertions -- Sinon-Chai assertions -- Complex assertions -- Assertion timeout -- Understanding hooks and aliases -- Introducing hooks -- Using aliases -- Scopes of hooks and aliases -- Hooks scope -- Aliases scope -- Best practices for using hooks and aliases -- Dealing with asynchronous operations -- Conclusion -- Further readings -- 4. End-to-End (E2E) Testing -- Introduction -- Structure -- Overview of E2E testing -- The crucial role of E2E testing -- E2E testing with Cypress: A new age in testing -- Testing user interactions -- Clicking and double clicking -- Typing into input fields -- Checking and unchecking boxes -- Selecting options in dropdowns -- Working with events -- Drag and Drop -- Hovering -- File uploads -- Keyboard interactions -- Scrolling -- Right clicking -- Form interactions -- Dealing with popups and alerts -- Working with iframes -- Working with different types of elements -- Text elements -- Input fields -- Buttons -- Links -- Images -- Lists -- Tables -- Scalable vector graphics (SVGs) -- Forms -- Dialog and pop-up windows -- Canvas -- Audio and video elements -- Shadow DOM -- Custom Elements -- Map Elements -- Handling timeouts and retries -- Timeouts -- Automatic retries -- Custom retries -- Best practices for handling timeouts and retries -- Conclusion -- Further readings -- 5. Component Testing -- Introduction -- Structure -- Introduction to component testing -- Types of component testing -- Timing of component testing execution -- Differentiating component testing and unit testing -- Component testing vs end-to-end testing -- Setting up component testing with Cypress -- Writing component tests -- Scaffold React Application -- Testing React components -- Crafting a component -- First component test -- Locating elements and assertions -- Incorporating props into components -- Testing interactions.Testing React components with events -- Testing Angular components -- Building an Angular component -- Component inputs -- Interactions with the component -- Testing Angular component events -- Testing Vue.js components -- Building a Vue.js component -- Locating elements and assertions -- Incorporating props into components -- Testing interactions -- Testing Vue.js components with events -- Best practices for component testing -- Understand the component's functionality -- Isolate the component -- Use descriptive test titles -- Favor integration over snapshot tests -- Test different states -- Test events and side effects -- Keep tests DRY, but not at all costs -- Incorporate accessibility checks -- Continuously run tests in your development environment -- Use a test-first methodology (TDD/BDD) -- Debugging and troubleshooting component tests -- Utilize Cypress's time traveling and real-time reloading -- Use cy.log for custom logging -- Use cy.pause for pausing execution -- Use Cypress's built-in debuggability -- Reviewing test artifacts -- Integrating component tests into your testing workflow -- Running component tests locally -- Running component tests in continuous integration -- Writing component tests -- Running component tests -- Conclusion -- Further readings -- 6. API Testing -- Introduction -- Structure -- Introduction to API testing -- Understanding RESTful APIs -- Exploring GraphQL -- Comparing REST and GraphQL -- Cypress for API Testing -- Testing RESTful APIs -- Testing GraphQL APIs -- Aliasing Multiple Queries or Mutations -- Expectations for Query or Mutation Results -- Modifying a Query or Mutation Response -- Validating API responses -- Conclusion -- Further Readings -- 7. Data-Driven Testing -- Introduction -- Structure -- Overview of data-driven testing -- Data-Driven Testing in Action -- Using JSON Files for Test Data.Reasons for Using JSON Files -- Structuring JSON Files for Test Data -- Reading JSON Files in Cypress -- Implementing Data-Driven Tests with JSON Files -- Reading Data from Databases -- Reasons for Using Databases for Test Data -- Setting up the Database Connection -- Setting up MongoDB Connection -- Setting up MySQL Connection -- Using MongoDB and MySQL Data in Cypress Tests -- Implementing Data-Driven Test Cases -- Segregation of Test Data and Production Data -- Leveraging Realistic Data in Tests -- Minimizing Test Data Duplication -- Employing Cypress Plugins for Database Testing -- Setting up a Test Database -- Connecting Cypress to the Test Database -- Test Cases for CRUD Operations -- Test Case to Verify Data Integrity -- Testing Database Transactions -- Testing Database Migrations -- Conclusion -- Further Reading -- 8. Advanced Cypress Techniques -- Introduction -- Structure -- Cypress custom commands -- Creating a custom command -- Using a custom command -- Custom command overwrites -- Asynchronous custom commands -- Chaining custom commands -- Passing options to custom commands -- Custom commands with aliases -- Validating custom commands -- Use cases for custom commands -- Overriding existing commands -- Handling errors in custom commands -- Debugging custom commands -- Best practices for custom commands -- Using videos and screenshots for debugging -- Debugging with screenshots -- Debugging with videos -- Using screenshots and videos effectively -- Working with Cypress plugins -- Configuration -- Preprocessors -- Run lifecycle -- Spec lifecycle -- Browser launching -- Screenshot handling -- cy.task -- List of plugins -- Crafting a plugin -- Custom plugin examples -- Interacting with a database -- Plugin Events -- Environment variables -- Browser launch API -- Custom Webpack preprocessor -- Existing Cypress plugin examples.cypress-cucumber-preprocessor -- cypress-axe -- Handling authentication and authorization -- Authentication vs authorization -- Approaches to testing authentication and authorization -- Testing the UI -- Programmatic login -- Handling authorization -- Testing API authorization -- Authentication by visiting a different domain with cy.origin() -- Programmatic login using Auth0 authentication -- Parallel test execution -- Using CI/CD tools for parallelization -- Parallelization beyond the Dashboard: plugins -- cypress-parallel -- cypress-split -- Cross-browser testing -- Running tests in a specific browser -- Running tests in all supported browsers -- Electron browser: an integral part of Cypress -- Chrome browsers -- Firefox browsers -- Managing test flakiness across different browsers -- Comparing browser behaviors -- WebKit (experimental) -- Network stubbing and mocking -- Using the cy.intercept() command -- Intercepting responses and asserting with cy.wait() -- POST request stubbing -- Wildcards and glob patterns -- Visual regression testing -- Setting up cypress-image-snapshot plugin -- Creating your first visual test -- Dealing with dynamic content -- Image comparison strategies -- Setting up cypress-visual-regression -- Basic usage of cypress-visual-regression -- Dealing with dynamic content -- Customizing cypress-visual-regression -- Conclusion -- Further Reading -- 9. Cypress Cloud, Smart Orchestration, and Flaky Test Management -- Introduction -- Structure -- Introduction to Cypress Cloud -- Understanding Cypress Cloud -- Key features of Cypress Cloud -- Detailed test recording and optimized management -- Smart Orchestration in Cypress -- Introduction to Smart Orchestration -- Parallelization -- Load Balancing -- Spec Prioritization -- Run Cancellation -- Managing flaky tests -- Network instability -- Concurrency issues.Test order dependency.Skadorva, VitalyDelhi : Orange Education PVT Ltd,c202397881967826961414456642https://ebookcentral.proquest.com/lib/huberlin-ebooks/detail.action?docID=31011472rdaMiAaPQ24122920250207083542.0almahu_9949927123002882Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl (Revision 1.119 2018/06/21)eng info:srw/schema/1/mods-v3.5 xml 5Atwa, Omar Salah,author.texttextbookenkLondon, England :Academic Press,[2019]©20192019single uniteng

electronic resource

remote

1 online resource (420 pages)

computer

online resource

Practical Power System and Protective Relays Commissioning is a unique collection of the most important developments in the field of power system setup. It includes simple explanations and cost affordable models for operating engineers. The book explains the theory of power system components in a simple, clear method that also shows how to apply different commissioning tests for different protective relays. The book discusses scheduling for substation commissioning and how to manage available resources to efficiently complete projects on budget and with optimal use of resources.- Explains the theory of power system components and how to set the different types of relays- Discusses the time schedule for substation commissioning and how to manage available resources and cost implications- Details worked examples and illustrates best practicesFront Cover -- Practical Power System and Protective Relays Commissioning -- Copyright Page -- Contents -- Introduction -- 1 Power System Elements -- 1.1 Introduction -- 1.2 Overview of a Power System -- 1.2.1 Generation of Power -- 1.2.2 Transmission System -- 1.2.3 Distribution System -- 1.2.4 Loads -- 1.3 System Voltages -- 1.4 Power System Components -- 1.5 IEEE Device Numbers and Functions for Switchgear Apparatus -- 2 Substations -- 2.1 Introduction -- 2.2 Substation Electrical Diagrams -- 2.2.1 Single Line Diagram -- 2.2.2 Schematic/Elementary Diagram -- 2.2.3 Connection or Wiring Diagram -- 2.2.4 Interconnection Diagram -- 2.3 Substation and Busbar Layouts -- 2.3.1 Single Busbar Arrangement -- 2.3.2 Double Busbar/One Circuit Breaker Arrangement -- 2.3.3 Sectioning of Busbar Arrangement -- 2.3.4 Ring Busbar Arrangement -- 2.3.5 One and Half Breaker Arrangement -- 2.3.6 Double Busbar, Double Breaker Arrangement -- 2.3.7 Interconnected Mesh Corners Arrangement -- 2.4 Load Break Switches -- 2.5 Switchgear in Generating Stations -- 2.5.1 Main Switchgear Schemes -- 2.5.2 Auxiliary Switchgear -- 2.5.2.1 Unit system of generator -- 2.5.2.2 Unit scheme employing generator circuit breaker -- 3 Introduction to Testing and Commissioning of Power System -- 3.1 Introduction -- 3.1.1 Precommissioning Procedures -- 3.1.2 Commissioning Management -- 3.2 Power Transformer Commissioning -- 3.2.1 Visual Check -- 3.2.2 Electrical Tests -- 3.3 Surge Arrestor Test -- 3.3.1 Visual Checks -- 3.3.2 Electrical Tests -- 3.4 Current Transformer Commissioning Tests -- 3.4.1 Visual Checks -- 3.4.2 Commissioning Electrical Tests -- 3.5 Voltage Transformer Commissioning Tests -- 3.5.1 Visual Checks -- 3.5.2 Electrical Commissioning Tests -- 3.6 Gas Insulated Switchgear Commissioning Test -- 3.6.1 Visual Check and Mechanical Tests -- 3.6.2 Electrical Tests.3.7 High Voltage Cables Commissioning Tests -- 3.7.1 Visual Checks -- 3.7.2 Electrical Tests -- 3.8 Protection and Control Panels Commissioning Tests -- 3.8.1 Visual Check -- 3.8.2 Electrical Tests -- 3.9 Final Energization Commissioning Procedures -- 3.10 AC Distribution Panel Commissioning Tests -- 3.10.1 Visual Checks -- 3.10.2 Electrical Tests -- 3.11 DC Distribution Panels Commissioning Tests -- 3.11.1 Visual Check -- 3.11.2 Electrical Tests -- 3.12 Battery Commissioning Tests -- 3.12.1 Visual Check -- 3.12.2 Electrical Tests -- 3.13 Battery Charger Commissioning Tests -- 3.13.1 Visual Checks -- 3.13.2 Electrical Tests -- 4 Generators and Motors: Theory and Testing -- 4.1 Introduction -- 4.2 Generating Stations -- 4.2.1 Hydro Power Stations -- 4.2.2 Thermal Power Stations -- 4.2.3 Nuclear Power Stations -- 4.3 Renewable Power Systems -- 4.3.1 Introduction -- 4.3.2 Renewable Energy -- 4.3.3 Types of Renewable Energy -- 4.3.3.1 Solar Energy -- 4.3.3.2 Wind Energy -- 4.3.3.2.1 Wind Turbine Power System Protection Zones -- 4.3.3.3 Geothermal Energy -- 4.3.3.4 Biomass Energy -- 4.3.3.5 Ocean or Tidal Energy -- 4.3.3.6 Hydro-electric Energy -- 4.4 Synchronous Generators: Theory and Construction -- 4.4.1 Synchronous Generator Excitation System -- 4.4.2 Synchronous Generator Ratings -- 4.4.3 Steady-State Stability and Transient Stability of Synchronous Generators -- 4.4.4 Power Angle of Synchronous Machines -- 4.4.5 Excitation Response -- 4.4.6 Excitation Ceiling Voltage -- 4.5 Generator Connection in Power Stations -- 4.6 Synchronizing of Synchronous Generator With Busbars -- 4.7 Installation and Commissioning of Synchronous Generators -- 4.7.1 The Pre-start Commissioning Tests of Synchronous Generators -- 4.8 Synchronous Motors Theory -- 4.9 Three-Phase Induction Motors Theory -- 4.10 The Pre-start Commissioning Tests of Induction Motors.5 Power Transformers Theory Testing and Commissioning -- 5.1 Introduction -- 5.2 Transformer Construction -- 5.3 Transformer Cooling System -- 5.4 Transformer Theory and Circuit Analysis -- 5.4.1 Transformers and Overexcitation -- 5.5 Power Transformer Installation -- 5.5.1 Transportation -- 5.5.2 Site Inspections -- 5.5.3 Transformer Storage -- 5.6 Power Transformer Testing and Commissioning -- 5.6.1 Measurement of Winding Insulation Resistance -- 5.6.2 Measurement of Voltage Ratio Test -- 5.6.3 Determination of Transformer Vector Group Test -- 5.6.4 Winding Resistance Test -- 5.6.5 Measurement of No-Load Current and No-Load Circuit Losses Test -- 5.6.6 Measurement of Load Losses: Current and Impedance Voltage Test -- 5.6.7 Temperature Rise Test -- 5.6.8 Transformer Oil Breakdown Test -- 5.6.9 Measurement of Capacitance and Tan δ -- 5.6.10 Frequency Response Analysis -- 5.6.11 Partial Discharge Measurement -- 5.7 Commissioning Tests for Power Transformers at Site -- 5.7.1 General -- 5.7.2 Primary Tests -- 5.7.3 Secondary Tests -- 5.7.4 Tripping Tests -- 5.7.5 Load Test -- 6 Transmission Lines Theory Testing and Commissioning -- 6.1 Introduction -- 6.2 Overhead AC Lines -- 6.2.1 Electrical Characteristics of AC Transmission Lines -- 6.3 Underground Cables -- 6.3.1 High-Voltage Cables -- 6.3.2 High-Voltage Cables: End Terminations -- 6.4 Testing and Commissioning of Extra-High-Voltage and High-Voltage Cables at Site -- 6.4.1 Continuity and Phasing Checks -- 6.4.2 DC Contact Resistance of Cable Phase Conductors -- 6.4.3 DC Insulation Sheath Test -- 6.4.4 Cable Insulation Resistance Test -- 6.4.5 Cable Capacitance Test -- 6.4.6 Verification of Cross Bonding Test of Metallic Sheath of Cable -- 6.4.7 Measurements of Cable Positive Sequence Impedance -- 6.4.8 Measurements of Cable Zero Sequence Impedance -- 6.4.9 Sheath Voltage Limit Test.6.4.10 High-Voltage Resonant AC Test for 132kV Cables and Above -- 6.5 High Voltage DC Power Systems Transmission -- 6.5.1 Introduction -- 6.5.2 Construction of DC Transmission -- 6.5.2.1 Monopolar links -- 6.5.2.2 Bipolar links -- 6.5.2.3 Homopolar links -- 6.5.3 DC Transmission Components -- 6.5.4 High-Voltage DC Protection System -- 7 Circuit Breakers Theory Testing and Commissioning -- 7.1 Introduction -- 7.2 Principle of Arc Interruption -- 7.3 Circuit Breaker Types Based on Insulating Medium -- 7.3.1 Air Circuit Breaker -- 7.3.2 Oil Circuit Breaker -- 7.3.3 Vacuum Circuit Breaker -- 7.3.4 SF6 Circuit Breaker -- 7.3.4.1 Properties of SF6 Gas -- 7.3.4.2 Contaminants -- 7.3.4.3 Related Standards -- 7.3.4.4 Precautions -- 7.3.4.5 Testing for Contamination -- 7.4 Circuit Breaker Operating Mechanism -- 7.5 Circuit Breaker Controls -- 7.5.1 Electrical Control -- 7.6 Circuit Breaker Testing -- 7.6.1 Contact Resistance Testing -- 7.6.2 Insulation Resistance Testing -- 7.6.3 High-Voltage Test -- 7.6.4 Circuit Breaker Timing Test -- 7.6.5 Reduced Voltage Test -- 8 Air Insulated System Substations Theory and Testing -- 8.1 Introduction -- 8.2 Testing of the AIS-Components -- 9 Surge Arresters Theory Testing and Commissioning -- 9.1 Introduction -- 9.2 Testing of Surge Arresters -- 10 Traditional and Electronic Current Transformers Theory Testing and Commissioning -- 10.1 Introduction -- 10.2 Current Transformer Equivalent Circuit -- 10.3 Current Transformer Magnetization Curve -- 10.4 Current Transformer Accuracy Classes -- 10.4.1 Metering Current Transformer Accuracy Classes -- 10.4.2 Protection Current Transformer Accuracy Classes -- 10.4.3 Current Transformer Open Circuited Secondary Winding -- 10.5 Types of Current Transformers -- 10.5.1 Wound Primary Type Current Transformer -- 10.5.2 Bar Primary Type Current Transformer (Resin-Embedded).10.5.3 Bushing-Type Current Transformers -- 10.5.4 Air-Gapped Current Transformers -- 10.5.5 Transient Performance Current Transformers -- 10.5.5.1 TPY Class -- 10.5.5.2 TPZ Class -- TPS Class -- TPX Class -- TPY Class -- TPZ Class -- 10.5.6 Linear Coupler Current Transformers -- 10.6 Current Transformers Connections -- 10.7 Current Transformer Knee Point -- 10.8 Optical Current and Voltage Transformer -- 10.8.1 Advantages of Optical Instruments -- 10.9 Current Transformer Commissioning Testing -- 10.9.1 Visual Checks -- 10.9.2 Commissioning Electrical Tests -- 10.9.2.1 Insulation Resistance Test -- 10.9.2.2 Winding Resistance Test -- 10.9.2.3 Polarity Test -- 10.9.2.4 Ratio Test by Primary Injection -- 10.9.2.5 Magnetizing Current Test -- 10.9.2.6 Loop Resistance Burden Test -- 10.9.2.7 Continuity of Secondary Circuits -- 10.9.2.8 High Voltage Test -- 10.9.2.9 Demagnetizing the CT Cores -- 11 Voltage Transformers -- 11.1 Introduction -- 11.2 Principle of Operation of Electromagnetic Voltage Transformers -- 11.3 Principle of Operation of Capacitive Voltage Transformers -- 11.4 Burdens and Accuracy Classes -- 11.5 Types and Three-Phase Connections of Voltage Transformers -- 11.6 Optical Current and Voltage Transformers -- 11.6.1 Advantages of Optical Instruments -- 11.7 Voltage Transformer Testing -- 11.7.1 Visual Check -- 11.7.2 Insulation Resistance Test -- 11.7.3 Polarity (Flick) Test -- 11.7.4 Voltage Transformer Ratio Test -- 11.7.5 Winding Resistance Test -- 11.7.6 Loop Resistance Burden Test -- 12 Disconnecting Switches and Earthing Switches Theory Testing and Commissioning -- 12.1 Introduction -- 12.1.1 Load Break Switches -- 12.1.2 High-Speed Earthing Switches -- 12.2 Disconnect Switches/Earth (Grounding) Switches Tests -- 13 Fault Recorders in Substations and Power Stations -- 13.1 Introduction -- 13.2 Fault Recorder Testing.14 Gas Insulated System Substations.Omar Salah Atwa.Protective relays.Electric generatorsProtection.Electric power systemsProtection.TK2861 .A893 2019621.317621.319780128173121012817312297801281685850128168587rdaMiAaPQ19052720240509041011.0almafu_9960074272002883Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl (Revision 1.119 2018/06/21)eng info:srw/schema/1/mods-v3.5 xml 62,Practical aspects /Homès, Bernard,author.textbibliographytextElectronic books.enkLondon, UK :ISTE Ltd. ;Hoboken, NJ :John Wiley & Sons, Inc.,2022.2022single uniteng

electronic resource

remote

1 online resource (304 pages) : illustrations

computer

online resource

As a society today, we are so dependent on systems-of-systems that any malfunction has devastating consequences, both human and financial. Their technical design, functional complexity and numerous interfaces justify a significant investment in testing in order to limit anomalies and malfunctions. Based on more than 40 years of practice, this book goes beyond the simple testing of an application - already extensively covered by other authors - to focus on methodologies, techniques, continuous improvement processes, load estimates, metrics and reporting, which are illustrated by a case study. It also discusses several challenges for the near future. Pragmatic and clear, this book displays many examples and references that will help you improve the quality of your systemsof-systems efficiently and effectively and lead you to identify the impact of upstream decisions and their consequences. Advanced Testing of Systems-of-Systems 2 deals with the practical implementation and use of the techniques and methodologies proposed in the first volume.Cover -- Title Page -- Copyright Page -- Contents -- Title Page -- Copyright Page -- Contents -- Dedication and Acknowledgments -- Preface -- Chapter 1. Test Project Management -- 1.1. General principles -- 1.1.1. Quality of requirements -- 1.1.2. Completeness of deliveries -- 1.1.3. Availability of test environments -- 1.1.4. Availability of test data -- 1.1.5. Compliance of deliveries and schedules -- 1.1.6. Coordinating and setting up environments -- 1.1.7. Validation of prerequisites -- Test Readiness Review (TRR) -- 1.1.8. Delivery of datasets (TDS) -- 1.1.9. Go-NoGo decision -- Test Review Board (TRB) -- 1.1.10. Continuous delivery and deployment -- 1.2. Tracking test projects -- 1.3. Risks and systems-of-systems -- 1.4. Particularities related to SoS -- 1.5. Particularities related to SoS methodologies -- 1.5.1. Components definition -- 1.5.2. Testing and quality assurance activities -- 1.6. Particularities related to teams -- Chapter 2. Testing Process -- 2.1. Organization -- 2.2. Planning -- 2.2.1. Project WBS and planning -- 2.3. Control of test activities -- 2.4. Analyze -- 2.5. Design -- 2.6. Implementation -- 2.7. Test execution -- 2.8. Evaluation -- 2.9. Reporting -- 2.10. Closure -- 2.11. Infrastructure management -- 2.12. Reviews -- 2.13. Adapting processes -- 2.14. RACI matrix -- 2.15. Automation of processes or tests -- 2.15.1. Automate or industrialize? -- 2.15.2. What to automate? -- 2.15.3. Selecting what to automate -- Chapter 3. Continuous Process Improvement -- 3.1. Modeling improvements -- 3.1.1. PDCA and IDEAL -- 3.1.2. CTP -- 3.1.3. SMART -- 3.2. Why and how to improve? -- 3.3. Improvement methods -- 3.3.1. External/internal referential -- 3.4. Process quality -- 3.4.1. Fault seeding -- 3.4.2. Statistics -- 3.4.3. A posteriori -- 3.4.4. Avoiding introduction of defects -- 3.5. Effectiveness of improvement activities.3.6. Recommendations -- Chapter 4. Test, QA or IV&amp -- V Teams -- 4.1. Need for a test team -- 4.2. Characteristics of a good test team -- 4.3. Ideal test team profile -- 4.4. Team evaluation -- 4.4.1. Skills assessment table -- 4.4.2. Composition -- 4.4.3. Select, hire and retain -- 4.5. Test manager -- 4.5.1. Lead or direct? -- 4.5.2. Evaluate and measure -- 4.5.3. Recurring questions for test managers -- 4.6. Test analyst -- 4.7. Technical test analyst -- 4.8. Test automator -- 4.9. Test technician -- 4.10. Choose our testers -- 4.11. Training, certification or experience? -- 4.12. Hire or subcontract) -- 4.12.1. Effective subcontracting -- 4.13. Organization of multi-level test teams -- 4.13.1. Compliance, strategy and organization -- 4.13.2. Unit test teams (UT/CT) -- 4.13.3. Integration testing team (IT) -- 4.13.4. System test team (SYST) -- 4.13.5. Acceptance testing team (UAT) -- 4.13.6. Technical test teams (TT) -- 4.14. Insourcing and outsourcing challenges -- 4.14.1. Internalization and collocation -- 4.14.2. Near outsourcing -- 4.14.3. Geographically distant outsourcing -- Chapter 5. Test Workload Estimation -- 5.1. Difficulty to estimate workload -- 5.2. Evaluation techniques -- 5.2.1. Experience-based estimation -- 5.2.2. Based on function points or TPA -- 5.2.3. Requirements scope creep -- 5.2.4. Estimations based on historical data -- 5.2.5. WBS or TBS -- 5.2.6. Agility, estimation and velocity -- 5.2.7. Retroplanning -- 5.2.8. Ratio between developers -- testers -- 5.2.9. Elements influencing the estimate -- 5.3. Test workload overview -- 5.3.1. Workload assessment verification and validation -- 5.3.2. Some values -- 5.4. Understanding the test workload -- 5.4.1. Component coverage -- 5.4.2. Feature coverage -- 5.4.3. Technical coverage -- 5.4.4. Test campaign preparation -- 5.4.5. Running test campaigns -- 5.4.6. Defects management.5.5. Defending our test workload estimate -- 5.6. Multi-tasking and crunch -- 5.7. Adapting and tracking the test workload -- Chapter 6. Metrics, KPI and Measurements -- 6.1. Selecting metrics -- 6.2. Metrics precision -- 6.2.1. Special case of the cost of defaults -- 6.2.2. Special case of defects -- 6.2.3. Accuracy or order of magnitude? -- 6.2.4. Measurement frequency -- 6.2.5. Using metrics -- 6.2.6. Continuous improvement of metrics -- 6.3. Product metrics -- 6.3.1. FTR: first time right -- 6.3.2. Coverage rate -- 6.3.3. Code churn -- 6.4. Process metrics -- 6.4.1. Effectiveness metrics -- 6.4.2. Efficiency metrics -- 6.5. Definition of metrics -- 6.5.1. Quality model metrics -- 6.6. Validation of metrics and measures -- 6.6.1. Baseline -- 6.6.2. Historical data -- 6.6.3. Periodic improvements -- 6.7. Measurement reporting -- 6.7.1. Internal test reporting -- 6.7.2. Reporting to the development team -- 6.7.3. Reporting to the management -- 6.7.4. Reporting to the clients or product owners -- 6.7.5. Reporting to the direction and upper management -- Chapter 7. Requirements Management -- 7.1. Requirements documents -- 7.2. Qualities of requirements -- 7.3. Good practices in requirements management -- 7.3.1. Elicitation -- 7.3.2. Analysis -- 7.3.3. Specifications -- 7.3.4. Approval and validation -- 7.3.5. Requirements management -- 7.3.6. Requirements and business knowledge management -- 7.3.7. Requirements and project management -- 7.4. Levels of requirements -- 7.5. Completeness of requirements -- 7.5.1. Management of TBDs and TBCs -- 7.5.2. Avoiding incompleteness -- 7.6. Requirements and agility -- 7.7. Requirements issues -- Chapter 8. Defects Management -- 8.1. Defect management, MOA and MOE -- 8.1.1. What is a defect? -- 8.1.2. Defects and MOA -- 8.1.3. Defects and MOE -- 8.2. Defect management workflow -- 8.2.1. Example -- 8.2.2. Simplify.8.3. Triage meetings -- 8.3.1. Priority and severity of defects -- 8.3.2. Defect detection -- 8.3.3. Correction and urgency -- 8.3.4. Compliance with processes -- 8.4. Specificities of TDDs, ATDDs and BDDs -- 8.4.1. TDD: test-driven development -- 8.4.2. ATDD and BDD -- 8.5. Defects reporting -- 8.5.1. Defects backlog management -- 8.6. Other useful reporting -- 8.7. Don't forget minor defects -- Chapter 9. Configuration Management -- 9.1. Why manage configuration? -- 9.2. Impact of configuration management -- 9.3. Components -- 9.4. Processes -- 9.5. Organization and standards -- 9.6. Baseline or stages, branches and merges -- 9.6.1. Stages -- 9.6.2. Branches -- 9.6.3. Merge -- 9.7. Change control board (CCB) -- 9.8. Delivery frequencies -- 9.9. Modularity -- 9.10. Version management -- 9.11. Delivery management -- 9.11.1. Preparing for delivery -- 9.11.2. Delivery validation -- 9.12. Configuration management and deployments -- Chapter 10. Test Tools and Test Automation -- 10.1. Objectives of test automation -- 10.1.1. Find more defects -- 10.1.2. Automating dynamic tests -- 10.1.3. Find all regressions -- 10.1.4. Run test campaigns faster -- 10.2. Test tool challenges -- 10.2.1. Positioning test automation -- 10.2.2. Test process analysis -- 10.2.3. Test tool integration -- 10.2.4. Qualification of tools -- 10.2.5. Synchronizing test cases -- 10.2.6. Managing test data -- 10.2.7. Managing reporting (level of trust in test tools) -- 10.3. What to automate? -- 10.4. Test tooling -- 10.4.1. Selecting tools -- 10.4.2. Computing the return on investment (ROI) -- 10.4.3. Avoiding abandonment of tools and automation -- 10.5. Automated testing strategies -- 10.6. Test automation challenge for SoS -- 10.6.1. Mastering test automation -- 10.6.2. Preparing test automation -- 10.6.3. Defect injection/fault seeding.10.7. Typology of test tools and their specific challenges -- 10.7.1. Static test tools versus dynamic test tools -- 10.7.2. Data-driven testing (DDT) -- 10.7.3. Keyword-driven testing (KDT) -- 10.7.4. Model-based testing (MBT) -- 10.8. Automated regression testing -- 10.8.1. Regression tests in builds -- 10.8.2. Regression tests when environments change -- 10.8.3. Prevalidation regression tests, sanity checks and smoke tests -- 10.8.4. What to automate? -- 10.8.5. Test frameworks -- 10.8.6. E2E test cases -- 10.8.7. Automated test case maintenance or not? -- 10.9. Reporting -- 10.9.1. Automated reporting for the test manager -- Chapter 11. Standards and Regulations -- 11.1. Definition of standards -- 11.2. Usefulness and interest -- 11.3. Implementation -- 11.4. Demonstration of compliance -- IADT -- 11.5. Pseudo-standards and good practices -- 11.6. Adapting standards to needs -- 11.7. Standards and procedures -- 11.8. Internal and external coherence of standards -- Chapter 12. Case Study -- 12.1. Case study: improvement of an existing complex system -- 12.1.1. Context and organization -- 12.1.2. Risks, characteristics and business domains -- 12.1.3. Approach and environment -- 12.1.4. Resources, tools and personnel -- 12.1.5. Deliverables, reporting and documentation -- 12.1.6. Planning and progress -- 12.1.7. Logistics and campaigns -- 12.1.8. Test techniques -- 12.1.9. Conclusions and return on experience -- Chapter 13. Future Testing Challenges -- 13.1. Technical debt -- 13.1.1. Origin of the technical debt -- 13.1.2. Technical debt elements -- 13.1.3. Measuring technical debt -- 13.1.4. Reducing technical debt -- 13.2. Systems-of-systems specific challenges -- 13.3. Correct project management -- 13.4. DevOps -- 13.4.1. DevOps ideals -- 13.4.2. DevOps-specific challenges -- 13.5. IoT (Internet of Things) -- 13.6. Big Data.Bernard Homès.Includes bibliographical references and index.Computer softwareTesting.Computer softwareTesting.QA76.76.T48005.1/4Homès, Bernard.London : Wiley-ISTE, 2023ISBN 9781786307507(OCoLC)1363816658978139418846813941884639781394188482139418848X9781786307507178630750210.1002/97813941884821371296200on13712962009781786307507 O'Reilly Mediahttps://onlinelibrary.wiley.com/doi/book/10.1002/9781394188482rdaORMDA23022820250205234621.0almahu_9949501384802882Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl (Revision 1.119 2018/06/21)eng info:srw/schema/1/mods-v3.5 xml 7build a healthy codebase /Rappin, Noel,author.Dvorak, Katharine,editor.textbibliographytextncuRaleigh, North Carolina :The Pragmatic Bookshelf,2018.©201820182018Version: P1.0 (February 2018).single uniteng

electronic resource

remote

1 online resource (388 pages) : illustrations.

computer

online resource

Does your Rails code suffer from bloat, brittleness, or inaccuracy? Cure these problems with the regular application of test-driven development. You'll use Rails 5.1, Minitest 5, and RSpec 3.6, as well as popular testing libraries such as factory_girl and Cucumber. Updates include Rails 5.1 system tests and Webpack integration. Do what the doctor ordered to make your applications feel all better. Side effects may include better code, fewer bugs, and happier developers. Your Ruby on Rails application is sick. Deadlines are looming, but every time you make the slightest change to the code, something else breaks. Nobody remembers what that tricky piece of code was supposed to do, and nobody can tell what it actually does. Plus, it has bugs. You need test-driven development: a process for improving the design, maintainability, and long-term viability of software. With both practical code examples and discussion of why testing works, this book starts with the most basic features delivered as part of core Ruby on Rails. Once you've integrated those features into your coding practice, work with popular third-party testing tools such as RSpec, Jasmine, Cucumber, and factory_girl. Test the component parts of a Rails application, including the back-end model logic and the front-end display logic. With Rails examples, use testing to enable your code to respond better to future change. Plus, see how to handle real-world testing situations. This new edition has been updated to Rails 5.1 and RSpec 3.6 and contains full coverage of new Rails features, including system tests and the Webpack-based JavaScript setup. What You Need: Ruby 2.4, Rails 5.1Cover -- Table of Contents -- Acknowledgments -- Preface -- Who You Are -- What's in This Book -- What You'll Need -- A Word About Tools, Best Practices, and Teaching TDD -- Changes in This Edition -- Online Resources -- 1. A Test-Driven Fable -- Testing First Drives Design -- What Is TDD Good For? -- When TDD Needs Some Help -- What You've Done -- 2. Test-Driven Development Basics -- Infrastructure -- The Requirements -- Installing RSpec -- Where to Start? -- Running the Test -- Making the Test Pass -- The Second Test -- Back on Task -- Adding Some Math -- The First Date -- Using the Time Data -- What You've Done -- 3. Test-Driven Rails -- Let's Write Some Rails -- The Days Are Action-Packed -- Who Controls the Controller? -- A Test with a View -- Testing for Failure -- What You've Done -- 4. What Makes Great Tests -- The Big One -- Cost and Value -- SWIFT: The Five Qualities of Valuable Tests -- What You've Done -- 5. Testing Models -- What Can You Do in a Model Test? -- What Should You Test in a Model Test? -- Okay, Funny Man, What Makes a Good Set of Model Tests? -- Refactoring Models -- A Note on Assertions per Test -- Testing What Rails Gives You -- Testing ActiveRecord Finders -- Testing Shared Modules and ActiveSupport Concerns -- Writing Your Own RSpec Matchers -- What You've Done -- 6. Adding Data to Tests -- What's the Problem? -- Fixtures -- Factories -- Dates and Times -- What You've Done -- 7. Using Test Doubles as Mocks and Stubs -- Test Doubles Defined -- Creating Stubs -- Mock Expectations -- Using Mocks to Simulate Database Failure -- Using Mocks to Specify Behavior -- More Expectation Annotations -- Mock Tips -- What You've Done -- 8. Integration Testing with Capybara and Cucumber -- A Field Guide to Integration and System Tests -- Setting Up Capybara -- Using Feature Tests to Build a Feature.What to Test in an RSpec System Test -- Outside-in Testing -- Making the Capybara Test Pass -- Retrospective -- Setting Up Cucumber -- Writing Cucumber Features -- Writing Cucumber Steps -- Advanced Cucumber -- Is Cucumber Worth It? -- What You've Done -- 9. Testing JavaScript: Integration Testing -- Integration-Testing JavaScript with Capybara -- Let's Talk About Drivers -- Making the Test Pass -- Webpack in Developer Mode -- What You've Done -- 10. Unit-Testing JavaScript -- Setting Up JavaScript Unit Tests -- Writing a Sample Test -- TDD in JavaScript -- Jasmine Matchers -- Testing Ajax Calls -- Using testdouble.js -- Connecting the JavaScript to the Server Code -- What You've Done -- 11. Testing Rails Display Elements -- Testing Routes -- Testing Helper Methods -- Testing Controllers and Requests -- Simulating Requests -- What to Expect in a Request Spec -- Older Rails Controller Tests -- Testing Mailers -- Testing Views and View Markup -- Using Presenters -- Testing Jobs and Cables -- What You've Done -- 12. Minitest -- Getting Started with Minitest -- Minitest Basics -- Running Minitest -- Minitest Setup -- Mocha -- System Tests and Others -- Minitest Helper Tests -- Minitest and Routing -- What You've Done -- 13. Testing for Security -- User Authentication and Authorization -- Adding Users and Roles -- Restricting Access -- More Access-Control Testing -- Using Roles -- Protection Against Form Modification -- Mass Assignment Testing -- Other Security Resources -- What You've Done -- 14. Testing External Services -- External Testing Strategy -- The Service Integration Test -- Introducing VCR -- Client Unit Tests -- Why an Adapter? -- Adapter Tests -- Testing for Error Cases -- Smoke Tests and VCR Options -- The World Is a Service -- What You've Done -- 15. Troubleshooting and Debugging -- General Principles -- The Humble Print Statement.Git Bisect -- RSpec or Minitest Bisect -- Pry -- Common Rails Gotchas -- What You've Done -- 16. Running Tests Faster and Running Faster Tests -- Running Smaller Groups of Tests -- Running Rails in the Background -- Running Tests Automatically with Guard -- Writing Faster Tests by Bypassing Rails -- Recommendations for Faster Tests -- What You've Done -- 17. Testing Legacy Code -- What's a Legacy? -- Set Expectations -- Getting Started with Legacy Code -- Test-Driven Exploration -- Dependency Removal -- Find the Seam -- Don't Look Back -- What You've Done -- Bibliography -- Index -- - SYMBOLS - -- - A - -- - B - -- - C - -- - D - -- - E - -- - F - -- - G - -- - H - -- - I - -- - J - -- - K - -- - L - -- - M - -- - N - -- - O - -- - P - -- - Q - -- - R - -- - S - -- - T - -- - U - -- - V - -- - W - -- - X - -- - Y -.Noel Rappin ; edited by Katharine Dvorak.Includes bibliographical references and index.Ruby on rails (Electronic resource)Web site development.TK5105.8885.R83 .N684 2018005.117005.133978168050557316805055729781680505566168050556497816805055801680505580978168050250316805025061030304591on10303045911505732959rdaMiAaPQ18040620180403104010.0almatuudk_9923195625902884Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl (Revision 1.119 2018/06/21)eng info:srw/schema/1/mods-v3.5 xml 8create higher-quality software by writing tests first with solid and hexagonal architecture /Mellor, Alan,author.texttextbookenkPackt Publishing202320221st ed.single uniteng

electronic resource

remote

1 online resource (348 pages)

computer

online resource

Drive development with automated tests and gain the confidence you need to write high-quality software Key Features Get up and running with common design patterns and TDD best practices Learn to apply the rhythms of TDD - arrange, act, assert and red, green, refactor Understand the challenges of implementing TDD in the Java ecosystem and build a plan Book Description Test-driven development enables developers to craft well-designed code and prevent defects. It's a simple yet powerful tool that helps you focus on your code design, while automatically checking that your code works correctly. Mastering TDD will enable you to effectively utilize design patterns and become a proficient software architect. The book begins by explaining the basics of good code and bad code, bursting common myths, and why Test-driven development is crucial. You'll then gradually move toward building a sample application using TDD, where you'll apply the two key rhythms -- red, green, refactor and arrange, act, assert. Next, you'll learn how to bring external systems such as databases under control by using dependency inversion and test doubles. As you advance, you'll delve into advanced design techniques such as SOLID patterns, refactoring, and hexagonal architecture. You'll also balance your use of fast, repeatable unit tests against integration tests using the test pyramid as a guide. The concluding chapters will show you how to implement TDD in real-world use cases and scenarios and develop a modern REST microservice backed by a Postgres database in Java 17. By the end of this book, you'll be thinking differently about how you design code for simplicity and how correctness can be baked in as you go. What you will learn Discover how to write effective test cases in Java Explore how TDD can be incorporated into crafting software Find out how to write reusable and robust code in Java Uncover common myths about TDD and understand its effectiveness Understand the accurate rhythm of implementing TDD Get to grips with the process of refactoring and see how it affects the TDD process Who this book is for This book is for expert Java developers and software architects crafting high-quality software in Java. Test-Driven Development with Java can be picked up by anyone with a strong working experience in Java who is planning to use Test-driven development for their upcoming projects.Cover -- Title Page -- Copyright and Credit -- Dedicated -- Contributors -- Table of Contents -- Preface -- Part 1: How We Got to TDD -- Chapter 1: Building the Case for TDD -- Writing code badly -- Understanding why bad code is written -- Recognizing bad code -- Bad variable names -- Bad function, method, and class names -- Error-prone constructs -- Coupling and cohesion -- Decreasing team performance -- Diminishing business outcomes -- Summary -- Questions and answers -- Further reading -- Chapter 2: Using TDD to Create Good Code -- Designing good quality code -- Say what you mean, mean what you say -- Take care of the details in private -- Avoid accidental complexity -- Revealing design flaws -- Analyzing the benefits of writing tests before production code -- Preventing logic flaws -- Protecting against future defects -- Documenting our code -- Summary -- Questions and answers -- Further reading -- Chapter 3: Dispelling Common Myths about TDD -- Writing tests slows me down -- Understanding the benefits of slowing down -- Overcoming objections to tests slowing us down -- Tests cannot prevent every bug -- Understanding why people say tests cannot catch every bug -- Overcoming objections to not catching every bug -- How do you know the tests are right? -- Understanding the concerns behind writing broken tests -- Providing reassurance that we test our tests -- TDD guarantees good code -- Understanding problem-inflated expectations -- Managing your expectations of TDD -- Our code is too complex to test -- Understanding the causes of untestable code -- Reframing the relationship between good design and simple tests -- Managing legacy code without tests -- I don't know what to test until I write the code -- Understanding the difficulty of starting with testing -- Overcoming the need to write production code first -- Summary.Questions and answers -- Further reading -- Part 2: TDD Techniques -- Chapter 4: Building an Application Using TDD -- Technical requirements -- Preparing our development environment -- Installing the IntelliJ IDE -- Setting up the Java project and libraries -- Introducing the Wordz application -- Describing the rules of Wordz -- Exploring agile methods -- Reading user stories - the building block of planning -- Combining agile development with TDD -- Summary -- Questions and answers -- Further reading -- Chapter 5: Writing Our First Test -- Technical requirements -- Starting TDD: Arrange-Act-Assert -- Defining the test structure -- Working backward from outcomes -- Increasing workflow efficiency -- Defining a good test -- Applying the FIRST principles -- Using one assert per test -- Deciding on the scope of a unit test -- Catching common errors -- Asserting exceptions -- Only testing public methods -- Preserving encapsulation -- Learning from our tests -- A messy Arrange step -- A messy Act step -- A messy Assert step -- Limitations of unit tests -- Code coverage - an often-meaningless metric -- Writing the wrong tests -- Beginning Wordz -- Summary -- Questions and answers -- Chapter 6: Following the Rhythms of TDD -- Technical requirements -- Following the RGR cycle -- Starting on red -- Keep it simple - moving to green -- Refactoring to clean code -- Writing our next tests for Wordz -- Summary -- Questions and answers -- Further reading -- Chapter 7: Driving Design - TDD and SOLID -- Technical requirements -- Test guide - we drive the design -- SRP - simple building blocks -- Too many responsibilities make code harder to work with -- Ability to reuse code -- Simplified future maintenance -- Counter-example - shapes code that violates SRP -- Applying SRP to simplify future maintenance -- Organizing tests to have a single responsibility.DIP - hiding irrelevant details -- Applying DI to the shapes code -- LSP - swappable objects -- Reviewing LSP usage in the shapes code -- OCP - extensible design -- Adding a new type of shape -- ISP - effective interfaces -- Reviewing ISP usage in the shapes code -- Summary -- Questions and answers -- Chapter 8: Test Doubles - Stubs and Mocks -- Technical requirements -- The problems collaborators present for testing -- The challenges of testing unrepeatable behavior -- The challenges of testing error handling -- Understanding why these collaborations are challenging -- The purpose of test doubles -- Making the production version of the code -- Using stubs for pre-canned results -- When to use stub objects -- Using mocks to verify interactions -- Understanding when test doubles are appropriate -- Avoiding the overuse of mock objects -- Don't mock code you don't own -- Don't mock value objects -- You can't mock without dependency injection -- Don't test the mock -- When to use mock objects -- Working with Mockito - a popular mocking library -- Getting started with Mockito -- Writing a stub with Mockito -- Writing a mock with Mockito -- Blurring the distinction between stubs and mocks -- Argument matchers - customizing behavior of test doubles -- Driving error handling code with tests -- Testing an error condition in Wordz -- Summary -- Questions and answers -- Further reading -- Chapter 9: Hexagonal Architecture -Decoupling External Systems -- Technical requirements -- Why external systems are difficult -- Environmental problems bring trouble -- Accidentally triggering real transactions from tests -- What data should we expect? -- Operating system calls and system time -- Challenges with third-party services -- Dependency inversion to the rescue -- Generalizing this approach to the hexagonal architecture.Overview of the hexagonal architecture's components -- The golden rule - the domain never connects directly to adapters -- Why the hexagon shape? -- Abstracting out the external system -- Deciding what our domain model needs -- Writing the domain code -- Deciding what should be in our domain model -- Using libraries and frameworks in the domain model -- Deciding on a programming approach -- Substituting test doubles for external systems -- Replacing the adapters with test doubles -- Unit testing bigger units -- Unit testing entire user stories -- Wordz - abstracting the database -- Designing the repository interface -- Designing the database and random numbers adapters -- Summary -- Questions and answers -- Further reading -- Chapter 10: FIRST Tests and the Test Pyramid -- Technical requirements -- The test pyramid -- Unit tests - FIRST tests -- Integration tests -- What should an integration test cover? -- Testing database adapters -- Testing web services -- Consumer-driven contract testing -- End-to-end and user acceptance tests -- Acceptance testing tools -- CI/CD pipelines and test environments -- What is a CI/CD pipeline? -- Why do we need continuous integration? -- Why do we need continuous delivery? -- Continuous delivery or continuous deployment? -- Practical CI/CD pipelines -- Test environments -- Testing in production -- Wordz - integration test for our database -- Fetching a word from the database -- Summary -- Questions and answers -- Further reading -- Chapter 11: Exploring TDD with Quality Assurance -- TDD - its place in the bigger quality picture -- Understanding the limits of TDD -- No more need for manual testing? -- Manual exploratory - discovering the unexpected -- Code review and ensemble programming -- User interface and user experience testing -- Testing the user interface -- Evaluating the user experience.Security testing and operations monitoring -- Incorporating manual elements into CI/CD workflows -- Summary -- Questions and answers -- Further reading -- Chapter 12: Test First, Test Later, Test Never -- Adding tests first -- Test-first is a design tool -- Tests form executable specifications -- Test-first provides meaningful code coverage metrics -- Beware of making a code coverage metric a target -- Beware of writing all tests upfront -- Writing tests first helps with continuous delivery -- We can always test it later, right? -- Test-later is easier for a beginner to TDD -- Test-later makes it harder to test every code path -- Test-later makes it harder to influence the software design -- Test-later may never happen -- Tests? They're for people who can't write code! -- What happens if we do not test during development? -- Testing from the inside out -- Testing from the outside in -- Defining test boundaries with hexagonal architecture -- Inside-out works well with the domain model -- Outside-in works well with adapters -- User stories can be tested across the domain model -- Summary -- Questions and answers -- Further reading -- Part 3: Real-World TDD -- Chapter 13: Driving the Domain Layer -- Technical requirements -- Starting a new game -- Test-driving starting a new game -- Tracking the progress of the game -- Triangulating word selection -- Playing the game -- Designing the scoring interface -- Triangulating game progress tracking -- Ending the game -- Responding to a correct guess -- Triangulating the game over due to too many incorrect guesses -- Triangulating response to guess after game over -- Reviewing our design -- Summary -- Questions and answers -- Further reading -- Chapter 14: Driving the Database Layer -- Technical requirements -- Installing the Postgres database -- Creating a database integration test.Creating a database test with DBRider.Alan Mellor.Includes index.Mellor Alan: Alan Mellor is an academy lead at BJSS, training the next generation of consulting software engineers, and the author of Java OOP Done Right: Create object-oriented code you can be proud of with modern Java. Alan started with a Sinclair ZX81 computer with 1K of RAM and is very happy to have better computers now. Alan's work includes industrial control in C, web applications for e-commerce, gaming, and banking in Java and Go, and document warehousing in C++. His most visible code is part of Nokia Bounce and the RAF Red Arrows flight simulator if you go back far enough.Java (Computer program language)Computer softwareDevelopment.Computer softwareTesting.QA76 .M455 2023929.605ISBN 9781803236230ISBN 180323623X9781803237961180323796110.0000/97818032379611357534122rdaMiAaPQ23020420230204184834.0almatuudk_9923197706502884Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl (Revision 1.119 2018/06/21)eng info:srw/schema/1/mods-v3.5 xml 9For VTU.Mathur, Aditya P.texttextbookxxNoida :Pearson India,2010.©2004.20101st ed.single uniteng

electronic resource

remote

1 online resource (765 pages)

computer

online resource

Foundations of Software Testing presents sound engineering approaches for software test generation, selection, minimization, assessment, and enhancement. Using numerous examples, it offers a lucid description of a wide range of techniques for a variety of testing-related tasks. Students, practitioners and researchers will find this book an excellent source of simple-to-advanced techniques to use and improve their knowledge of the expertise in software testing.Cover -- Contents -- Preface -- Acknowledgments -- Part I: Preliminaries -- Chapter 1: Basics of Software Testing -- 1.1.Humans, Errors, and Testing -- 1.1.1. Errors, faults, and failures -- 1.1.2. Test automation -- 1.1.3. Developer and tester as two roles -- 1.2 Software Quality -- 1.2.1. Quality attributes -- 1.2.2. Reliability -- 1.3 Requirements, Behavior, and Correctness -- 1.3.1. Input domain and program correctness -- 1.3.2. Valid and invalid inputs -- 1.4 Correctness Versus Reliability -- 1.4.1. Correctness -- 1.4.2. Reliability -- 1.4.3. Program use and the operational profile -- 1.5 Testing and Debugging -- 1.5.1. Preparing a test plan -- 1.5.2. Constructing test data -- 1.5.3. Executing the program -- 1.5.4. Specifying program behavior -- 1.5.5. Assessing the correctness of program behavior -- 1.5.6. Construction of oracles -- 1.6 Test Metrics -- 1.6.1. Organizational metrics -- 1.6.2. Project metrics -- 1.6.3. Process metrics -- 1.6.4. Product metrics: Generic -- 1.6.5. Product metrics: OO software -- 1.6.6. Progress monitoring and trends -- 1.6.7. Static and dynamic metrics -- 1.6.8. Testability -- 1.7 Software and Hardware Testing -- 1.8 Testing and Verification -- 1.9 Defect Management -- 1.10 Execution History -- 1.11 Test-Generation Strategies -- 1.12 Static Testing -- 1.12.1. Walkthroughs -- 1.12.2. Inspections -- 1.12.3. Use of static code analysis tools in static testing -- 1.12.4. Software complexity and static testing -- 1.13 Model-Based Testing and Model Checking -- 1.14 Control-Flow Graph -- 1.14.1. Basic block -- 1.14.2. Flow graph: Definition and pictorial representation -- 1.14.3. Path -- 1.15 Dominators and Postdominators -- 1.16 Program-Dependence Graph -- 1.16.1. Data dependence -- 1.16.2. Control dependence -- 1.17 Strings, Languages, and Regular Expressions -- 1.18 Types of Testing.1.18.1. Classifier C1: Source of test generation -- 1.18.2. Classifier C2: Life cycle phase -- 1.18.3. Classifier C3: Goal-directed testing -- 1.18.4. Classifier C4: Artifact under test -- 1.18.5. Classifier C5: Test process models -- 1.19 The Saturation Effect -- 1.19.1. Confidence and true reliability -- 1.19.2. Saturation region -- 1.19.3. False sense of confidence -- 1.19.4. Reducing Δ -- 1.19.5. Impact on test process -- Summary -- Bibliographic Notes -- Exercises -- Part II: Test Generation -- Chapter 2: Test Generation from Requirements -- 2.1 Introduction -- 2.2 The Test-Selection Problem -- 2.3 Equivalence Partitioning -- 2.3.1. Faults targeted -- 2.3.2. Relations and equivalence partitioning -- 2.3.3. Equivalence classes for variables -- 2.3.4. Unidimensional versus multidimensional partitioning -- 2.3.5. A systematic procedure for equivalence partitioning -- 2.3.6. Test selection based on equivalence classes -- 2.3.7. GUI design and equivalence classes -- 2.4 Boundary-Value Analysis -- 2.5 Category-Partition Method -- 2.5.1 Steps in the category-partition method -- 2.6 Cause-Effect Graphing -- 2.6.1. Notation used in cause-effect graphing -- 2.6.2. Creating cause-effect graphs -- 2.6.3. Decision table from cause-effect graph -- 2.6.4. Heuristics to avoid combinatorial explosion -- 2.6.5. Test generation from a decision table -- 2.7 Test Generation from Predicates -- 2.7.1. Predicates and boolean expressions -- 2.7.2. Fault model for predicate testing -- 2.7.2.1 Missing or Extra Boolean Variable Faults -- 2.7.3. Predicate constraints -- 2.7.4. Predicate-testing criteria -- 2.7.5. Generating BOR-, BRO-, and BRE-adequate tests -- 2.7.5 Generating the BOR-constraint set -- Generating the BRO-constraint set -- 2.7.5.3 Generating the BRE-constraint set -- 2.7.5.4 Generating BOR Constraints for Nonsingular Expressions.2.7.6 Cause-effect Graphs and Predicate Testing -- 2.7.7 Fault Propagation -- 2.7.8 Predicate Testing in Practice -- 2.7.8.1 Specification-based Predicate Test Generation -- 2.7.8.2 Program-based Predicate Test Generation -- Summary -- Bibliographic Notes -- Exercises -- Chapter 3: Test Generation from Finite-State Models -- 3.1 Software Design and Testing -- 3.2 Finite-state Machines -- 3.2.1. Excitation using an input sequence -- 3.2.2. Tabular representation -- 3.2.3. Properties of FSM -- 3.3 Conformance Testing -- 3.3.1. Reset inputs -- 3.3.2. The testing problem -- 3.4 A Fault Model -- 3.4.1. Mutants of FSMs -- 3.4.2. Fault coverage -- 3.5 Characterization Set -- 3.5.1. Construction of the k-equivalence partitions -- 3.5.2. Deriving the characterization set -- 3.5.3. Identification sets -- 3.6 The W-method -- 3.6.1. Assumptions -- 3.6.2. Maximum number of states -- 3.6.3. Computation of the transition cover set -- 3.6.4. Constructing Z -- 3.6.5. Deriving a test set -- 3.6.6. Testing using the W-method -- 3.6.7. The error-detection process -- 3.7 The Partial W-method -- 3.7.1. Testing using the Wp-method for m = n -- 3.7.2. Testing using the Wp-method for m > n -- 3.8 The UIO-sequence Method -- 3.8.1. Assumptions -- 3.8.2. UIO sequences -- 3.8.3. Core and noncore behavior -- 3.8.4. Generation of UIO sequences -- 3.8.4.1 Explanation of gen-UIO -- 3.8.5. Distinguishing signatures -- 3.8.6. Test generation -- 3.8.7. Test optimization -- 3.8.8. Fault detection -- 3.9 Automata Theoretic Versuscontrol-flow-based Techniques -- 3.9.1. n-switch-cover -- 3.9.2. Comparing automata-theoretic methods -- Summary -- Bibliographic Notes -- Exercises -- Chapter 4: Test Generation from Combinatorial Designs -- 4.1 Combinatorial Designs -- 4.1.1. Test configuration and test set -- 4.1.2. Modeling the input and configuration spaces.4.2 A Combinatorial Test-Design Process -- 4.3 Fault Model -- 4.3.1. Fault vectors -- 4.4 Latin Squares -- 4.5 Mutually Orthogonal Latin Squares -- 4.6 Pairwise Design: Binary Factors -- 4.7 Pairwise Design: Multivalued Factors -- 4.7.1. Shortcomings of using MOLS for test design -- 4.8 Orthogonal Arrays -- 4.8.1. Mixed-level orthogonal arrays -- 4.9 Covering and Mixed-Level Covering Arrays -- 4.9.1. Covering arrays -- 4.9.2. Mixed-level covering arrays -- 4.10 Arrays Of Strength >2 -- 4.11 Generating Covering Arrays -- Summary -- Bibliographic Notes -- Exercises -- Chapter 5: Test Selection, Minimization, and Prioritization for Regression Testing -- 5.1 What is Regression Testing? -- 5.2 Regression-Test Process -- 5.2.1. Test revalidation, selection, minimization, and prioritization -- 5.2.2. Test setup -- 5.2.3. Test sequencing -- 5.2.4. Test execution -- 5.2.5. Output comparison -- 5.3 RTS: The Problem -- 5.4 Selecting Regression Tests -- 5.4.1. Test all -- 5.4.2. Random selection -- 5.4.3. Selecting modification-traversing tests -- 5.4.4. Test minimization -- 5.4.5. Test prioritization -- 5.5 Test Selection Using Execution Trace -- 5.5.1. Obtaining the execution trace -- 5.5.2. Selecting regression tests -- 5.5.3. Handling function calls -- 5.5.4. Handling changes in declarations -- 5.6 Test Selection Using Dynamic Slicing -- 5.6.1. Dynamic slicing -- 5.6.2. Computation of dynamic slices -- 5.6.3. Selecting tests -- 5.6.4. Potential dependence -- 5.6.5. Computing the relevant slice -- 5.6.6. Addition and deletion of statements -- 5.6.7. Identifying variables for slicing -- 5.6.8. Reduced dynamic-dependence graph -- 5.7 Scalability of Test-Selection Algorithms -- 5.8 Test Minimization -- 5.8.1. The set-cover problem -- 5.8.2. A procedure for test minimization -- 5.9 Test Prioritization -- 5.10 Tools For Regression Testing -- Summary.Bibliographic Notes -- Exercises -- Part III: Test Adequacy Assessment and Enhancement -- Chapter 6: Test-Adequacy Assessment Using Control Flow and Data Flow -- 6.1 Test Adequacy: Basics -- 6.1.1. What is test adequacy? -- 6.1.2. Measurement of test adequacy -- 6.1.3. Test enhancement using measurements of adequacy -- 6.1.4. Infeasibility and test adequacy -- 6.1.5. Error detection and test enhancement -- 6.1.6. Single and multiple executions -- 6.2 Adequacy Criteria Based on Control Flow -- 6.2.1. Statement and block coverage -- 6.2.2. Conditions and decisions -- 6.2.3. Decision coverage -- 6.2.4. Condition coverage -- 6.2.5. Condition/decision coverage -- 6.2.6. Multiple condition coverage -- 6.2.7. Linear code sequence and jump (LCSAJ) coverage -- 6.2.8. Modified condition/decision coverage -- 6.2.9. MC/DC-adequate tests for compound conditions -- 6.2.10. Definition of MC/DC coverage -- 6.2.11. Minimal MC/DC tests -- 6.2.12. Error detection and MC/DC adequacy -- 6.2.13. Short-circuit evaluation and infeasibility -- 6.2.14. Tracing test cases to requirements -- 6.3 Data-Flow Concepts -- 6.3.1. Definitions and uses -- 6.3.2. c-use and p-use -- 6.3.3. Global and local definitions and uses -- 6.3.4. Data-flow graph -- 6.3.5. Def-clear paths -- 6.3.6. Def-use pairs -- 6.3.7. Def-use chains -- 6.3.8. A little optimization -- 6.3.9. Data contexts and ordered data contexts -- 6.4 Adequacy Criteria Based on Data Flow -- 6.4.1. c-use coverage -- 6.4.2. p-use coverage -- 6.4.3. all-uses coverage -- 6.4.4. k-dr chain coverage -- 6.4.5. Using the k-dr chain coverage -- 6.4.6. Infeasible c-uses and p-uses -- 6.4.7. Context coverage -- 6.5 Control Flow Versus Data Flow -- 6.6 The Subsumes Relation -- 6.7 Structural and Functional Testing -- 6.8 Scalability of Coverage Measurement -- Summary -- Bibliographic Notes -- Exercises.Chapter 7: Test-Adequacy Assessment Using Program Mutation.Computer softwareTesting.QA76.76.T48005.1/4ISBN 1-299-48672-X93-325-0995-68428423411434255816rdaMiAaPQ21090120230725015213.0almatuudk_9923197423202884Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl (Revision 1.119 2018/06/21)eng info:srw/schema/1/mods-v3.5 xml 10Da Costa, Lucas,author.texttextbooknyuShelter Island, New York :Manning,[2021]©20212021single uniteng

electronic resource

remote

1 online resource (392 pages)

computer

online resource

Testing JavaScript Applications teaches you how to implement an automated testing plan for JavaScript-based web applications. Summary Automated testing will help you write high-quality software in less time, with more confidence, fewer bugs, and without constant manual oversight. Testing JavaScript Applications is a guide to building a comprehensive and reliable JS application testing suite, covering both how to write tests and how JS testing tools work under the hood. You'll learn from Lucas de Costa, a core contributor to popular JS testing libraries, as he shares a quality mindset for making testing decisions that deliver a real contribution to your business. You'll benefit from informative explanations and diagrams, easily-transferable code samples, and useful tips on using the latest and most consolidated libraries and frameworks of the JavaScript ecosystem. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the technology Automated testing is essential to delivering good JavaScript applications every time. A complete testing strategy needs to cover functions in isolation, integration between different parts of your code, and correctness from the end user's perspective. This book will teach you how to deliver reliable software quickly and confidently. About the book Testing JavaScript Applications teaches you how to implement an automated testing plan for JavaScript-based web applications. It describes practical testing strategies, covers useful tools and libraries, and explains how to foster a culture of quality. In this clearly-written, example-rich book, you'll explore approaches for both backend and frontend applications and learn how to validate your software much more quickly and reliably. What's inside Unit, end-to-end, and integration testing Managing test cost and complexity Practicing test-driven development Dealing with external dependencies Tools like like Jest and Cypress About the reader For junior JavaScript developers. About the author Lucas da Costa is a core maintainer of Chai and Sinon.JS, two of the most popular testing tools in the JavaScript ecosystem, and contributed to numerous other open-source projects, including Jest. Table of Contents PART 1 - TESTING JAVASCRIPT APPLICATIONS1 An introduction to automated testing2 What to test and when?Part 2 - WRITING TESTS3 Testing techniques4 Testing backend applications5 Advanced backend testing techniques6 Testing frontend applications7 The React testing ecosystem8 Testing React applications9 Test-driven development10 UI-based end-to-end testing11 Writing UI-based end-to-end testsPART 3 - BUSINESS IMPACT12 Continuous integration and continuous delivery13 A culture of qualityIntro -- inside front cover -- Testing JavaScript Applications -- Copyright -- dedication -- contents -- front matter -- preface -- acknowledgments -- about this book -- Who should read this book -- How this book is organized: A roadmap -- About the code -- System requirements -- liveBook discussion forum -- about the author -- about the cover illustration -- Part 1. Testing JavaScript applications -- 1 An introduction to automated testing -- 1.1 What is an automated test? -- 1.2 Why automated tests matter -- 1.2.1 Predictability -- 1.2.2 Reproducibility -- 1.2.3 Collaboration -- 1.2.4 Speed -- Summary -- 2 What to test and when? -- 2.1 The testing pyramid -- 2.2 Unit tests -- 2.3 Integration tests -- 2.4 End-to-end tests -- 2.4.1 Testing HTTP APIs -- 2.4.2 Testing GUIs -- 2.4.3 Acceptance tests and end-to-end tests are not the same -- 2.5 Exploratory testing and the value of QA -- 2.6 Tests, cost, and revenue -- Summary -- Part 2. Writing tests -- 3 Testing techniques -- 3.1 Organizing test suites -- 3.1.1 Breaking down tests -- 3.1.2 Parallelism -- 3.1.3 Global hooks -- 3.1.4 Atomicity -- 3.2 Writing good assertions -- 3.2.1 Assertions and error handling -- 3.2.2 Loose assertions -- 3.2.3 Using custom matchers -- 3.2.4 Circular assertions -- 3.3 Test doubles: Mocks, stubs, and spies -- 3.3.1 Mocking imports -- 3.4 Choosing what to test -- 3.4.1 Don't test third-party software -- 3.4.2 To mock, or not to mock: That's the question -- 3.4.3 When in doubt, choose integration tests -- 3.5 Code coverage -- 3.5.1 Automated coverage reports -- 3.5.2 Coverage types -- 3.5.3 What coverage is good for and what it isn't -- Summary -- 4 Testing backend applications -- 4.1 Structuring a testing environment -- 4.1.1 End-to-end testing -- 4.1.2 Integration testing -- 4.1.3 Unit testing -- 4.2 Testing HTTP endpoints -- 4.2.1 Testing middleware.4.3 Dealing with external dependencies -- 4.3.1 Integrations with databases -- 4.3.2 Integrations with other APIs -- Summary -- 5 Advanced backend testing techniques -- 5.1 Eliminating nondeterminism -- 5.1.1 Parallelism and shared resources -- 5.1.2 Dealing with time -- 5.2 Reducing costs while preserving quality -- 5.2.1 Reducing overlap between tests -- 5.2.2 Creating transitive guarantees -- 5.2.3 Turning assertions into preconditions -- Summary -- 6 Testing frontend applications -- 6.1 Introducing JSDOM -- 6.2 Asserting on the DOM -- 6.2.1 Making it easier to find elements -- 6.2.2 Writing better assertions -- 6.3 Handling events -- 6.4 Testing and browser APIs -- 6.4.1 Testing a localStorage integration -- 6.4.2 Testing a History API integration -- 6.5 Dealing with WebSockets and HTTP requests -- 6.5.1 Tests involving HTTP requests -- 6.5.2 Tests involving WebSockets -- Summary -- 7 The React testing ecosystem -- 7.1 Setting up a test environment for React -- 7.1.1 Setting up a React application -- 7.1.2 Setting up a testing environment -- 7.2 An overview of React testing libraries -- 7.2.1 Rendering components and the DOM -- 7.2.2 React Testing Library -- 7.2.3 Enzyme -- 7.2.4 The React test renderer -- Summary -- 8 Testing React applications -- 8.1 Testing component integration -- 8.1.1 Stubbing components -- 8.2 Snapshot testing -- 8.2.1 Snapshots beyond components -- 8.2.2 Serializers -- 8.3 Testing styles -- 8.4 Component-level acceptance tests and component stories -- 8.4.1 Writing stories -- 8.4.2 Writing documentation -- Summary -- 9 Test-driven development -- 9.1 The philosophy behind test-driven development -- 9.1.1 What test-driven development is -- 9.1.2 Adjusting the size of your iterations -- 9.1.3 Why adopt test-driven development? -- 9.1.4 When not to apply test-driven development -- 9.2 Writing a JavaScript module using TDD.9.3 Testing top-down versus testing bottom-up -- 9.3.1 What bottom-up and top-down testing mean -- 9.3.2 How top-down and bottom-up approaches impact a test-driven workflow -- 9.3.3 The pros and cons of bottom-up versus top-down approaches -- 9.4 Balancing maintenance costs, delivery speed, and brittleness -- 9.4.1 Test-driven implementation -- 9.4.2 Test-driven maintenance -- 9.5 Setting up an environment for TDD to succeed -- 9.5.1 Teamwide adoption -- 9.5.2 Keeping distinct lanes -- 9.5.3 Pairing -- 9.5.4 Supplementary testing -- 9.6 TDD, BDD, validations, and specificationsBDD (behavior-driven development) -- Summary -- 10 UI-based end-to-end testing -- 10.1 What are UI-based end-to-end tests? -- 10.2 When to write each type of test -- 10.2.1 UI-based end-to-end tests -- 10.2.2 Pure end-to-end tests -- 10.2.3 Pure UI tests -- 10.2.4 A note on acceptance testing and this chapter's name -- 10.3 An overview of end-to-end testing tools -- 10.3.1 Selenium -- 10.3.2 Puppeteer -- 10.3.3 Cypress -- 10.3.4 When to choose Cypress -- Summary -- 11 Writing UI-based end-to-end tests -- 11.1 Your first UI-based end-to-end tests -- 11.1.1 Setting up a test environment -- 11.1.2 Writing your first tests -- 11.1.3 Sending HTTP requests -- 11.1.4 Sequencing actions -- 11.2 Best practices for end-to-end-tests -- 11.2.1 Page objects -- 11.2.2 Application actions -- 11.3 Dealing with flakiness -- 11.3.1 Avoiding waiting for fixed amounts of time -- 11.3.2 Stubbing uncontrollable factors -- 11.3.3 Retrying tests -- 11.4 Running tests on multiple browsers -- 11.4.1 Using a testing framework to run tests within a browser -- 11.4.2 Running UI-based tests in multiple browsers -- 11.5 Visual regression tests -- Summary -- Part 3. Business impact -- 12 Continuous integration and continuous delivery -- 12.1 What are continuous integration and continuous delivery?.12.1.1 Continuous integration -- 12.1.2 Continuous delivery -- 12.2 The role of automated tests in a CI/CD pipeline -- 12.3 Version-control checks -- Summary -- 13 A culture of quality -- 13.1 Using type systems to make invalid states unrepresentable -- 13.2 Reviewing code to catch problems machines can't -- 13.3 Using linters and formatters to produce consistent code -- 13.4 Monitoring your systems to understand how they actually behave -- 13.5 Explaining your software with good documentation -- Summary -- index -- inside back cover.Lucas Da Costa.Includes index.JavaScript (Computer program language)Application softwareDevelopment.QA76.73.J39 .D336 2021005.276297816383563941638356394978161729791516172979171259321777rdaMiAaPQ22020420260803102847.0almatuudk_9923194523502884Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl (Revision 1.119 2018/06/21)eng