Forem: Tatenda Carl Sakarombe

Request Management and Variables in Postman

Tatenda Carl Sakarombe — Sun, 14 Jan 2024 14:57:50 +0000

🔍🚀Exploring API Testing Essentials with Postman!

👩‍💻 In the world of API testing, mastering tools like Postman is a game-changer. Today, let's unravel key aspects like saving requests, utilizing variables, and decoding query parameters.

💡🌐It's a journey where precision meets flexibility. Ready to dive in? Let's make API testing a breeze!
**
Saving Requests**
The key to handling requests efficiently is to create collections.

Before saving a request in Postman, you must start a collection.

These collections act as organized repositories, designed for a specific API or customized for a specific purpose.

Imagine them as carefully curated libraries that contain the complex interactions of APIs, guaranteeing a methodical approach to testing.
**
Storing and Creating Variables**
To improve our testing skills, we can utilize variables.

We start by emphasizing the base URL, which is an essential part of any API request.

By simply clicking on the 'set variable' button, Postman enables us to effortlessly create and store variables within the collection.

This not only makes the testing process more efficient but also provides us with the ability to modify variables as required.
**
Modifying Collection Variables**
In the ever-changing world of testing, being adaptable is crucial.

Postman understands this and offers a convenient way to modify collection variables.

By going directly to the collection, we can make instant changes, ensuring that our testing environment stays flexible and responsive to changing needs.
**
Query Parameters**
As we explore the API landscape, query parameters play a vital role in exchanging data.

The use of a question mark indicates the start of query parameters, and it is important to consider their sensitivity to uppercase and lowercase letters.

Postman, acting as the messenger, sends only the specific parameter category to the API.

Behind the scenes, the API utilizes this parameter to filter through the data.

Testing Tuesdays: Unveiling the Magic Behind API Testing!

Tatenda Carl Sakarombe — Fri, 05 Jan 2024 11:05:22 +0000

Scripts
In the world of API testing, scripts are the building blocks of automation.
These careful lines of code, when created with skill, become the tools that carry out accurate workflows and tests.
Workflows smoothly coordinate the sequence of steps an API call needs to go through, while tests carefully examine every aspect of functionality.
When these three elements come together, API testing becomes a well-coordinated symphony of precision.

Auto API testing
The Collection Runner is a fast executor that smoothly handles API requests in a predetermined order, guaranteeing a smooth testing process.
Newman, the pioneer, expands this capability beyond manual execution.
By integrating with CI servers like Jenkins and other CI counterparts, it transforms API testing into a streamlined and continuous process.

API documentation
Comprehensive API documentation plays a crucial role in fostering effective communication between developers and testers.
It acts as a compass, guiding testers through the testing process.
By providing clear and concise information about endpoints, parameters, and expected responses, it promotes collaboration and helps testers navigate the API terrain more easily.

Collaboration
Effective collaboration tools are essential in software development.
They act as a bridge between developers and testers, facilitating seamless communication and enabling testers to provide valuable feedback, report bugs, and engage in constructive dialogue with the development team.

Mock server
In the world of API testing, the Mock Server plays a crucial role.
By mimicking real-life situations, it enables testers to verify API interactions in a controlled and virtual setting.
This not only guarantees thorough testing but also promotes parallel development, where teams can work independently while still collaborating effectively.

Manual API testing
Amidst the rise of automation, manual API testing remains important.
The skilled tester's hands-on approach, navigating endpoints, examining limits, and discovering unique scenarios, brings a human touch to testing.
Manual testing serves as a crucial test, confirming the user's experience and ensuring a comprehensive testing method.

Postman and HTTP in Communication

Tatenda Carl Sakarombe — Fri, 29 Dec 2023 11:00:42 +0000

Postman is an extensively utilized tool for API development, which simplifies the interaction between clients and servers.

An API, also known as an Application Programming Interface, comprises a set of regulations that enable diverse software applications to exchange information.

In this particular scenario, Postman functions as a client, serving as a means for users to transmit requests to a server and obtain corresponding responses.

