Test-Driven Development with Python. Obey the Testing Goat: Using Django, Selenium, and JavaScript. 2nd Edition
- Autor:
- Harry J. W. Percival
- Ocena:
- 6.0/6 Opinie: 1
- Stron:
- 624
- Dostępne formaty:
-
ePubMobi
Opis ebooka: Test-Driven Development with Python. Obey the Testing Goat: Using Django, Selenium, and JavaScript. 2nd Edition
By taking you through the development of a real web application from beginning to end, the second edition of this hands-on guide demonstrates the practical advantages of test-driven development (TDD) with Python. You’ll learn how to write and run tests before building each part of your app, and then develop the minimum amount of code required to pass those tests. The result? Clean code that works.
In the process, you’ll learn the basics of Django, Selenium, Git, jQuery, and Mock, along with current web development techniques. If you’re ready to take your Python skills to the next level, this book—updated for Python 3.6—clearly demonstrates how TDD encourages simple designs and inspires confidence.
- Dive into the TDD workflow, including the unit test/code cycle and refactoring
- Use unit tests for classes and functions, and functional tests for user interactions within the browser
- Learn when and how to use mock objects, and the pros and cons of isolated vs. integrated tests
- Test and automate your deployments with a staging server
- Apply tests to the third-party plugins you integrate into your site
- Run tests automatically by using a Continuous Integration environment
- Use TDD to build a REST API with a front-end Ajax interface
Wybrane bestsellery
-
Dzięki tej książce zrozumiesz, że w rekurencji nie kryje się żadna magia. Dowiesz się, na czym polega jej działanie i kiedy warto zastosować algorytm rekursywny, a kiedy lepiej tego nie robić. Poznasz szereg klasycznych i mniej znanych algorytmów rekurencyjnych. Pracę z zawartym tu materiałem uła...
Rekurencyjna książka o rekurencji. Zostań mistrzem rozmów kwalifikacyjnych poświęconych językom Python i JavaScript Rekurencyjna książka o rekurencji. Zostań mistrzem rozmów kwalifikacyjnych poświęconych językom Python i JavaScript
(47.40 zł najniższa cena z 30 dni)51.35 zł
79.00 zł(-35%) -
Dzięki temu przyjaznemu przewodnikowi poznasz kluczowe koncepcje programistyczne i operacje obiektowego modelu dokumentu. Nauczysz się też pisać kod działający asynchronicznie i współbieżnie. Poszczególne zagadnienia zostały zilustrowane przykładowymi fragmentami kodu i prostymi projektami ―...
JavaScript od pierwszej linii kodu. Błyskawiczna nauka pisania gier, stron WWW i aplikacji internetowych JavaScript od pierwszej linii kodu. Błyskawiczna nauka pisania gier, stron WWW i aplikacji internetowych
(59.40 zł najniższa cena z 30 dni)64.35 zł
99.00 zł(-35%) -
This quick-start reference distills the core concepts of React through simple explanations, examples, and step-by-step derivations. This new edition tackles changes brought by React 19, including form actions, the use() hook, and React on the server.
React Key Concepts. An in-depth guide to React's core features - Second Edition React Key Concepts. An in-depth guide to React's core features - Second Edition
(100.08 zł najniższa cena z 30 dni) -
This book is a comprehensive guide to Nuxt.js, which takes you from the basics to advanced topics. Uniquely, this book emphasizes practical, project-based learning, tackling real-world problems.
Nuxt 3 Projects. Build scalable applications with Nuxt 3 using TypeScript, Pinia, and Composition API Nuxt 3 Projects. Build scalable applications with Nuxt 3 using TypeScript, Pinia, and Composition API
-
Full-Stack React Projects is a complete guide to learning full-stack web development, understanding the creation and integration of backend systems, and advancing your career as a frontend developer.
Modern Full-Stack React Projects. Build, maintain, and deploy modern web apps using MongoDB, Express, React, and Node.js Modern Full-Stack React Projects. Build, maintain, and deploy modern web apps using MongoDB, Express, React, and Node.js
-
This book is a comprehensive guide to deploying and scaling frontend web applications on Netlify. With hands-on instructions and real-world examples, this book takes you from setting up a Netlify account and deploying web apps to optimizing performance.
Web Development on Netlify. Proven strategies for building, deploying, and hosting modern web applications Web Development on Netlify. Proven strategies for building, deploying, and hosting modern web applications
-
In this book, you'll gain extensive knowledge of the JavaScript ecosystem, Node.js, and microservices. Moreover, you'll learn best practices that you can easily apply in your everyday work or study.
Building Microservices with Node.js. Explore microservices applications and migrate from a monolith architecture to microservices Building Microservices with Node.js. Explore microservices applications and migrate from a monolith architecture to microservices
-
This unique book introduces both React and React Native, giving you a big picture view of the React ecosystem.
React and React Native. Build cross-platform JavaScript and TypeScript apps for the web, desktop, and mobile - Fifth Edition React and React Native. Build cross-platform JavaScript and TypeScript apps for the web, desktop, and mobile - Fifth Edition
Ebooka "Test-Driven Development with Python. Obey the Testing Goat: Using Django, Selenium, and JavaScript. 2nd Edition" przeczytasz na:
-
czytnikach Inkbook, Kindle, Pocketbook, Onyx Boox i innych
-
systemach Windows, MacOS i innych
-
systemach Windows, Android, iOS, HarmonyOS
-
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi
Masz pytania? Zajrzyj do zakładki Pomoc »
Audiobooka "Test-Driven Development with Python. Obey the Testing Goat: Using Django, Selenium, and JavaScript. 2nd Edition" posłuchasz:
-
w aplikacji Ebookpoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych
-
na dowolnych urządzeniach i aplikacjach obsługujących format MP3 (pliki spakowane w ZIP)
Masz pytania? Zajrzyj do zakładki Pomoc »
Kurs Video "Test-Driven Development with Python. Obey the Testing Goat: Using Django, Selenium, and JavaScript. 2nd Edition" zobaczysz:
-
w aplikacjach Ebookpoint i Videopoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych z dostępem do najnowszej wersji Twojej przeglądarki internetowej
Szczegóły ebooka
- ISBN Ebooka:
- 978-14-919-5865-0, 9781491958650
- Data wydania ebooka:
- 2017-08-02 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@ebookpoint.pl.
- Język publikacji:
- angielski
- Rozmiar pliku ePub:
- 7.9MB
- Rozmiar pliku Mobi:
- 19.8MB
Spis treści ebooka
- Preface
- Why I Wrote a Book About Test-Driven Development
- Aims of This Book
- Outline
- Conventions Used in This Book
- Submitting Errata
- Using Code Examples
- OReilly Safari
- Contacting OReilly
- Prerequisites and Assumptions
- Python 3 and Programming
- How HTML Works
- Django
- JavaScript
- Required Software Installations
- Gits Default Editor, and Other Basic Git Config
- Installing Firefox and Geckodriver
- Setting Up Your Virtualenv
- Activating and Deactivating the Virtualenv
- Installing Django and Selenium
- Some Error Messages Youre Likely to See When You Inevitably Fail to Activate Your Virtualenv
- Companion Video
- Acknowledgments
- Additional Thanks for the Second Edition
- I. The Basics of TDD and Django
- 1. Getting Django Set Up Using a
Functional Test
- Obey the Testing Goat! Do Nothing Until You Have a Test
- Getting Django Up and Running
- Starting a Git Repository
- 2. Extending Our Functional Test Using
the unittest Module
- Using a Functional Test to Scope Out a Minimum Viable App
- The Python Standard Librarys unittest Module
- Commit
- 3. Testing a Simple Home Page with
Unit Tests
- Our First Django App, and Our First Unit Test
- Unit Tests, and How They Differ from Functional Tests
- Unit Testing in Django
- Djangos MVC, URLs, and View Functions
- At Last! We Actually Write Some Application Code!
- urls.py
- Unit Testing a View
- The Unit-Test/Code Cycle
- 4. What Are We Doing with All These Tests? (And, Refactoring)
- Programming Is Like Pulling a Bucket of Water Up from a Well
- Using Selenium to Test User Interactions
- The Dont Test Constants Rule, and Templates to the Rescue
- Refactoring to Use a Template
- The Django Test Client
- On Refactoring
- A Little More of Our Front Page
- Recap: The TDD Process
- 5. Saving User Input: Testing the Database
- Wiring Up Our Form to Send a POST Request
- Processing a POST Request on the Server
- Passing Python Variables to Be Rendered in the Template
- Three Strikes and Refactor
- The Django ORM and Our First Model
- Our First Database Migration
- The Test Gets Surprisingly Far
- A New Field Means a New Migration
- Saving the POST to the Database
- Redirect After a POST
- Better Unit Testing Practice: Each Test Should Test One Thing
- Rendering Items in the Template
- Creating Our Production Database with migrate
- Recap
- 6. Improving Functional Tests: Ensuring Isolation and Removing Voodoo Sleeps
- Ensuring Test Isolation in Functional Tests
- Running Just the Unit Tests
- Ensuring Test Isolation in Functional Tests
- Aside: Upgrading Selenium and Geckodriver
- On Implicit and Explicit Waits, and Voodoo time.sleeps
- 7. Working Incrementally
- Small Design When Necessary
- Not Big Design Up Front
- YAGNI!
- REST (ish)
- Small Design When Necessary
- Implementing the New Design Incrementally Using TDD
- Ensuring We Have a Regression Test
- Iterating Towards the New Design
- Taking a First, Self-Contained Step: One New URL
- A New URL
- A New View Function
- Green? Refactor
- Another Small Step: A Separate Template for Viewing Lists
- A Third Small Step: A URL for Adding List Items
- A Test Class for New List Creation
- A URL and View for New List Creation
- Removing Now-Redundant Code and Tests
- A Regression! Pointing Our Forms at the New URL
- Biting the Bullet: Adjusting Our Models
- A Foreign Key Relationship
- Adjusting the Rest of the World to Our New Models
- Each List Should Have Its Own URL
- Capturing Parameters from URLs
- Adjusting new_list to the New World
- The Functional Tests Detect Another Regression
- One More View to Handle Adding Items to an Existing List
- Beware of Greedy Regular Expressions!
- The Last New URL
- The Last New View
- Testing the Response Context Objects Directly
- A Final Refactor Using URL includes
- II. Web Development Sine Qua Nons
- 8. Prettification: Layout and Styling, and What to Test About It
- What to Functionally Test About Layout and Style
- Prettification: Using a CSS Framework
- Django Template Inheritance
- Integrating Bootstrap
- Rows and Columns
- Static Files in Django
- Switching to StaticLiveServerTestCase
- Using Bootstrap Components to Improve the Look of the Site
- Jumbotron!
- Large Inputs
- Table Styling
- Using Our Own CSS
- What We Glossed Over: collectstatic and Other Static Directories
- A Few Things That Didnt Make It
- 9. Testing Deployment Using a Staging Site
- TDD and the Danger Areas of Deployment
- As Always, Start with a Test
- Getting a Domain Name
- Manually Provisioning a Server to Host Our Site
- Choosing Where to Host Our Site
- Spinning Up a Server
- User Accounts, SSH, and Privileges
- Installing Nginx
- Installing Python 3.6
- Configuring Domains for Staging and Live
- Using the FT to Confirm the Domain Works and Nginx Is Running
- Deploying Our Code Manually
- Adjusting the Database Location
- Creating a Virtualenv Manually, and Using requirements.txt
- Simple Nginx Configuration
- Creating the Database with migrate
- Success! Our Hack Deployment Works
- 10. Getting to a Production-Ready Deployment
- Switching to Gunicorn
- Getting Nginx to Serve Static Files
- Switching to Using Unix Sockets
- Switching DEBUG to False and Setting ALLOWED_HOSTS
- Using Systemd to Make Sure Gunicorn Starts on Boot
- Saving Our Changes: Adding Gunicorn to Our requirements.txt
- Thinking About Automating
- Saving Templates for Our Provisioning Config Files
- Saving Our Progress
- 11. Automating Deployment with Fabric
- Breakdown of a Fabric Script for Our Deployment
- Creating the Directory Structure
- Pulling Down Our Source Code with Git
- Updating settings.py
- Updating the Virtualenv
- Migrating the Database If Necessary
- Breakdown of a Fabric Script for Our Deployment
- Trying It Out
- Deploying to Live
- Nginx and Gunicorn Config Using sed
- Git Tag the Release
- Further Reading
- 12. Splitting Our Tests into Multiple Files, and a Generic Wait Helper
- Start on a Validation FT: Preventing Blank Items
- Skipping a Test
- Splitting Functional Tests Out into Many Files
- Running a Single Test File
- Start on a Validation FT: Preventing Blank Items
- A New Functional Test Tool: A Generic Explicit Wait Helper
- Finishing Off the FT
- Refactoring Unit Tests into Several Files
- 13. Validation at the Database Layer
- Model-Layer Validation
- The self.assertRaises Context Manager
- A Django Quirk: Model Save Doesnt Run Validation
- Model-Layer Validation
- Surfacing Model Validation Errors in the View
- Checking That Invalid Input Isnt Saved to the Database
- Django Pattern: Processing POST Requests in the Same View as Renders the Form
- Refactor: Transferring the new_item Functionality into view_list
- Enforcing Model Validation in view_list
- Refactor: Removing Hardcoded URLs
- The {% url %} Template Tag
- Using get_absolute_url for Redirects
- 14. A Simple Form
- Moving Validation Logic into a Form
- Exploring the Forms API with a Unit Test
- Switching to a Django ModelForm
- Testing and Customising Form Validation
- Moving Validation Logic into a Form
- Using the Form in Our Views
- Using the Form in a View with a GET Request
- A Big Find and Replace
- Using the Form in a View That Takes POST Requests
- Adapting the Unit Tests for the new_list View
- Using the Form in the View
- Using the Form to Display Errors in the Template
- Using the Form in the Other View
- A Helper Method for Several Short Tests
- An Unexpected Benefit: Free Client-Side Validation from HTML5
- A Pat on the Back
- But Have We Wasted a Lot of Time?
- Using the Forms Own Save Method
- 15. More Advanced Forms
- Another FT for Duplicate Items
- Preventing Duplicates at the Model Layer
- A Little Digression on Queryset Ordering and String Representations
- Rewriting the Old Model Test
- Some Integrity Errors Do Show Up on Save
- Another FT for Duplicate Items
- Experimenting with Duplicate Item Validation at the Views Layer
- A More Complex Form to Handle Uniqueness Validation
- Using the Existing List Item Form in the List View
- Wrapping Up: What Weve Learned About Testing Django
- 16. Dipping Our Toes, Very Tentatively,
into JavaScript
- Starting with an FT
- Setting Up a Basic JavaScript Test Runner
- Using jQuery and the Fixtures Div
- Building a JavaScript Unit Test for Our Desired Functionality
- Fixtures, Execution Order, and Global State: Key Challenges of JS Testing
- console.log for Debug Printing
- Using an Initialize Function for More Control Over Execution Time
- Columbo Says: Onload Boilerplate and Namespacing
- JavaScript Testing in the TDD Cycle
- A Few Things That Didnt Make It
- 17. Deploying Our New Code
- Staging Deploy
- Live Deploy
- What to Do If You See a Database Error
- Wrap-Up: git tag the New Release
- III. More Advanced Topics in Testing
- 18. User Authentication, Spiking, and
De-Spiking
- Passwordless Auth
- Exploratory Coding, aka Spiking
- Starting a Branch for the Spike
- Frontend Log in UI
- Sending Emails from Django
- Using Environment Variables to Avoid Secrets in Source Code
- Storing Tokens in the Database
- Custom Authentication Models
- Finishing the Custom Django Auth
- De-spiking
- Reverting Our Spiked Code
- A Minimal Custom User Model
- Tests as Documentation
- A Token Model to Link Emails with a Unique ID
- 19. Using Mocks to Test External Dependencies or Reduce Duplication
- Before We Start: Getting the Basic Plumbing In
- Mocking Manually, aka Monkeypatching
- The Python Mock Library
- Using unittest.patch
- Getting the FT a Little Further Along
- Testing the Django Messages Framework
- Adding Messages to Our HTML
- Starting on the Login URL
- Checking That We Send the User a Link with a Token
- De-spiking Our Custom Authentication Backend
- 1 if = 1 More Test
- The get_user Method
- Using Our Auth Backend in the Login View
- An Alternative Reason to Use Mocks: Reducing Duplication
- Using mock.return_value
- Patching at the Class Level
- The Moment of Truth: Will the FT Pass?
- It Works in Theory! Does It Work in Practice?
- Finishing Off Our FT, Testing Logout
- 20. Test Fixtures and a Decorator for
Explicit Waits
- Skipping the Login Process by Pre-creating a Session
- Checking That It Works
- Skipping the Login Process by Pre-creating a Session
- Our Final Explicit Wait Helper: A Wait Decorator
- 21. Server-Side Debugging
- The Proof Is in the Pudding: Using Staging to Catch Final Bugs
- Setting Up Logging
- The Proof Is in the Pudding: Using Staging to Catch Final Bugs
- Setting Secret Environment Variables on the Server
- Adapting Our FT to Be Able to Test Real Emails via POP3
- Managing the Test Database on Staging
- A Django Management Command to Create Sessions
- Getting the FT to Run the Management Command on the Server
- Using Fabric Directly from Python
- Recap: Creating Sessions Locally Versus Staging
- Locally:
- Against staging:
- Baking In Our Logging Code
- Wrap-Up
- 22. Finishing My Lists: Outside-In TDD
- The Alternative: Inside-Out
- Why Prefer Outside-In?
- The FT for My Lists
- The Outside Layer: Presentation and Templates
- Moving Down One Layer to View Functions (the Controller)
- Another Pass, Outside-In
- A Quick Restructure of the Template Inheritance Hierarchy
- Designing Our API Using the Template
- Moving Down to the Next Layer: What the View Passes to the Template
- The Next Requirement from the Views Layer: New Lists Should Record Owner
- A Decision Point: Whether to Proceed to the Next Layer with a Failing Test
- Moving Down to the Model Layer
- Final Step: Feeding Through the .name API from the Template
- 23. Test Isolation, and Listening to Your Tests
- Revisiting Our Decision Point: The Views Layer Depends on Unwritten Models Code
- A First Attempt at Using Mocks for Isolation
- Using Mock side_effects to Check the Sequence of Events
- Listen to Your Tests: Ugly Tests Signal a Need to Refactor
- Rewriting Our Tests for the View to Be Fully Isolated
- Keep the Old Integrated Test Suite Around as a Sanity Check
- A New Test Suite with Full Isolation
- Thinking in Terms of Collaborators
- Moving Down to the Forms Layer
- Keep Listening to Your Tests: Removing ORM Code from Our Application
- Finally, Moving Down to the Models Layer
- Back to Views
- The Moment of Truth (and the Risks of Mocking)
- Thinking of Interactions Between Layers as Contracts
- Identifying Implicit Contracts
- Fixing the Oversight
- One More Test
- Tidy Up: What to Keep from Our Integrated Test Suite
- Removing Redundant Code at the Forms Layer
- Removing the Old Implementation of the View
- Removing Redundant Code at the Forms Layer
- Conclusions: When to Write Isolated Versus Integrated Tests
- Let Complexity Be Your Guide
- Should You Do Both?
- Onwards!
- 24. Continuous Integration (CI)
- Installing Jenkins
- Configuring Jenkins
- Initial Unlock
- Suggested Plugins for Now
- Configuring the Admin User
- Adding Plugins
- Telling Jenkins Where to Find Python 3 and Xvfb
- Finishing Off with HTTPS
- Setting Up Our Project
- First Build!
- Setting Up a Virtual Display So the FTs Can Run Headless
- Taking Screenshots
- If in Doubt, Try Bumping the Timeout!
- Running Our QUnit JavaScript Tests in Jenkins with PhantomJS
- Installing node
- Adding the Build Steps to Jenkins
- More Things to Do with a CI Server
- 25. The Token Social Bit, the Page Pattern, and an Exercise for the Reader
- An FT with Multiple Users, and addCleanup
- The Page Pattern
- Extend the FT to a Second User, and the My Lists Page
- An Exercise for the Reader
- 26. Fast Tests, Slow Tests, and Hot Lava
- Thesis: Unit Tests Are Superfast and Good Besides That
- Faster Tests Mean Faster Development
- The Holy Flow State
- Slow Tests Dont Get Run as Often, Which Causes Bad Code
- Were Fine Now, but Integrated Tests Get Slower Over Time
- Dont Take It from Me
- And Unit Tests Drive Good Design
- Thesis: Unit Tests Are Superfast and Good Besides That
- The Problems with Pure Unit Tests
- Isolated Tests Can Be Harder to Read and Write
- Isolated Tests Dont Automatically Test Integration
- Unit Tests Seldom Catch Unexpected Bugs
- Mocky Tests Can Become Closely Tied to Implementation
- But All These Problems Can Be Overcome
- Synthesis: What Do We Want from Our Tests, Anyway?
- Correctness
- Clean, Maintainable Code
- Productive Workflow
- Evaluate Your Tests Against the Benefits You Want from Them
- Architectural Solutions
- Ports and Adapters/Hexagonal/Clean Architecture
- Functional Core, Imperative Shell
- Conclusion
- Further Reading
- Obey the Testing Goat!
- Testing Is Hard
- Keep Your CI Builds Green
- Take Pride in Your Tests, as You Do in Your Code
- Testing Is Hard
- Remember to Tip the Bar Staff
- Dont Be a Stranger!
- A. PythonAnywhere
- Running Firefox Selenium Sessions with Xvfb
- Setting Up Django as a PythonAnywhere Web App
- Cleaning Up /tmp
- Screenshots
- The Deployment Chapter
- B. Django Class-Based Views
- Class-Based Generic Views
- The Home Page as a FormView
- Using form_valid to Customise a CreateView
- A More Complex View to Handle Both Viewing and Adding to a List
- The Tests Guide Us, for a While
- Until Were Left with Trial and Error
- Back on Track
- Is That Your Final Answer?
- Compare Old and New
- Best Practices for Unit Testing CBGVs?
- Take-Home: Having Multiple, Isolated View Tests with Single Assertions Helps
- C. Provisioning with Ansible
- Installing System Packages and Nginx
- Configuring Gunicorn, and Using Handlers to Restart Services
- What to Do Next
- Move Deployment out of Fabric and into Ansible
- Use Vagrant to Spin Up a Local VM
- D. Testing Database Migrations
- An Attempted Deploy to Staging
- Running a Test Migration Locally
- Entering Problematic Data
- Copying Test Data from the Live Site
- Confirming the Error
- Inserting a Data Migration
- Re-creating the Old Migration
- Testing the New Migrations Together
- Conclusions
- E. Behaviour-Driven Development (BDD)
- What Is BDD?
- Basic Housekeeping
- Writing an FT as a Feature Using Gherkin Syntax
- As-a /I want to/So that
- Given/When/Then
- Not Always a Perfect Fit!
- Coding the Step Functions
- Generating Placeholder Steps
- First Step Definition
- setUp and tearDown Equivalents in environment.py
- Another Run
- Capturing Parameters in Steps
- Comparing the Inline-Style FT
- BDD Encourages Structured Test Code
- The Page Pattern as an Alternative
- BDD Might Be Less Expressive than Inline Comments
- Will Nonprogrammers Write Tests?
- Some Tentative Conclusions
- F. Building a REST API: JSON, Ajax, and Mocking with JavaScript
- Our Approach for This Appendix
- Choosing Our Test Approach
- Basic Piping
- Actually Responding with Something
- Adding POST
- Testing the Client-Side Ajax with Sinon.js
- Sinon and Testing the Asynchronous Part of Ajax
- Wiring It All Up in the Template to See If It Really Works
- Implementing Ajax POST, Including the CSRF Token
- Mocking in JavaScript
- Finishing the Refactor: Getting the Tests to Match the Code
- Data Validation: An Exercise for the Reader?
- G. Django-Rest-Framework
- Installation
- Serializers (Well, ModelSerializers, Really)
- Viewsets (Well, ModelViewsets, Really) and Routers
- A Different URL for POST Item
- Adapting the Client Side
- What Django-Rest-Framework Gives You
- Configuration Instead of Code
- Free Functionality
- H. Cheat Sheet
- Initial Project Setup
- The Basic TDD Workflow
- Moving Beyond Dev-Only Testing
- General Testing Best Practices
- Selenium/Functional Testing Best Practices
- Outside-In, Test Isolation Versus Integrated Tests, and Mocking
- I. What to Do Next
- NotificationsBoth on the Site and by Email
- Switch to Postgres
- Run Your Tests Against Different Browsers
- 404 and 500 Tests
- The Django Admin Site
- Write Some Security Tests
- Test for Graceful Degradation
- Caching and Performance Testing
- JavaScript MVC Frameworks
- Async and Websockets
- Switch to Using py.test
- Check Out coverage.py
- Client-Side Encryption
- Your Suggestion Here
- J. Source Code Examples
- Full List of Links for Each Chapter
- Using Git to Check Your Progress
- Downloading a ZIP File for a Chapter
- Dont Let it Become a Crutch!
- Bibliography
- Index
O'Reilly Media - inne książki
-
This concise yet comprehensive guide explains how to adopt a data lakehouse architecture to implement modern data platforms. It reviews the design considerations, challenges, and best practices for implementing a lakehouse and provides key insights into the ways that using a lakehouse can impact ...(202.00 zł najniższa cena z 30 dni)
201.80 zł
249.00 zł(-19%) -
In today's fast-paced world, more and more organizations require rapid application development with reduced development costs and increased productivity. This practical guide shows application developers how to use PowerApps, Microsoft's no-code/low-code application framework that helps developer...(172.95 zł najniższa cena z 30 dni)
172.85 zł
219.00 zł(-21%) -
Welcome to the systems age, where software professionals are no longer building software&emdash;we're building systems of software. Change is continuously deployed across software ecosystems coordinated by responsive infrastructure. In this world of increasing relational complexity, we need t...(163.44 zł najniższa cena z 30 dni)
163.24 zł
219.00 zł(-25%) -
This book provides an ideal guide for Python developers who want to learn how to build applications with large language models. Authors Olivier Caelen and Marie-Alice Blete cover the main features and benefits of GPT-4 and GPT-3.5 models and explain how they work. You'll also get a step-by-step g...
Developing Apps with GPT-4 and ChatGPT. 2nd Edition Developing Apps with GPT-4 and ChatGPT. 2nd Edition
(165.68 zł najniższa cena z 30 dni)165.63 zł
219.00 zł(-24%) -
In today's cloud native world, where we automate as much as possible, everything is code. With this practical guide, you'll learn how Policy as Code (PaC) provides the means to manage the policies, related data, and responses to events that occur within the systems we maintain—Kubernetes, c...(226.87 zł najniższa cena z 30 dni)
226.37 zł
289.00 zł(-22%) -
Geared to intermediate- to advanced-level DBAs and IT professionals looking to enhance their MySQL skills, this guide provides a comprehensive overview on how to manage and optimize MySQL databases. You'll learn how to create databases and implement backup and recovery, security configurations, h...(233.25 zł najniższa cena z 30 dni)
232.75 zł
289.00 zł(-19%) -
Get the details, examples, and best practices you need to build generative AI applications, services, and solutions using the power of Azure OpenAI Service. With this comprehensive guide, Microsoft AI specialist Adrián González Sánchez examines the integration and utilization of Az...
Azure OpenAI Service for Cloud Native Applications Azure OpenAI Service for Cloud Native Applications
(171.69 zł najniższa cena z 30 dni)171.49 zł
219.00 zł(-22%) -
Despite the increase of high-profile hacks, record-breaking data leaks, and ransomware attacks, many organizations don't have the budget for an information security (InfoSec) program. If you're forced to protect yourself by improvising on the job, this pragmatic guide provides a security-101 hand...(225.80 zł najniższa cena z 30 dni)
225.75 zł
239.00 zł(-6%) -
Keeping up with the Python ecosystem can be daunting. Its developer tooling doesn't provide the out-of-the-box experience native to languages like Rust and Go. When it comes to long-term project maintenance or collaborating with others, every Python project faces the same problem: how to build re...(198.88 zł najniższa cena z 30 dni)
198.83 zł
239.00 zł(-17%) -
Bringing a deep-learning project into production at scale is quite challenging. To successfully scale your project, a foundational understanding of full stack deep learning, including the knowledge that lies at the intersection of hardware, software, data, and algorithms, is required.This book il...(239.01 zł najniższa cena z 30 dni)
238.91 zł
289.00 zł(-17%)
Dzieki opcji "Druk na żądanie" do sprzedaży wracają tytuły Grupy Helion, które cieszyły sie dużym zainteresowaniem, a których nakład został wyprzedany.
Dla naszych Czytelników wydrukowaliśmy dodatkową pulę egzemplarzy w technice druku cyfrowego.
Co powinieneś wiedzieć o usłudze "Druk na żądanie":
- usługa obejmuje tylko widoczną poniżej listę tytułów, którą na bieżąco aktualizujemy;
- cena książki może być wyższa od początkowej ceny detalicznej, co jest spowodowane kosztami druku cyfrowego (wyższymi niż koszty tradycyjnego druku offsetowego). Obowiązująca cena jest zawsze podawana na stronie WWW książki;
- zawartość książki wraz z dodatkami (płyta CD, DVD) odpowiada jej pierwotnemu wydaniu i jest w pełni komplementarna;
- usługa nie obejmuje książek w kolorze.
Masz pytanie o konkretny tytuł? Napisz do nas: sklep[at]helion.pl.
Książka, którą chcesz zamówić pochodzi z końcówki nakładu. Oznacza to, że mogą się pojawić drobne defekty (otarcia, rysy, zagięcia).
Co powinieneś wiedzieć o usłudze "Końcówka nakładu":
- usługa obejmuje tylko książki oznaczone tagiem "Końcówka nakładu";
- wady o których mowa powyżej nie podlegają reklamacji;
Masz pytanie o konkretny tytuł? Napisz do nas: sklep[at]helion.pl.
Książka drukowana
Oceny i opinie klientów: Test-Driven Development with Python. Obey the Testing Goat: Using Django, Selenium, and JavaScript. 2nd Edition Harry J. W. Percival (1) Weryfikacja opinii następuję na podstawie historii zamówień na koncie Użytkownika umieszczającego opinię. Użytkownik mógł otrzymać punkty za opublikowanie opinii uprawniające do uzyskania rabatu w ramach Programu Punktowego.
(1)
(0)
(0)
(0)
(0)
(0)