These choices depend on the company’s business processes, the type of the development, whether critical data is involved, risk management and infrastructure options. All of them has led to the development of different deployment strategies.

Actually, every day, we use CI/CD tools within a small cycle to deploy our developments to the production environment. Then, we conduct environment-specific (feature-branch or stage or preprod) tests.

If everything goes well, we monitor our applications and follow our audit logs. But what if there’s an issue in the production environment?
Rollback or hot-fix… Which one we choose?

Downtime in production = Amount of quality lost

So what if there’s an issue and we can’t roll back? What if all users are affected, or if we lose critical data? What if users dislike the new feature we introduced? Is this a scenario we would want?

Why are there so many deployment strategies, and are they really necessary?.. Let’s take a deeper look at the main reasons behind them

• For some applications, downtime is unacceptable (financial transaction platforms), so strategies that provide seamless updates are preferred.
• In competitive markets, quickly delivering new features to users is crucial.
• For mission-critical applications, gradual or controlled deployment strategies are used to minimize risks a new version may introduce.
• The application’s architecture determines which strategies are more suitable.
• Different hosting environments require different deployment methods (e.g., cloud, on-premises, or hybrid environments).
• Strategies are adjusted to ensure no downtime during peak traffic times.
• Some strategies require more resources ( Blue-Green deployment requires two full environments).
• Strategies like Canary and A/B testing are used to gather real user feedback (production environment testing).
• To measure the impact of new features and detect potential issues early on (step-by-step %1 release).
• Strategies have been developed to quickly revert to the previous version when issues are detected (Fast Rollback).
• Deploying new versions without negatively impacting user experience (minimizing downtime or data loss).
• Automation and Flexible CI/CD strategies.
• Docker and Kubernetes make it easier new deployment approaches (some containers st.).

How Many Deployment Strategies Are There and How to Implement Them Step by Step?

• Big-Bang Deployment
• Rolling Deployment
• Blue-Green Deployment
• Canary Deployment
• A/B Testing Deployment

1. Big-Bang Deployment

Downtime: There is downtime because the application is completely stopped.
Use Cases: Suitable for small applications or situations where downtime is tolerable.

2. Rolling Update Deployment

• Zero Downtime: There is no downtime for users.
• Gradual Update: Updates are applied gradually.
• Risk Management: Errors only affect the updated instances.

3. Blue-Green Deployment

• Zero Downtime: Users do not notice the transition.
• Quick Rollback: If issues arise, you can redirect traffic back to the Blue environment.
• Resource Usage: Requires more resources as two complete environments are needed.

4. Canary Deployment

• Risk Mitigation: The impact of potential issues is minimized.
• Real User Testing: The new version is tested with real users.
• Flexibility: The deployment speed and scope are controllable.

5. A/B Testing Deployment

A/B Testing Tools & Analytics: Monitoring user reactions and measures feature performance. Data is everything.

Here are some useful tips for tests, deployments, and business features:

• Understand the work and requirements well, and choosing the right strategy will show itself.
• Frequently downtimes can make the application seem low quality.
• Testing customized to the requirements can save time.
• Not every strategy works for every business.
• If there’s critical data and processes in production, downtime can be a big problem.
• For managing risks, follow a step-by-step process and make sure to do environment-based testing.
• We can give users the best experience with strong data handling and monitoring.

Happy testing and deployments…

gRPC is a high-performance, language-agnostic remote procedure call (RPC) framework developed by Google. It’s designed for efficient communication between microservices and is based on the HTTP/2 protocol. While gRPC offers impressive performance out of the box, it’s essential to conduct performance testing to ensure your services can handle real-world loads effectively. In this comprehensive guide, we’ll explore the importance of performance testing for gRPC services and provide code examples and best practices to help you get started.

Setting Up a gRPC Service for Performance Testing

Before we dive into performance testing, let’s set up a simple gRPC service and client for demonstration purposes. We’ll use Python and the gRPC library for this example.

Installing gRPC for Python

You can install the gRPC Python library using pip:

Creating a Simple gRPC Service