HTTP, also known as Hypertext Transfer Protocol, serves as the fundamental framework for data exchange on the global network known as the World Wide Web.

Functioning as an application layer protocol, it facilitates seamless communication between clients, including web browsers and Postman, and servers across the internet.

HTTP establishes the guidelines for message structure and transmission, as well as the expected responses from web servers and browsers in relation to different commands.

When a client, such as Postman, initiates an HTTP request to a server, it usually contains details regarding the specific operation to be executed (e.g., GET, POST, PUT, DELETE) along with any essential data or parameters.

Subsequently, the server handles the request and returns a response that encompasses the requested data or signifies the outcome of the operation, whether it was successful or unsuccessful.

The interaction between the client and server plays a vital role in numerous web-based applications and services.

It facilitates the seamless exchange of information, enabling functionalities like data retrieval, form submission, information updates, and more.

By employing HTTP, these interactions adhere to a standardized and uniform approach, promoting interoperability across diverse systems and technologies.

The significance of APIs in Software Testing

Tatenda Carl Sakarombe — Wed, 27 Dec 2023 09:57:25 +0000

APIs are the crucial link that binds applications to data repositories in the complex realm of software development. They can be likened to a covert gesture that unlocks the vast wealth of information stored on servers, typically nestled within databases. For a seasoned expert in software testing, comprehending the pivotal role APIs play in enabling smooth communication between programs and servers is akin to possessing a potent instrument in the pursuit of thorough and efficient testing.

The Key to Server Knowledge

In its core, an API functions as the key to the revered domain of server-stored data. Envision a stronghold of knowledge, protected by the API, enabling a program to not just communicate but also partake in a graceful exchange of data with the server. Devoid of this crucial interface, the server transforms into an impregnable fortress, rendering its abundance of information completely out of reach for the external realm.

Now, the fascinating aspect – APIs are not ready-made components. To unleash their capabilities, individuals must immerse themselves in the realm of programming code or utilize the powerful terminal to execute intricate commands. It is the enchantment, the magical formula that grants access to a realm of endless possibilities. As an expert in software testing, this is where your true expertise shines.

Introducing Postman, the maestro of API testing. Envision it as your enchanted tool, effortlessly establishing connections with servers through APIs and harmonizing the flow of data. There is no requirement to struggle with complex lines of code or commit cryptic terminal commands to memory. Postman streamlines this intricate performance, enabling effortless communication with servers.

Elevating Testing to a Harmonious Communication Ensemble

For those well-versed in software testing, the importance of Postman lies in its capacity to surpass the intricacies of API interaction. It revolutionizes the testing realm by providing a user-friendly platform that effortlessly navigates the complexities of server communication. Postman assumes the role of an intermediary, enabling a seamless and harmonious conversation between your testing suite and the server.

Unleashing the Power of Postman: A Comprehensive Guide to API Development and Testing

Tatenda Carl Sakarombe — Sun, 24 Dec 2023 15:34:45 +0000

In the fast-paced world of software development, the smooth communication between applications is extremely important. As we explore the complex world of APIs, it is essential to have a strong tool that can simplify the process. That's where Postman comes in - the perfect companion for developers, testers, and API enthusiasts.

Building Bridges with Postman
Postman's main strength lies in its ability to simplify the complex process of creating, testing, and documenting APIs. Think of this tool as the conductor leading the way in your API development journey.

Building Request: Creating Strong Connections with Accuracy
Postman enables developers to create requests with exceptional accuracy. Whether you're dealing with RESTful APIs, SOAP, or any other web services, the platform offers a user-friendly interface for constructing requests that effortlessly interact with your endpoints.

Collections: Simplifying Complexity, Unlocking Simplicity
In the vast world of API development, being organized is crucial for efficiency. Postman introduces collections, which help developers group requests in a logical manner. This improves clarity and speeds up the testing and validation process.

Environment Variables: Tailoring for Versatility
Postman understands that every development environment is unique, which is why it introduces the concept of environment variables. With this feature, developers can adjust requests in real-time to suit different environments, making the testing process flexible and adaptable.

