Pytest for Fast and Reliable Feedback Loop

Yesterday I asked: do you write tests before or after your code? Here’s why that matters — and how TDD fixes it. Most bugs aren’t a coding problem. They’re a thinking problem. You wrote the code first. Then you tested it. By then, you were already too attached to question your own logic. TDD fixes this at the root. Test-Driven Development means writing the test first — for code that doesn’t exist yet. The cycle is 3 steps: 🔴 Write a failing test 🟢 Write the minimum code to pass it 🔵 Refactor and clean it up That’s the core of the methodology. Simple to explain. Takes discipline to do. Tomorrow: why Django makes TDD easier than you think. Which step feels hardest for you: Red, Green, or Refactor? 👇 #TDD_Series_Django_2 #Python #Django #TDD #CleanCode #TDDWithDjango #Day2

How to Build Scalable Data-Driven API Tests with Pytest Want to make your API tests more scalable and efficient? In this tutorial, I walk through how to build data-driven API tests using Python Requests and Pytest. You’ll learn how to run the same test logic with multiple datasets stored in JSON, CSV, and Excel, making your test suite more reusable and maintainable. The tutorial also covers how to use @pytest.mark.parametrize to execute tests with different inputs without writing repetitive loops. Using a practical Books API example, I demonstrate how to automate order creation and deletion while handling dynamic values like order IDs. On top of that, I explain serialization and deserialization, and why converting Python dictionaries into JSON is essential for API communication. A great learning resource for QA engineers, SDETs, and automation testers looking to strengthen their API automation skills. #APITesting #DataDrivenTesting #Python #Pytest #AutomationTesting #QAEngineering #SoftwareTesting #TestAutomation #APIAutomation #SDET #PythonTesting #RequestsLibrary #QualityEngineering #TechTutorial #ProjectManagement

𝐁𝐞𝐜𝐨𝐦𝐢𝐧𝐠 𝐚 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐫 𝐁𝐞𝐟𝐨𝐫𝐞 𝐁𝐞𝐜𝐨𝐦𝐢𝐧𝐠 𝐚𝐧 𝐄𝐦𝐩𝐥𝐨𝐲𝐞𝐞 1.6% of transforming into a developer. Yesterday I explored how classes can be connected using Inheritance. Today, I focused on understanding another important concept — Polymorphism. What I practiced today: • Runtime Polymorphism → Method Overriding (Employee → Developer / Manager) • Method Overloading → Handling multiple inputs in Python • Applying polymorphism in simple real-world scenarios I practiced using .ipynb notebooks, writing code step by step, testing outputs, and refining my understanding. I also pushed my practice code to GitHub, continuing my habit of tracking progress. What changed in my thinking today: Before → Writing separate methods for different behaviors Now → Writing one method that works differently based on the object That helped me understand: Polymorphism is about writing flexible code. The goal remains the same: Learn daily. Improve daily. Level up daily. 1.6% today. Still building. 🚀 #Python #OOPS #Polymorphism #LearningJourney #DeveloperJourney #StudentDeveloper #Programming #BuildInPublic #Consistency #SoftwareEngineering

Beyond the Boilerplate: Why Pytest Fixtures are the secret weapon of Python automation. If your test setup logic feels like a teetering Jenga tower of inherited classes and repetitive setUp methods, you’re likely spending more time managing code than actually testing. In the world of Python, moving toward Pytest Fixtures is like switching from manual configuration to a streamlined, automated workflow. The beauty of fixtures lies in their ability to handle complex dependencies while keeping your test files remarkably clean and focused. Why moving away from standard class-based setups changes everything: Explicit Dependency Injection: No more wondering where a database connection or a browser instance magically came from. In Pytest, you pass fixtures as arguments directly to your test function. It’s clear, readable, and tells you exactly what a test requires before you even look at the logic. The Magic of Scopes: Not every resource needs to be recreated for every single test. Pytest allows you to define the "lifetime" of a fixture—whether it’s for a single function, a class, or the entire session. Why log in to your application 50 times when you can do it once, share the state, and significantly speed up your entire pipeline? The "Yield" Revolution: Forget about writing separate, detached cleanup methods. By using the yield keyword, you can combine setup and teardown into a single, intuitive function. Everything before yield happens before the test; everything after handles the cleanup—even if the test fails. Modular Power with conftest.py: You can organize your fixtures in a central conftest.py file, making them globally available across your project without a single import statement. It’s the cleanest way to share configurations across hundreds of test files. Quality in automation is about building a framework that doesn't become a maintenance burden six months down the road. Leveraging fixtures allows you to treat your test infrastructure as a set of modular, reusable components rather than a massive block of copy-pasted boilerplate. Are you still using classic class-based setups, or have you embraced the power of fixtures? Let’s talk about your most complex setup—how many fixtures do you usually "chain" together for a single E2E test? #Python #Pytest #TestAutomation #SDET #SoftwareEngineering #CleanCode #TestGeeks