Let’s start by defining the service interface in a Protocol Buffers (protobuf) file:

Now, generate the Python code from the protobuf file:

Implementing the gRPC Service

Let’s implement the gRPC server:

Creating a gRPC Client

Now, let’s create a simple gRPC client to interact with the service:

Conducting Performance Testing

Now that we have our gRPC service and client set up, let’s conduct performance testing using two popular tools: Locust and Gatling.

Performance Testing with Locust

Installing Locust

You can install Locust via pip:

pip install locust

Writing a Locust Test Script

Here’s a Locust test script that simulates multiple users making gRPC requests:

Running the Locust Performance Test

You can run the Locust test with the following command:

Locust will start a web-based UI on `http://localhost:8089`, allowing you to configure and run your performance test.

Performance Testing with Gatling

You can download Gatling from the official website (https://gatling.io/download/) and follow the installation instructions.

Writing a Gatling Simulation

Here’s a Gatling simulation script for testing gRPC services:

Running the Gatling Performance Test

You can run the Gatling test using the following command:

./gatling.sh -s CalculatorSimulation

Gatling will generate detailed reports and metrics to help you analyze the performance of your gRPC service.

Conclusion

Performance testing is essential to ensure your gRPC services can meet the demands of real-world traffic. In this comprehensive guide, we set up a simple gRPC service and client and performed performance tests using Locust and Gatling.

Happy Load Testing 🔖

References

• GitHub - mostafa/performance-testing-grpc-services: Performance Testing gRPC Services
• Quick start
• Building a gRPC service with Java | Google Codelabs

I have been looking at Jules Verne’s magnificent world with admiration since my childhood. His books, filled with adventurous and fantastical worlds and extraordinary inventions, have captivated me. But Jules Verne’s influence not only nourished my imagination but also played a significant role in shaping my career as an engineer.

Jules Verne is one of the famous French writers of the 19th century. His works are considered pioneers of science fiction and adventure genres and are still popular today. So, how can this famous author make me into an engineer?

Some of Jules Verne’s most famous works present a magnificent blend of imagination and technological discoveries. “Twenty Thousand Leagues Under the Sea,” “Journey to the Center of the Earth,” and “Journey to the Moon” are among these books, narrating fantastic adventures that push the boundaries of technology during that era. The advanced technologies featured in these works laid the foundation for many inventions and devices that did not yet exist at that time. Jules Verne’s works skillfully combine science fiction and adventure genres, transporting readers to different worlds. The inventions and technologies depicted in his books were incredibly forward-thinking for their time and surpassed the imagination of that era. For instance, the submarine Nautilus featured in “Journey to the Center of the Earth” is considered the first submarine used for underwater travel and was a futuristic invention ahead of its time.

As I read Jules Verne’s books, instead of pushing my imagination to its limits, I began to contemplate how I could work in the real world. My interest in the field of engineering was further strengthened by the details and scientific approaches found in his works. Especially in books like “Around the World in Eighty Days” and “From the Earth to the Moon” various machines, vehicles, and mechanisms described became a source of inspiration for me. Verne’s works emphasize the importance of science and its contributions to human development. Engineering is closely intertwined with science, and his books excite those interested in engineering. Inventions, discoveries, and challenging technical problems capture the attention of engineering professionals and encourage them to come up with new solutions.

During my engineering education, Jules Verne’s books inspired me to create realistic and innovative projects based on scientific principles. His vision and creativity encouraged me to tackle more complex problems instead of settling for ordinary solutions. At the same time, they strengthened my belief that I could overcome any challenge.

Jules Verne’s works have been a source of inspiration for many individuals working in the field of engineering. His imaginative worlds help us envision what could be achieved in the real world. By reading his works, I have decided to pursue a more creative and innovative path in my engineering career. Jules Verne’s characters take bold steps to explore the world and push the boundaries. Similarly, engineers in the real world overcome challenges and undertake significant projects and discoveries. Verne’s works inspire engineers to dream big and work towards turning those dreams into reality.

Jules Verne not only drew me into the realms of fantasy but also had a profound impact on nurturing my passion for engineering.

In Verne’s books, characters overcoming challenges by working together emphasizes the importance of teamwork. Engineers, too, are aware of the power of teamwork and collaborate for successful projects and technologies.

In “Twenty Thousand Leagues Under the Sea,” the main characters Professor Aronnax, Ned Land, and Conseil embark on a journey aboard the submarine Nautilus under the leadership of Captain Nemo. The crew of Captain Nemo consists of sailors and scientists with diverse expertise. Each character contributes to the functioning of the submarine and collaborates to overcome challenges.

In “Around the World in Eighty Days” the protagonist Phileas Fogg and his loyal servant Passepartout must complete a journey around the world in 80 days. Throughout their journey, they encounter various challenges in different countries. Passepartout’s witty personality and Phileas Fogg’s logical thinking style make them a strong team and lead them to success in their journey.

In “From the Earth to the Moon” members of the American Gun Club plan a manned journey to the Moon. The project’s success relies on the members’ abilities to work together as a team. Each member takes on tasks in their respective areas of expertise, working together to achieve their common goal.

These examples from Jules Verne’s works illustrate how teamwork and collaboration play essential roles in overcoming obstacles and achieving success. Just like the characters in the novels, engineers understand the significance of teamwork in developing projects and technologies, and they actively engage in collaboration for successful outcomes.

In the novel “Robur the Conqueror,” the main characters encounter the mysterious and charismatic Robur, who pilots the flying machine “Albatros.” Robur’s crew forms a team under his leadership and manages the Albatros. Teamwork plays a vital role in safely navigating the flying machine and undertaking a world tour.

In real life, complex projects also require teamwork and collaboration to achieve significant goals. Verne’s works serve as a reminder to readers of the power of teamwork, emphasizing the importance of working together and complementing each other’s skills to achieve greater success.

The fantastic worlds where imagination, technology, and exploration converge in Verne’s novels remind engineers of their potential to change the world and lead them to new and exciting projects. By reading Verne’s books, engineering enthusiasts can find inspiration to think bigger, push boundaries, and make positive contributions to the world.

I believe that through reading Verne’s works, engineering enthusiasts will be inspired to think bigger, challenge the limits, and make positive contributions to the world.

Enjoyable reading with Jules Verne Books 🫶🏻 ☕️

Performance testing plays a critical role in ensuring the stability, scalability, and reliability of applications in the field of software development. Therefore, it is essential to emphasize the significance of performance testing.

Users now expect fast, seamless, and impressive experiences rather than just functional applications. This is precisely where performance testing comes into play. Performance testing is a vital process that evaluates, analyzes, and improves how efficiently a software, application, or system operates.

Get ready to learn how to prepare performance tests that will elevate your applications to new heights.

How to Design Efficient Load Tests?

• Test Objectives: Define the specific purposes and objectives of your load test.
• Test Scenarios: Identify the scenarios you want to simulate, such as high user load, API performance, or stress testing.
• Test Data Management: Efficiently use test data to provide realistic and consistent load test scenarios.
• Scalability and Concurrency: Optimize your load tests for high concurrency and scalability.
• Test Environment Isolation: Create isolated and controlled test environments to prevent interactions with production systems.
• Virtual Users and Ramp-Up: Determine the number of virtual users and the ramp-up strategy for your load tests.
• Response Verification: Implement response verification to ensure the accuracy of the application’s behavior.
• Identifying Performance Issues: Learn techniques for identifying and diagnosing performance issues during load testing.
• Logging and Error Handling: Implement logging and error handling mechanisms to capture relevant information during tests.
• Test Configuration: Configure advanced settings, including iterations, duration, and test environment variables.
• Load Testing APIs: Explore techniques for effectively loading test APIs, including rate limiting, authentication, and data-driven tests.
• Integration with CI/CD: Integrate performance tools into CI/CD pipelines for seamless performance testing as part of your development workflow.
• Real-Time Monitoring: Visualize test measurements and identify performance bottlenecks with real-time monitoring capabilities.
• Performance Thresholds: Define performance thresholds and analyze test results against these criteria.
• Exporting Results: Learn how to export and share test results for further analysis.

Types of Performance Test Patterns

1. Fixed Ramp Model (Linear Load Model): In this model, the load on the system is gradually increased over a specific period of time. The number of users or transactions starts from a low value and steadily increases at a constant rate until it reaches the maximum load. This model is useful for identifying performance issues that arise only when the load increases over time.

2. Constant Load Model: This model involves applying a constant load to the system for a specific duration. It helps to understand the system’s behavior under a steady load.

3. Spike Load Model: This model involves a sudden increase or decrease in the load generated by a large number of users. It helps to understand how the system behaves during abrupt load changes.

4. Stress Load Model: This model involves testing the system under extreme load conditions. It helps determine the system’s maximum capacity and how it recovers from failures.

5. Soak Load Model (Endurance Testing): This model includes applying a moderate load over an extended period. It helps identify memory leaks and performance degradation over time.

Performance Testing Building Blocks

While setting up performance testing, several hindering factors may arise, such as:

Test Environment Issues: A suitable test environment is crucial for conducting performance tests. However, problems may occur when the test environment is insufficient, lacking the necessary hardware, software, or network resources.

Test Data Accessibility: Realistic and representative data is essential for performance testing, including user profiles, database records, files, or other data necessary for the system to function correctly. Difficulties in accessing this data can impact the test’s realism.

Dependencies and Integration Challenges: Systems may interact with other systems, services, or components. During performance testing, providing and managing resources required by dependencies or integrations can be challenging.

Test Scenario Definition: Accurate and comprehensive definition of performance test scenarios is vital. Errors, such as scenarios not accurately reflecting user interactions, workflows, or intensity levels, or neglecting important scenarios, can affect the effectiveness of performance testing.

Test Planning and Coordination: Performance testing may require the participation of multiple teams or stakeholders. Factors like test planning, resource allocation, timing, and coordination can lead to challenges. Communication gaps or discrepancies can hinder the testing process.

Long-Term Execution of Test Scenarios: Performance tests often run for a specific duration, generating a substantial load on the system. Successfully managing resources, timing, permissions, and other practical challenges is necessary for sustained long-term testing.

Inability to Reproduce Issues: During performance testing, encountered problems or performance issues should be reproducible. However, sometimes issues may not be replicable or are difficult to recreate, hindering the identification and resolution of performance problems.
These hindering factors represent possible challenges one may encounter while conducting performance tests. Adequate planning, resource management, communication, and teamwork are essential to address these challenges effectively.
Performance testing strategy comprises the steps and approaches taken to accurately evaluate the performance of an application or system. Below, general performance testing strategy and “shift-left” performance testing strategy are briefly explained:

Performance Testing Strategy:

The Shift-Left performance testing strategy may include:

Code Review: Reviewing and optimizing code snippets critical for performance.

Integration of Performance Test Tools: Integrating performance test tools into the development environment and running automated tests continuously.

Realistic Representation of Test Data: Ensuring that test data used in the development environment closely resembles real production data.

Frequent Performance Testing: Conducting performance tests regularly, especially when adding new features or making updates.

Continuous Improvement for Performance Optimization: Regularly analyzing performance test results and making performance improvements.

The Shift-Left performance testing strategy is an important approach to detecting performance issues early, providing quick feedback, and preventing costly fixes. This strategy involves making performance monitoring and improvement an integral part of the development process.

How to perform performance testing for both the backend and the frontend may require different approaches as each component has different testing requirements.

Here are the basic steps to follow when performing backend and frontend performance tests:

Backend Performance Testing:
To test the backend part of the application, you need to define various scenarios that can simulate specific functions of the application and high-usage situations. For instance, you can test critical functions such as database queries, API requests, and complex calculations.

Prepare the test environment with the necessary backend infrastructure, such as servers, databases, and caching mechanisms.
Deploy the latest version of the backend application and ensure it is properly configured.

To conduct performance tests, you need to set up the environment where the testing will take place. This environment can be a staging server, a test server, or a scalable cloud solution, depending on your application’s requirements and the scale of testing.

As for selecting a performance testing tool, you have several options available, such as Apache JMeter, LoadRunner or k6 Each of these tools can help you create test scenarios, execute load tests, and analyze performance metrics.

Additionally, you can use Grafana to create a custom dashboard where you can query and visualize data from multiple sources, including various backend endpoints. Grafana can help you gain insights into the performance of your application during load testing and monitor key metrics effectively.

The choice of the specific tool and environment will depend on your project requirements, the complexity of the application, and your team’s familiarity with the tools. Whichever tool you choose, make sure it aligns well with your testing objectives and provides the necessary features to effectively evaluate the backend performance of your application.

Frontend Performance Testing:
Frontend performance testing should include factors such as page load times, responsiveness of interactive elements, and overall user experience of web pages. Determine performance tests for different pages and scenarios to evaluate the frontend performance thoroughly.

Tools like WebPageTest, Lighthouse, and Chrome DevTools are available for frontend performance testing. These tools are helpful in assessing page load times, identifying unoptimized resources, measuring render times, and evaluating user experience. When conducting frontend performance tests, it’s essential to simulate different devices and connection speeds. This way, you can understand how the web page performs across various platforms.

Based on the results of performance tests, identify areas that affect the webpage’s performance. For instance, you may discover optimization opportunities such as compressing unoptimized images, reducing file sizes, or utilizing browser caching. By addressing these optimizations, you can improve the frontend performance of the web page and enhance the user experience.

To improve frontend performance, you can utilize the identified optimization opportunities. Here are some common optimization techniques:

Reduce File Sizes: Minimizing the size of images and other media files can significantly reduce page load times, resulting in a faster user experience. Image compression and optimization of other assets can be employed.

Enable Caching: Implementing caching mechanisms allows web browsers to store certain resources locally, reducing the need for repeated downloads. This leads to quicker page loads for returning users.

Asynchronous Loading: Employ asynchronous loading for non-essential resources like scripts and stylesheets. By loading these resources in the background, the main content can be displayed more rapidly to users.

Regularly repeating performance tests and adopting a “shift-left” approach from the early stages of the development process helps in identifying performance issues early and addressing them more effectively. This way, you can provide a faster and more efficient experience for your users.

Happy Load Testing! 📌

References

• JMeter Ramp-Up Period: The Ultimate Guide | BlazeMeter by Perforce
• Soak Testing - GeeksforGeeks
• Understanding the Different Types of Load Tests: Goals and Recommendations

Hello everyone, ✋🏻 I will tell you about our ‘The Buy with Friends’ project, which we recently launched, and the work we have done in the test area throughout this adventure.

First of all, Let’s look at what the ‘The Buy with Friends’ project is…

The Buy with Friends feature is an application implemented on an online shopping platform for the first time in Turkey and allows customers to buy products with their friends at a discount.

For discounted products defined by sellers, customers will be able to both purchase the product at this price and share the product link with their friends through certain platforms. If the group reaches the targeted number of people within 24 hours, the discount will apply. Thanks to the Buy with Your Friends feature, we can purchase discounted products with our friends and have a pleasant shopping experience.

What have we experienced in process management and what should we pay attention to?

1. First of all, the team should act in cooperation in such projects where time management is important
2. A test plan should be drawn up with the team for both UAT and automation tests
3. Before the development process, test environments (stage, prod, pre-prod, uat, etc.) should be prepared
4. Data should be updated, if any, definitions should be made
5. Test cases should be determined in Planning and Refinement meetings and noted in the Project Management Tool (exp: JIRA) used
6. Test data should be collected, if possible, it should be made dynamic (generate dynamic data)
7. Regular know-how share meetings should be held within the team
8. Root cause analysis of errors in test runs should be removed
9. Risk detection of the application should be done
10. Test Support Documentation should be prepared for the test activity with different teams and announced through common channels
11. Test reports should be shared and reviewed with the team
12. The cause of Flaky Test scenarios should be investigated
13. Test environments should be kept stable
14. The most important thing is to keep an open mind and take joint responsibility throughout the process

What work did we do for testing in the GroupDeal project?

Being testable in the operation of a system or process is arguably one of the most important requirements. Analyzing the major requirements, making the developments, or preparing the environments, the purpose of all this is to prepare the system for a test run.

In our GroupDeal project, we paid attention to test-centered development and ran all tests in parallel with the development. We also ran each test snippet with the CI/CD implementation. The functional and non-functional tests we apply are as follows :

Test Types for GroupDeal Project :

Functional Testing

• Unit Test
• Integration Test
• Acceptance Test
• Journey (Regression) Test
• UI (User Interface) Testing
• Test Scripts

Non — Functional Testing

• Performance Test
• Load Test

Now Let’s look at what these tests are and their contents :

1. Unit Testing :

It is the smallest test unit where the verification and validation processes of each independent module are made. The developer who writes the code writes unit tests before development to test the smallest piece. Unit Test is a kind of White Box test. Because they are fast and easy to write, they provide a high level of test coverage. In this project, we wrote our unit tests using xUnit xUnit is a free, open-source testing tool that .NET developers use to write tests for their applications.

public void it_should_create_deal()
    {
        // given
        var createDealCommand = _fixture.Create<CreateDealDto>();
        // when
        var dealAggregate = new DealAggregate(createDealCommand);
        // then
        dealAggregate.Status.Should().Be(Status.Created);
    }

2. Integration Testing :

It is to ensure that all modules and units that we test independently are tested together. The aim is to minimize the interoperability of the integrated parts and the error rate in the increasingly complex system.

public async Task it_should_insert_dealAggregate_when_version_is_zero()
    {
        // given
        var command = _fixture.Create<CreateDealCommand>();
        var aggregate = new DealAggregate(command);
        var repository = _context.GetRequiredService<IDealRepository>();
        // when
        await repository.Save(aggregate);
        // then
        var expectedAggregate = await repository.GetById(aggregate.Id);
        expectedAggregate.Should().NotBeNull();
        expectedAggregate!.Id.Should().Be(aggregate.Id);
    }

3. Acceptance Testing :

It is the type of test for fault finding, in which we test the functionality of all functions in the system and consider all alternatives. Requirements are clearly stated. It helps us where the feature needs to reach. Therefore, Acceptance tests act as a guide and speed up the testing processes. It is also called Feature Test or API Acceptance Criteria.

Now let’s look at an example Acceptance Test Scenario :

Given : The seller navigate to groupdeal page
When : The seller create a deal
And : Enters a valid product to start a campaign 
Then : The system sends the succesful message

4. Journey Testing :

It is the type of test where we test the newly developed features or check if there are any problems after the errors in the application are correct. It covers Business Test cases as it validates the entire flow. New enhancements help us control the end-to-end (E2E) application before it goes live. It also makes sure that new enhancements don’t break anything else in the app. A stable test environment is important because all components and integrations in the system are activated and tested.

// DealCreateTest.java
 
package tests;
import base.DealBaseTest;
import org.testng.annotations.Test;
import static org.testng.Assert.*;
 
@Test()
@Step()
public void it_can_not_be_created_deal_id_when_final_price_is_higher_than_expected_maximum_price() throws Exception {
    //Given : Requested for Create deal id
    var createdDeal =  createdDealId( "Test", "12345", ...);

    //When : get deal response with id
    var dealResponse = getResponseWithDealId(createdDeal.getDealId());

    // Then : Expected null dealId
    assertThat(dealResponse.getId(), Matchers.nullValue());
}

5. Test Scripts :

Tests we write to help us automate manual testing and repetitive tasks.
Example: Group order creation, Order Cancellation, Campaign Define or Termination, etc.

6. UI (User Interface) Testing :

We chose to use Cypress to write tests of our campaign identification screens. Cypress has a simple and understandable syntax. It has a high community rate and a wide range of documentation. Also, Cypress uses a real browser when running tests. End-to-end tests run fast and are secure and stable.
Cypress can also be used for unit and integration testing.

checkFilterVisible() {
        this.elements.containerFilterActions().should('be.visible');
        this.elements.inputProductName().should('be.visible');
        this.elements.inputProductName().click();
        this.elements.inputProductName().type("Oyun Kolu");
        this.elements.inputBarcode().should('be.visible');
        this.elements.inputBarcode().click();
        this.elements.inputBarcode().type("12345");
}

7. Performance Testing :

After each application is released, we perform performance tests to measure how much the improvements made affect the system. The results are compared with the previous harness report. Response time and error rates are reviewed and shared with the team.

8. Load Testing :

It is the type of test we do to see how the system behaves under a certain load and to aim for bottlenecks in the application.

9. SonarQube — Code Quality :

The Sonarqube application, helped us do static code analysis before sending the source code to the production environment.
Test coverage rates were determined through the quality gate.

Programming Languages & Frameworks We Use

The programming languages and development tools we use are as follows.

How to API Test Deployment Coverage?

To understand how tests work, it is also necessary to understand the development environment. We tried to automate everything manageable in this process by establishing a CI/CD system. Now let’s see what we are doing in our deployment processes…

• After the developed works are built and committed, unit tests are run to provide Code coverage
• Acceptance or Integration tests are run
• When it comes to the Quality step in the Pipeline for static code analysis, quality rules are passed with the Sonarqube application.
• If there is any weakness in the Security gates step, the findings are shared with the team
• Deployed to the test environment
• Journey tests are run in the stage environment
• If available, it is deployed to the UAT environment and UAT cases are run.
• It is deployed to the prod environment and announced from the relevant channels
• Monitoring via New Relic / Grafana
• After deployment, review service logs
• Performance tests are run to see if the response time is affected after the deployment. The comparison with the previous deployment is shared with the team as a report on the slack channel.

Best Practices for API Test Automation

• Most software tries to achieve a principle called DRY — “Don’t Repeat Yourself”. This software is easier to maintain if every concept is standardly represented in one place and code repetition is kept to a minimum. This approach is particularly valuable for facilitating changes because an engineer only needs to update a single piece of code rather than keeping track of multiple references. Refactorings should be done to make tests more descriptive and meaningful, not just to reduce duplication
• As test projects grow, their maintenance becomes more difficult. That’s why the constant and method namings we use gain importance. The more descriptive and clear they are, the more helpful they will be in guiding us
• One of the most important parts of testing is to focus on validation and verification methods
• Instead of testing the system with some stable conditions, we should test it in bad and failing conditions
• As much as possible, test data should be created dynamically during testing and should work to include user behavior. Because we expect scenarios not covered by the test data to occur
• We want the system to perform well under a certain load and stress. The traffic each system can handle may vary

Advice on About Test Automation

• Writing automation has many tools and methodologies. Creating a project-specific requirement bridge is important for a high-quality automation infrastructure
• Accurate and inclusive testing should be added to every layer of the code base
• A structure should be established to receive continuous feedback during the testing process (CI/CD)
• Quality targets should be determined jointly

If you want to be part of a team that tries new technologies and want to experience a new challenge every day, come to us.

I hope it will be helpful for you… Happy Testing !

References

• https://learning.oreilly.com/library/view/full-stack-testing/9781098108120/
• https://learning.oreilly.com/library/view/software-engineering-at/9781492082781/

What did we experience about the GroupDeal Project Testing …? was originally published in Trendyol Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.

We want the same ease in JSX, right? Then let’s get it done right away with a little touch 😃

👻 After pressing the Studio Code Ctrl + P keys, let’s write “>Workspace Settings” on the screen that opens.

👻 Let’s go to the Emmet field and click “Edit in settings.json”..

👻 Let’s add the code below and save it..

{
"emmet.includeLanguages": {
"javascript": "javascriptreact"
 }
}

👻 And process done..

Hope to see you in the next article 🕵️‍♀️
Goodbye..

Kurulum için buradaki linkten Charles indirelim. Programı açtığımızda bizi aşağıdaki gibi bir ekran karşılayacak.

Yapmamız gerekenler :

1. Charles üzerinden SSL Proxy Settings üzerinden Host ve Port’u ayarlamak.

2. Bilgisayarımızı ve telefonumuzu “Aynı kablosuz ağa bağlamak”.

3. Bilgisayarımızda görünen IP adresi ve Port numarasını telefona proxy olarak eklemek.

4. Ardından iOS/Android için Safari/Chrome dan https://chls.pro/ssl adresinden SSL sertifikasını indirmek.

5. Telefon ayarlarından “SSL sertifikasına güven” diyerek doğrulamak.

6. Charles Üzerinden Host ve Portu Ayarlamak

Proxy ayarlarından “SSL Proxy Settings” kısmına giriyoruz.

SSL Proxying sekmesinden “Add” diyerek Host ve Portumuzu giriyoruz.

(Host=* / Port=* olacak şekilde)

Telefonumuzu ve Bilgisayarımızı Aynı Kablosuz Ağa Bağlama İşlemine Geldik :

NOT: Bilgisayar / Telefon aynı ağa bağlı olmak zorundadır.

Bilgisayarımızın IP adresini ve Portunu Telefonumuza Proxy Olarak Ekleyeceğiz..

IP adresini, Kablosuz Ağ ayarlarından görebilirsiniz. Aşağıdaki resimde IPv4 Address olarak gösteriliyor.

SSL Sertifikamızı indirelim :

Sertifika adını Charles Proxy, Used for kısmını VPN and apps yazarak dolduralım. İndirme işlemi bittikten sonra Charles açıp Proxy / SSL Proxy Settings seçeneğine tıklayalım. Hostu “utest” portu ise “443” olarak yazalım. Tamam diyip ekranı kapatalım.

Port numarasını ise Charles üzerinden değiştirebilir ve görebilirsiniz.Proxy ayarlarından Proxy Settings’e tıklıyoruz. Port numarası Default olarak 8888 olarak geliyor.

Telefondaki ayarlamaları yapıp Charles ı açtıgımızda bu adresten gelen verileri onaylıyor musunuz ekranında Allow seçeneğine tıklamamız gerekiyor.

İşte hepsi bu kadar.. Artık telefonunuzdan örnek bir web adresine ”https://www.utest.com.tr/” gittiğinizde bütün logları takip edebileceksiniz.

Bir sonraki yazımda görüşmek üzere.. Sevgiyle kalın :)