Assertions
Testing involves more than just sending requests; it involves making sure the responses match what is expected. Postman's assertion capabilities enable developers to establish predetermined criteria, automatically validate responses, and guarantee accuracy in API interactions.

Automated Testing
In the age of agile development, efficiency is essential. Postman leads the way with its automated testing features. Developers can create test scenarios, enabling quick and consistent testing, minimizing manual work, and improving productivity.

Documentation
Postman is exceptional at ensuring transparency in API development. It effortlessly reveals the complexities of your APIs, generating detailed documentation that serves as a clear guide for both developers and stakeholders.

Mock Servers
Postman takes testing to the next level with the addition of mock servers. These servers imitate API endpoints, enabling developers to try out various scenarios and conduct experiments without impacting the real production environment. This is extremely beneficial for iterative development and testing.

Monitoring
In the fast-moving software development industry, being alert is crucial. Postman's monitoring feature enables developers to closely monitor API performance in real-time. By identifying bottlenecks, tracking down times, and ensuring the well-being of your APIs, this feature proves to be invaluable.

As I continue to discuss API topics at greater length, I will provide more practical uses for them and how you can implement these principles in your professional life.

The Upwork currency: Connects

Tatenda Carl Sakarombe — Wed, 08 Mar 2023 18:55:19 +0000

Hello Dev family! Today, I became aware of a feature that I found interesting on Upwork and it is called "Connects". Connects can be a form of digital currency on Upwork and it is used by freelancers to 'buy' the clients attention in the hope of an actual exchange of money if the 2 parties agree to work together. Of course, when starting out, Upwork gives the feelancer Connects so that they can start to bid for jobs/positions. I am keen to find out more about being a freelancer on Upwork and I am excited to be able to share my experience here on Dev. Thank you for reading and cheers!

currency #upwork

Three js: Scene, Camera and Renderer

Tatenda Carl Sakarombe — Fri, 03 Feb 2023 09:35:09 +0000

From what I can gather , there are 3 necessary components that make Three.js function and these are:

Scene
Camera
Renderer

To understand what I scene is, you can take movie scenes as an example. The scene is where all the objects are displayed, where they are positioned and what they look like.

A Renderer is what it's name implies and they allow the 3D graphics to be displayed. Webgl is the default renderer.

Cameras determine the way in which the scene is going to be viewed. This can be a perspective view, orthographic view etc.

As I delve deeper into uncovering the world of 3D graphics in Javascript, I am sure that I will encounter very interesting topics that will challenge me. Till next time...

Front-End development vs. UI Design. or are both equally important

Tatenda Carl Sakarombe — Thu, 09 Jun 2022 17:05:26 +0000

One hurdle I have recently come across in my web development career is really defining exactly what I do. What I mean by this is that I have 2 very similar interests, which are designing interfaces from scratch and then developing those designs into feasible front-end websites. As I have been looking for internships and junior roles lately, being a UI designer seems very attractive at this point as my design skills currently surpass my development skills. My question is, would it be better to abandon one at this point and solely focus on the other or should I do both?

1 and a half years learning JavaScript. Here is what I'd tell the past me.

Tatenda Carl Sakarombe — Tue, 03 May 2022 18:03:55 +0000

So, it has been about 1 and a half years of me learning JavaScript and honestly it has been a roller-coaster journey. If I could talk to the one year ago version of me, this is what I'd tell him:

Watch more coding videos. Watching videos of people coding shows you their thought process and it also shows you their mistakes, just to show you that everyone is human. This is especially important if you are self-taught and are experiencing some form of imposter syndrome.
Start blogging. It's very ironic that I am mentioning blogging in a blog but blogging actually helps with getting your ideas down and being able to explain your code. Another great thing is that the developer community is very friendly and people are always keen to see you improve.
Finding discord servers. This point ties in with the second one. Just find a community on discord and you'll be able to engage with different developers around the globe.
Visit different sites and try to mimic them. The most growth I have ever experienced is when I have visited professionally built websites and trying to mimic them. This essentially throws you into the deep and and forces you to find weird and out-of-the box ways to solve the problems.
In order to have structure, Read and follow a book. In the beginning of my JavaScript journey, I would just try to learn whatever I could without any kind of structure which really left me with looks of holes in my knowledge. Topics will become much clearer and if you can, write down notes just to keep track of what you have learnt.

