{"id":2789,"date":"2020-03-17T01:20:02","date_gmt":"2020-03-17T01:20:02","guid":{"rendered":"https:\/\/codoid.com\/software-testing-tutorial-for-beginners\/"},"modified":"2022-02-04T18:36:50","modified_gmt":"2022-02-04T18:36:50","slug":"software-testing-tutorial-for-beginners","status":"publish","type":"post","link":"https:\/\/codoid.com\/software-testing\/software-testing-tutorial-for-beginners\/","title":{"rendered":"Software Testing Tutorial for Beginners"},"content":{"rendered":"

On this planet everything that is developed should be tested, officially or unofficially. In our rota, we tend to do a lot of testing<\/b> but we don\u2019t realize because they are part and parcel of daily routines. In a similar profession, the information technology stream adopted the testing domain as one of their power to ensure that the application or software designed working as intended and it serves the purpose.<\/p>\n

In this blog we are going to give the knowledge related software testing from the very basic level even a novice will be able to follow.<\/p>\n

One must brainstorm themselves to get the motivation of being a software tester<\/b>. Being an art testing requires some of below skillset.<\/p>\n

<\/i> Intelligence<\/p>\n

<\/i> Out of box thinking<\/p>\n

<\/i> Disciplinary and punctual actions<\/p>\n

<\/i> Planning <\/p>\n

<\/i> Leadership abilities<\/p>\n

The mentioned skills were quite common for any profession but when it comes to the point of testing they play an additional role but are mandatory to possess. We keep everything crossed for you to choose to test as your profession, be ready to break the system in a procedural manner and ensure that you are of great help to your team always to launch a perfect flawless product<\/a>.<\/p>\n

Understanding the SDLC<\/strong><\/p>\n

As a pre-requisite, we would strongly recommend one to give yourself a walkthrough on SDLC (software testing life cycle), while going through the below content. A blog can still be understood without SDLC knowledge but it\u2019s recommended as that way you connect the dots while undergoing discovery learning to understand better.<\/p>\n

What is software testing?<\/strong><\/p>\n

Software testing a process of identifying the bugs present in the software by validating all possible scenarios that are applicable to the software. In this formal process, we design test cases<\/a> basis the understanding of the application then executes to deem the correctness of the software<\/p>\n

Why is software testing required?<\/strong><\/p>\n

For an illustration, let\u2019s consider that a bank has launched one of its internet banking system applications<\/a> into production for use without testing. It is evident that customers are going to initiate transactions and apply for various services that are offered by the system. <\/p>\n

There is a high probability for the customer-friendly scenarios could fail, which in turn cause the bank to lose its reputation and trust in the market and it\u2019s very expensive for the bank to correct the mistake and re-work on the application<\/p>\n

1. Initiated transactions might get failed due to various reason<\/p>\n

2. Fund would have not credited at the receiving end <\/p>\n

3. Can\u2019t be able to query about the balance?<\/p>\n

4. Can\u2019t apply for cheque leaves through the internet banking system.<\/p>\n

In the above discussion, it\u2019s a software imagine its software component that performs some physical actions based on the input such as airbag release system in the car, automotive alarms elevators, and lift..etc. failing which can cost lives. So we need to keep the mindset in such a way that, if the application or a working software is not tested we are going to see a huge amount of loss which is difficult to recover from. So we know why testing is essential now, great understanding!!! <\/p>\n

Principles of testing<\/strong><\/p>\n

There are a few principles that must be learned which explain the reasoning of testing in all possible views, why wait? Let\u2019s see them quickly<\/p>\n

Early testing is beneficial<\/b><\/p>\n

How early we start to test, that early we can stabilize the system also it’s true that early bugs are cheaper<\/b> than bugs that are identified late in the business. When we say cheaper if we can identify and fix them early we can avoid doing late regression testing and that as well helps to meet the deadlines. So we should adopt a process that helps us proceed with test activities early in the software life cycle.<\/p>\n

Error absence is the fallacy<\/b><\/p>\n

Though the intention is to test as much as we can and identify all possible bugs, we can guarantee that system if bug-free and 100% flawless. We might have misbehavior seen at a very low level that might not have caught up in our test scope or an unfortunate miss. Despite the principle, we should always ensure that we don\u2019t cover any bug present in customer use cases.<\/p>\n

Exhaustive testing can\u2019t be conducted<\/b><\/p>\n

As part of the testing phase in the software development life cycle, we will conduct various levels and types of testing, but it\u2019s still difficult to cover all the scenarios including positive and negative. Given the timelines for the testing phase we should understand the prioritized edge tests also we need to apply the proper test case techniques to make sure a few test cases will give more coverage. <\/p>\n

Pesticide paradox (redundant test case)<\/b><\/p>\n

We should be continuously reviewing the test cases in order to ensure we have powerful tests and no more duplicates present. If the same tests are being executed again and again we end up identifying no defects. Every time there is an operational change or enhancement in the module, we should build the tests accordingly.<\/p>\n

Defect clustering<\/b><\/p>\n

In any software system, every component has to be treated and tested thoroughly, it could be that most of the defects might be happening in smaller components or from a module which we don\u2019t even think of. We should always focus on the integration pieces and also focus on edge cases as that gives confidence that either boundary are working.<\/p>\n

Testing shows the presence of defects<\/b><\/p>\n

It\u2019s evident that only testing allows us to find defects, how much diligence we possess while testing that much defect rate can be achieved and in turn can help the business to make the application more stable within the nominal time.<\/p>\n

Testing is situational dependent<\/b><\/p>\n

We should keep changing the mindset and the game plan when we are supposed to test different applications or different software. The same strategy will not help us to find the bugs and which will cause so many complexities within the domain. For an illustration, the plan that\u2019s applied for testing a banking-related application may not be useful to test the retail application or insurance application as the requirements and usage are significantly varying.<\/p>\n

Software testing life cycle <\/strong><\/p>\n

STLC is a part of SDLC, it\u2019s one of the phases which is executed after completion of development. It\u2019s essential to understand the phases involved in the testing life cycle as that helps us apply the right testing approach. The steps involved in STLC are<\/p>\n

Requirement analysis understanding<\/b><\/p>\n

In this phase, the goal is to analyze the requirements thoroughly to understand the functionality. Any clarification that would be required should be clarified by discussing with the business analysts or the subject matter experts. <\/p>\n

Test plan<\/b><\/p>\n

Once the requirements are understood we should plan for proper testing. We should also define the scope as what comes into the scope and what can\u2019t be. We should also plan the number of resources that would be required also the timelines.<\/p>\n

Test case design<\/b><\/p>\n

Basis the understanding the test case design should be commenced. By following the proper test case development techniques also keeping the type of test in scope we should have the test cases designed. Since the tests designed are going to be executed for finding the defects. Hence proper understanding of the design techniques are needed.<\/p>\n

Test data preparation<\/b><\/p>\n

Test data plays an important role in the execution front. Based on the test data the test execution flow changes, hence apparently we can believe that test data has the ability to drive the test case. We should identify possible combinations of negative and positive scenarios. Test data plays a major role in automation as well, in a pure data-driven or hybrid framework, we can execute the same test with different sets of inputs than writing them as a separate test case. Test data can be maintained in Database or in excel spreadsheet or in any other known form.<\/p>\n

Test execution<\/b><\/p>\n

Once the designing of the test cases and identification of test data is done we need to execute the test cases. Any underlying bugs present in the system can possibly be found in this phase. Due diligence is required while executing the tests as we need to catch up with minor cosmetic bugs as well. Every execution report should be shared with all the stakeholders for their reference and also help with understanding the progress of the test<\/p>\n

Test closure<\/b><\/p>\n

As a test closure activity we will share the final results observed during the execution phase in a detailed format. We will put in graphs, bar charts and presentations so that the higher management can actually understand the status better. Also, the sign-off documents, test risk assessments, and test completion reports are being circulated to get the approval from all business stakeholders.<\/p>\n

Test case development techniques<\/strong><\/p>\n

While writing the test cases it\u2019s essential to adopt the techniques to be smart enough also to ensure the coverage with a minimum set of test cases as possible. If the techniques are not followed we end up writing invalid tests also test cases might appear as redundant ones.<\/p>\n

Given the two major classifications of testing, we have respective test case techniques designed as well<\/p>\n

White box testing techniques<\/strong><\/p>\n

As discussed above it\u2019s a test designed or executed on the structure or design of an application and proper understanding of the code and system is a must. <\/p>\n

Statement coverage<\/b><\/p>\n

Let\u2019s consider a developer is conducting a unit testing, the developer must have a thorough understanding of what that module or component should do? Also, the developer must aware of the code that has been written. Predominantly with the help of this technique, we try to get rid of any unreachable code that\u2019s available in the system. Ideally, the statement coverage is equal to the number of statements being written.<\/p>\n

Eg.<\/p>\n

\n
\n
    \n
  • <\/li>\n
  • <\/li>\n
  • <\/li>\n<\/ul>\n<\/div>\n
    \r\n\r\nMain(){\r\nIf(a>0&&b>0){\r\nIf(a>b){\r\nPrint is bigger;\r\nElse\r\nPrint b is bigger;\r\n}\r\nElse{\r\nPrint error message saying, negative values are not allowed;\r\n}\r\n}\r\n\r\n  <\/pre>\n<\/div>\n
    The statement coverage for the above program is 9, as there are 9 statements.<\/p>\n
    Decision coverage <\/b><\/p>\n
    The decision coverage mechanism of a white box testing technique ensures that we make proper conditional calls and don\u2019t miss any edge cases. The decision coverage is equal to the number of decisions we have in the system.<\/p>\n
    Eg:<\/p>\n
    \n
    \n
      \n
    • <\/li>\n
    • <\/li>\n
    • <\/li>\n<\/ul>\n<\/div>\n
      \r\n\r\nMain(){\r\nIf(a>0&&b>0){\r\nIf(a>b){\r\nPrint is bigger;\r\nElse\r\nPrint b is bigger;\r\n}\r\nElse{\r\nPrint error message saying, negative values are not allowed;\r\n}\r\n}\r\n\r\n  <\/pre>\n<\/div>\n
      In the above snippet we are making two decisions as to whether or not both the given numbers are non-negative integers then considering a decision as which number is bigger<\/p>\n
      So the decision coverage for the snippet is equaled to 2<\/p>\n
      Path coverage <\/b><\/p>\n
      Path coverage ensure that how many use cases and flows can be derived based on the given inputs. Also, we need to ensure that all possible paths are covered to ensure that the system is not open to breaking in any scenario. This can be understood by drawing some UML, flow chart diagrams.<\/p>\n
      Black box testing techniques<\/strong><\/p>\n
      As we already discussed above that black box is a manual validation and test cases are mainly focused to test the functional validation. These techniques will help us to do some permutations and combinations and identify the test cases based on the edge cases or doing some partitioning <\/p>\n
      Boundary value analysis<\/b><\/p>\n
      In this technique based on the condition, the boundary values such one immediate left and one immediate right boundary values are tested to ensure the state transition is happening properly on the conditional edge.<\/p>\n
      Eg lets consider that a person whose age is 18 or above only can vote and below age group, people can\u2019t cast their vote.<\/p>\n
      In order to test this condition we will understand the deciding factor age as \u201c18\u201d as it’s mentioned then identify one value just below 17 and one above 19  as boundary values to test that critical conditional logic.<\/p>\n
      Equivalence partitioning<\/b><\/p>\n
      This is another technique, which will help us to avoid the number of test cases but gives more coverage in this testing. In this technique based on the condition, we will partition the negative and positive slots and then pick one of those values to test. The lore is that, if the test case is behaving as expected for one value it is understood rest other values would be passed from the same slot.<\/p>\n
      Eg:  let\u2019s consider the same example as above that person with 18 or above can vote and rest can\u2019t<\/p>\n
      We will identify three partitions as <\/p>\n
      Age- 0<=17- negative slot<\/p>\n
      Age- 18= positive slot<\/p>\n
      Age- 19 to any greater value- positive slot<\/p>\n
      We will pick any one test data from each classification then with the help of 3 test cases all the scenarios can be covered.<\/p>\n
      Decision tables<\/b><\/p>\n
      When we have multiple combinations of inputs to test, if we choose to write test cases for all the values it becomes an overhead. Then forming a table with all the conditions and actions put in would help better to identify the cases.<\/p>\n
      Eg: let\u2019s consider a scenario of withdrawing money from the automated teller machine.<\/p>\n
      The machine will dispense money only when<\/p>\n
      Cond-1 user put incorrect passcode<\/p>\n
      Cond-2 withdrawal money should be lesser or equal to the savings balance.<\/p>\n
      Action \/ Goal:<\/b> Withdraw money from the teller machine. <\/p>\n
      The above requirement can be converted into a decision table as,<\/p>\n
      \"Decision<\/p>\n
      State transition testing<\/b><\/p>\n
      In this technique we need to understand the state flow of the use case then come up with a design flow diagram. This flow can help us derive how many flows and how many are positive and negative. In order to do this, we must have proper knowledge of the application.<\/p>\n
      Use case testing<\/b><\/p>\n
      Use case tests are designed to be more customer-specific test. The test case is written in the form of a user guide where the steps are written in a procedural format. This gives more insight on the test procedure as it talks about the actors, events n pre and post conditions in specific.<\/p>\n
      Eg: let\u2019s consider a login scenario into an application<\/p>\n
      Actor<\/b><\/p>\n
      Actor is the person who performs that events<\/p>\n
      Pre-condition<\/b><\/p>\n
      Actor should own a good network provision<\/p>\n
      Actor should be on the login page to be able to enter credentials<\/p>\n
      Events<\/b><\/p>\n
      Steps are addressed as events, the events involved in this step are<\/p>\n
      Enter the username and password<\/p>\n
      Click on the login button<\/p>\n
      Alternatives<\/b><\/p>\n
      This says what other actions can be possible when actor on that page.<\/p>\n
      The actor can look for help link or actor can try signing up if the account is not created yet.<\/p>\n
      Exceptions<\/b><\/p>\n
      These are the problems that user might encounter during the execution of events<\/p>\n
      Application might be throwing an error upon entering the credentials<\/p>\n
      After the clicking the login button, occurrence of any HTTP error <\/p>\n
      Post- actions<\/b><\/p>\n
      These are the subsequent actions executed after the completion of events.<\/p>\n
      Logging out from the application<\/p>\n
      Performing any business functionality with in the application<\/p>\n
      Conclusion<\/strong><\/p>\n
      We reckon it\u2019s a vague discussion, but every piece in this is important to be a competitive and distinguished tester. Adopting these fundamentals will help us test the applications with due diligence and with enhanced coverage. How much its the fact that the principles have to be understood, in the same fashion we must apply the sense to determine what technique to be used and when. I keep everything crossed for every reader to be a successful tester.<\/p>\n
      Thanks for reading!!! More we know more we grow.<\/p>\n","protected":false},"excerpt":{"rendered":"
      On this planet everything that is developed should be tested, officially or unofficially. In our rota, we tend to do a lot of testing but we don\u2019t realize because they are part and parcel of daily routines. In a similar profession, the information technology stream adopted the testing domain as one of their power to […]<\/p>\n","protected":false},"author":1,"featured_media":5345,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"","_et_pb_old_content":"","_et_gb_content_width":"","footnotes":""},"categories":[181,179,20],"tags":[],"acf":[],"yoast_head":"\nSoftware Testing Tutorial for Beginners - Codoid<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Software Testing Tutorial for Beginners\" \/>\n<meta property=\"og:description\" content=\"On this planet everything that is developed should be tested, officially or unofficially. In our rota, we tend to do a lot of testing but we don\u2019t realize because they are part and parcel of daily routines. In a similar profession, the information technology stream adopted the testing domain as one of their power to […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/codoid.com\/learn\/software-testing\/software-testing-tutorial-for-beginners\/\" \/>\n<meta property=\"og:site_name\" content=\"Codoid\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/codoid.softwaretestingcompany\" \/>\n<meta property=\"article:published_time\" content=\"2020-03-17T01:20:02+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2022-02-04T18:36:50+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/codoid.com\/wp-content\/uploads\/2020\/03\/Software_Testing_Tutorial_for_Beginners_Blog.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"800\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"admin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@codoid\" \/>\n<meta name=\"twitter:site\" content=\"@codoid\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"admin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"11 minutes\" \/>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Software Testing Tutorial for Beginners - Codoid","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"og_locale":"en_US","og_type":"article","og_title":"Software Testing Tutorial for Beginners","og_description":"On this planet everything that is developed should be tested, officially or unofficially. In our rota, we tend to do a lot of testing but we don\u2019t realize because they are part and parcel of daily routines. In a similar profession, the information technology stream adopted the testing domain as one of their power to […]","og_url":"https:\/\/codoid.com\/learn\/software-testing\/software-testing-tutorial-for-beginners\/","og_site_name":"Codoid","article_publisher":"https:\/\/www.facebook.com\/codoid.softwaretestingcompany","article_published_time":"2020-03-17T01:20:02+00:00","article_modified_time":"2022-02-04T18:36:50+00:00","og_image":[{"width":1200,"height":800,"url":"https:\/\/codoid.com\/wp-content\/uploads\/2020\/03\/Software_Testing_Tutorial_for_Beginners_Blog.jpg","type":"image\/jpeg"}],"author":"admin","twitter_card":"summary_large_image","twitter_creator":"@codoid","twitter_site":"@codoid","twitter_misc":{"Written by":"admin","Est. reading time":"11 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/codoid.com\/learn\/software-testing\/software-testing-tutorial-for-beginners\/#article","isPartOf":{"@id":"https:\/\/codoid.com\/learn\/software-testing\/software-testing-tutorial-for-beginners\/"},"author":{"name":"admin","@id":"https:\/\/codoid.com\/#\/schema\/person\/360ee1d38151acb7c746787fbfa8e586"},"headline":"Software Testing Tutorial for Beginners","datePublished":"2020-03-17T01:20:02+00:00","dateModified":"2022-02-04T18:36:50+00:00","mainEntityOfPage":{"@id":"https:\/\/codoid.com\/learn\/software-testing\/software-testing-tutorial-for-beginners\/"},"wordCount":2132,"commentCount":0,"publisher":{"@id":"https:\/\/codoid.com\/#organization"},"articleSection":["Software Testing","Fixed","Blog"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/codoid.com\/learn\/software-testing\/software-testing-tutorial-for-beginners\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/codoid.com\/learn\/software-testing\/software-testing-tutorial-for-beginners\/","url":"https:\/\/codoid.com\/learn\/software-testing\/software-testing-tutorial-for-beginners\/","name":"Software Testing Tutorial for Beginners - Codoid","isPartOf":{"@id":"https:\/\/codoid.com\/#website"},"datePublished":"2020-03-17T01:20:02+00:00","dateModified":"2022-02-04T18:36:50+00:00","breadcrumb":{"@id":"https:\/\/codoid.com\/learn\/software-testing\/software-testing-tutorial-for-beginners\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/codoid.com\/learn\/software-testing\/software-testing-tutorial-for-beginners\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/codoid.com\/learn\/software-testing\/software-testing-tutorial-for-beginners\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/codoid.com\/"},{"@type":"ListItem","position":2,"name":"Software Testing Tutorial for Beginners"}]},{"@type":"WebSite","@id":"https:\/\/codoid.com\/#website","url":"https:\/\/codoid.com\/","name":"Codoid","description":"","publisher":{"@id":"https:\/\/codoid.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/codoid.com\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/codoid.com\/#organization","name":"Codoid - Software Testing Company","url":"https:\/\/codoid.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/codoid.com\/#\/schema\/logo\/image\/","url":"https:\/\/codoid.com\/wp-content\/uploads\/2020\/09\/Codoid_Software_Testing_Company_Logo.png","contentUrl":"https:\/\/codoid.com\/wp-content\/uploads\/2020\/09\/Codoid_Software_Testing_Company_Logo.png","width":500,"height":500,"caption":"Codoid - Software Testing Company"},"image":{"@id":"https:\/\/codoid.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/codoid.softwaretestingcompany","https:\/\/twitter.com\/codoid","https:\/\/www.instagram.com\/codoid.softwaretestingcompany\/","https:\/\/www.linkedin.com\/company\/codoid-qacompany","https:\/\/www.pinterest.com\/codoid9282\/codoid-software-testing-company\/","https:\/\/www.youtube.com\/channel\/UCCmOTDQgcf4W8oo22mBMUYA"]},{"@type":"Person","@id":"https:\/\/codoid.com\/#\/schema\/person\/360ee1d38151acb7c746787fbfa8e586","name":"admin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/codoid.com\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/4d33f9036c9d60684b9478f738779823?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/4d33f9036c9d60684b9478f738779823?s=96&d=mm&r=g","caption":"admin"},"sameAs":["https:\/\/codoid.com"]}]}},"_links":{"self":[{"href":"https:\/\/codoid.com\/wp-json\/wp\/v2\/posts\/2789"}],"collection":[{"href":"https:\/\/codoid.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/codoid.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/codoid.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/codoid.com\/wp-json\/wp\/v2\/comments?post=2789"}],"version-history":[{"count":1,"href":"https:\/\/codoid.com\/wp-json\/wp\/v2\/posts\/2789\/revisions"}],"predecessor-version":[{"id":5344,"href":"https:\/\/codoid.com\/wp-json\/wp\/v2\/posts\/2789\/revisions\/5344"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/codoid.com\/wp-json\/wp\/v2\/media\/5345"}],"wp:attachment":[{"href":"https:\/\/codoid.com\/wp-json\/wp\/v2\/media?parent=2789"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/codoid.com\/wp-json\/wp\/v2\/categories?post=2789"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/codoid.com\/wp-json\/wp\/v2\/tags?post=2789"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}