Flaky Tests are inconsistent and unreliable.

Even though everything appears to be the same and there are no changes in the code, different test results can be encountered.

Flaky tests can be caused by several factors :

• Issues related to newly written code: If there are bugs or errors in the code being tested, it can lead to inconsistent test results.
• Problems related to the test itself: The test may have dependencies on external resources that can introduce variability, such as network connections, databases, or third-party services. If these dependencies are not properly managed or are prone to instability, it can result in flaky tests.
• External factors compromising test results: Factors outside the control of the test environment, such as system load, hardware performance, or timing issues, can influence test outcomes and make them inconsistent.
• Environmental issues: Differences in the test environment, such as operating systems, browser versions, or hardware configurations, can impact the reliability of tests. Inconsistent environments can produce varying results.
• Timing and concurrency problems: Tests that rely on specific timing or concurrent execution of code can be susceptible to flakiness if the timing or order of operations is not precisely controlled or if there are race conditions present.
• Non-deterministic behavior: Certain code or operations may have non-deterministic behavior, meaning their outcome can vary each time they are executed. If the tests rely on such code or operations, it can lead to flaky test results. Overall, it’s essential to investigate and address these factors to minimize flaky tests and improve the reliability of the testing process.

Actions to be taken:

• Development of the application should be paused.
• The developer should investigate if there is an error in the code.
• Test results should be analyzed.
• Data should be collected by examining the failed results.
• It should be checked whether the tests are affected by the test environment.
• The network environment in which the tests are executed should be checked.

Hope to see you in the next conversation. 😉 Goodbye..