As I progress further with my coding journey, I expect to encounter new and challenging topics and concepts and I am ready for the challenge. The ride has been good so far and I am far from reaching my destination so I might as well just enjoy the view!

Settling your priorities back on track...

Tatenda Carl Sakarombe — Thu, 21 Apr 2022 15:17:36 +0000

It feels weird to blog again after a couple of months away from the coding world. Actually, it feels weird being back in the coding world in general. The reason why I say this is because I, unintentionally, got caught up preparing for university that I did not leave too much time in my day to continue coding. Now that I am back, it feels as though I need to revisit the things I had learnt before I can proceed onto learning newer and more advanced things.

My time away has also allowed me to take things in and put things into perspective a little more. As I am more artistically inclined, I have found Three.js to be a fascinating realm of JavaScript as it involves both coding and 3D environments. In school, we have recently gotten to grips with C# and so far I can say that it has a lot of similarities with JavaScript.

Now that I am a student, in a completely foreign country, my ambition and determination to be the best coder I can be has been magnified because nothing is going to be given to me so I need to at least give 101% in order to achieve my short-term goals and ,eventually, the long term ones as well.

Building simple CSS cards that have transitions

Tatenda Carl Sakarombe — Wed, 26 Jan 2022 19:12:17 +0000

Ever wanted to make your site more interactive with just some simple HTML and CSS? If so, this is the post for and
I will be explaining how to make an interactive card that uses flex and scale.

Firstly, let us set up the HTML.

<body>
    <!--The card is a div itself and the div is comprised of subsections-->
    <div class="card">
        <!--Setting two divs allows us to use flex-->
        <div class="img">

        </div>
        <div class="text">

        </div>
    </div>
</body>

Notice that the div has 2 other divs in it. This makes it easier to apply flex in them.

The CSS is relatively easy too!

.card {
  height: 200px;
  width: 400px;
}

Giving the card a width of 400px may also make to possible to put the cards side-by-side and flex-wrap can easily be used to wrap the other
cards for a more responsive feel.

Secondly, let us add the image.

<body>
    <!--The card is a div itself and the div is comprised of subsections-->
    <div class="card">
        <!--Setting two divs allows us to use flex-->
        <div class="img">
            <img src="/Folder/img.png" alt="Vector Image" class="card-pics">
        </div>
        <div class="text">

        </div>
    </div>
</body>

To avoid size problems, set the preferred image sizes and in this case, I want an image height of 200px and a width of 175px.

.card-pics {
  height: 200px;
  width: 175px;
}

*Note
Instead of setting all the images to 200 x 150 I created a class for the cards because you may want to place
other images on your website and overriding each image can be a tedious task.

The third part involves the inclusion of text and the flex feature within the card class.

<div class="card">
        <!--Setting two divs allows us to use flex-->
        <div class="img">
            <img src="/Folder/img.png" alt="Vector Image" class="card-pics">
        </div>
        <div class="text">
            <h1 class="card-header">Lorem</h1>
            <p class="card-para">Lorem ipsum dolor sit amet consectetur, adipisicing elit. Minima eveniet quisquam reiciendis eum vitae?</p>
        </div>
</div>

.card {
  height: 200px;
  width: 400px;
  display: flex;
}

The text is too close to the image.Let us give it some breathing space.

.text {
  padding: 20px;
}

The fourth part includes border-radius. It works by rounding the corners you want rounded. If you enter four values, expect them to be set in a clockwise manner.

.card {
  height: 200px;
  width: 400px;
  display: flex;
  align-items: center;
  background: #ddd;
  border-radius: 30px 0 30px 0;
}
.card-pics {
  position: relative;
  border-radius: 30px 0 0 0;
  height: 200px;
  width: 175px;
}