I thought error handling was just “avoiding crashes”… I was wrong. Today I practiced handling multiple exceptions in Python — and it completely changed how I look at writing reliable code. What I worked on: Taking user input safely using int(input()) Handling invalid inputs with ValueError Preventing runtime crashes like division by zero (ZeroDivisionError) Structuring multiple except blocks for different failure cases What’s actually happening behind the scenes: Python executes the try block normally If an error occurs → it immediately jumps to the matching except block Each except targets a specific failure scenario The program doesn’t crash — it responds gracefully Why this matters (real understanding): Before this, I wrote code assuming users would behave “correctly.” Now I design code assuming they won’t. That shift changes everything. Real-world relevance: Every backend system, API, or production app deals with unpredictable inputs. Error handling isn’t optional — it’s what makes software robust. What changed for me: I’ve stopped writing “happy path only” code. Now I think in terms of: → What can go wrong? → How should my program respond? Small shift. Big impact. Consistency over intensity. Building step by step. How do you usually approach error handling — after writing logic or while designing it? #Python #ErrorHandling #BackendDevelopment #APIs #Programming #SoftwareEngineering #LearnInPublic #DeveloperJourney #CodingPractice #GenAI

Coding agents generate code like there is no tomorrow. Soon enough, they struggle under the weight of what they created. AI writes a new helper instead of reusing an existing one. Old functions stay around because tests still call them, even though production does not. The codebase grows, but the agent's ability to reason about it does not. On bigger projects, especially ones that have been heavily vibe-coded, this turns into chaos. The problem is not just messy code. It is slower reviews, weaker trust in the codebase, and agents that get less reliable as the surface area grows. We have put a lot of energy into making code generation faster. I think the next thing to get right is safe code removal. There is a reason senior engineers get excited about deleting code. It is a bit like never throwing away clothes you no longer wear. It seems fine at first. Then one day, you have five versions of everything, and finding what you actually need means digging through closets you forgot existed. I built a Claude Code skill to help with this. It gives Claude a methodology for dead code removal: classify what you are looking at, verify the cases static tools miss, and avoid drifting into refactor territory while you are in there. It is tuned for Python and TypeScript, but should be easy to adapt. Clone it, fork it, open a PR if you improve it. https://lnkd.in/ds5AcC5U #CodingAgents #CodeQuality

Writing the code is the easy part. Writing the tests is the real job. When I first started building personal projects, I just wanted to see the output on the screen. If it ran without crashing, I considered it done. Building reliable systems requires a totally different mindset. I have been spending time writing proper unit tests for my Python backend logic. Catching a data type mismatch in a local testing environment takes five minutes to fix. Catching that same mismatch after it breaks a production pipeline takes five hours. Testing is not a chore. It is an insurance policy. #Python #SoftwareEngineering #UnitTesting #CleanCode #DataEngineering

Finding and Removing Dead Code in code bases & scripting     Find and remove dead code – before it finds you We’ve all been there: the codebase grows, features come and go, and eventually the code ends up in functions that nobody calls anymore. Particularly tricky: scripting files (Python, Shell, JS), which often exist outside the IDE and are quickly forgotten. 🫵 Why this is problematic: • Maintenance costs: Everyone has to read code that is never executed. • Security risk: Outdated logic may contain vulnerabilities that have never been patched because they were never tested. • Confusion: New team members waste time trying to understand why something exists (“Is this still needed?”) • Slows down builds and increases binary size • Bloats tests and reviews   ➡️ How SciTools’ Understand helps Instead of tedious manual searching, Understand does the work for you: 1️⃣ Find unused functions & variables The static analysis detects code that is never called,  across all files and languages. 2️⃣Visualize dependencies Graphs immediately show you which modules are isolated and can be removed. 3️⃣ Track references Where is this function used? Understand shows you every reference, or, indeed, none. 4️⃣Scripting included Not just compiled code, your build scripts, helper scripts and automations are analyzed too. ✔️ Best practice: Integrate dead code checks into your workflow: 1. Generate reports regularly 2. Check before every release 3. Plan refactoring strategically The result: A leaner, more maintainable and more secure codebase. Free trial www.emenda.com/trial #SoftwareEngineering #DeadCode #CodeQuality #Refactoring #CleanCode #Understand #SciTools #Scripting 

🏗️ Scaling Up: Moving from Scripts to Systems As my Python projects grow, I’m learning that writing code that works is only half the battle. Writing code that is maintainable is where the real skill lies. I’ve started refactoring my automation scripts by breaking them down into reusable functions. Here’s why this shift is a game-changer: ♻️ Reusability (DRY - Don't Repeat Yourself) Instead of copying and pasting logic, I can write a function once and call it whenever I need it. It makes the codebase smaller and much easier to update. 📖 Readability By abstracting complex logic into functions with clear names like clean_data() or export_to_excel(), my main execution flow now reads like a story rather than a wall of text. Anyone (including my future self) can understand the logic at a glance. 🧪 Testability Organizing code into functions allows me to test individual "units" of logic in isolation. If something breaks, I know exactly which function is responsible, making debugging significantly faster. The Evolution: Level 1: Write a long script that runs top-to-bottom. Level 2: Organize logic into functions for better flow. Level 3: Move functions into separate modules for a professional project structure. I’m currently at Level 2 and feeling the difference in how I approach problem-solving! 💻 #PythonProgramming #CleanCode #SoftwareDevelopment #LearningToCode #CodeRefactoring #TechCommunity