So we now have everything set, what about the zoom in effect? The zoom-in event is triggered by an event. Events include :focus and :hover.
Scale helps increase the image size.
A common problem that people encounter here is that they often set their code in such a way that instead of triggering the image to grow on card:hover,
they set it on img:hover.
To avoid this we can say that when we hover on card, we want the image to grow. Check the code below.

.card:hover {
  .card-pics {
    scale: 1.05;
  }
}

After following the above code, you may have noticed that the image is outgrowing it confines. The solution is simple. Since the image is within the card div, you can
easily set the can in such a way that it hides any overflow.

.card {
  height: 200px;
  width: 400px;
  display: flex;
  align-items: center;
  background: #ddd;
  border-radius: 30px 0 30px 0;
  overflow: hidden;
}

Now that is taken care of, let us get a little bit fancy. Maybe some transitions.
When we hover, we want it to animate.

.card:hover {
  .card-pics {
    transition: all 300ms ease-out;
    scale: 1.05;
  }
}

The transition when we hover works but as soon as we leave, there is no animation. We can fix this by leaving another transition in the card-pics
but this time it will be an ease-in effect.

.card-pics {
  position: relative;
  border-radius: 30px 0 0 0;
  height: 200px;
  width: 175px;
  transition: all 300ms ease-in;
}

This that we have a good looking card, we can use this concept to apply it to many different problems we encounter in
the CSS world. Have fun!

Hiding and Revealing things with JavaScript pageYOffset

Tatenda Carl Sakarombe — Wed, 19 Jan 2022 18:31:06 +0000

Quite a while ago I was cloning a website and I stumbled on something I was not familiar with. It took me a while to comprehend what exactly I was looking at. The website had a Navigation bar and that bar would hide itself when you would scroll down the page and shows p when you scroll up. Weird!

My first instinct told me that I could fix this using CSS at first.

.nav-bar{
display:hidden;
}

Hidden display was my first guess but I quickly realized that it completely hides the nav-bar (without ever returning). I thought a little harder and came to the conclusion that it has something to do with JavaScript because I believed that it could trigger a function that could execute IF a condition is met. The condition was that IF I scroll down, the nav-bar should be hidden or ELSE, keep showing the nav-bar. In order to deepen this explanation, an example can be provided. Jimmy wants a chocolate but his mother will not give him one. The chocolates are located in the kitchen cabinet. The only way Jimmy can get a chocolate is if he gets it into the kitchen, without his mom knowing, and taking from there. IF mom is not there then he can sneak into the kitchen quietly. But if she does come into the kitchen then he should hide quickly behind the kitchen counter.

Firstly, let us add an event listener. An event listener method allows JavaScript to constantly monitor the browser to see if specific conditions are being met (in your declared function). In this case, we want JavaScript to listen in on a scroll event. I named my function scrollDown because the conditions I shall list down only apply when I scroll down.

window.addEventListener("scroll", scrollDown);
/* 'e' parameter stands for event */
function scrollDown(e) {
    let navigation = document.getElementById("nav-bar");
    if(window.pageYOffset > 500){
        navigation.style.display = "none";
    }
    else{
        navigation.style.display = "block";
    }
}

Start by declaring a navigation variable that get the Identification from your html so that Js knows what your are referring to. Secondly, we shall refer to the Y-axis because we are scrolling vertically. JavaScript calls this pageYOffset. So, If the pageYOffset is greater than 500px then hide the navigation. If the condition is false then show it again. The code works but only half way. We need to work on the other half, the part when we scroll up. The problem is that when we scroll up, the nav-bar does not appear again.

window.addEventListener("scroll", scrollUp);

function scrollUp(e) {
    let navigation= document.getElementById("nav-bar");
    if(window.pageYOffset <500){
        navigation.style.display = "block";
    }
    else{
        navigation.style.display = "none";
    }
}

Now that the code works, go and have fun with it. Maybe you can change the words of a heading as your scroll down. Or change the color of the nav-bar as you scroll.

Thanks for reading!