Implement an HTTP POST Request in Go

This challenge focuses on the fundamental task of sending data to a remote server using an HTTP POST request in Go. You will learn how to construct a POST request, serialize data into a suitable format, and handle the server's response. This is a crucial skill for interacting with most web APIs and services.

Problem Description

Your goal is to write a Go program that sends a POST request to a specified URL with specific data. The data should be JSON-encoded. You need to handle potential errors during the request and parse the JSON response from the server.

Key Requirements:

1. Construct POST Request: Create an HTTP POST request to a given URL.
2. JSON Payload: The body of the POST request must contain a JSON object representing the data to be sent.
3. Send Request: Execute the POST request and obtain the server's response.
4. Error Handling: Gracefully handle network errors, invalid URLs, and issues during request execution.
5. Parse Response: If the request is successful (HTTP status code 200 OK), parse the JSON response from the server.
6. Output: Print the parsed JSON response to the console. If an error occurs, print an informative error message.

Expected Behavior:

The program should:

• Attempt to POST data to the specified URL.
• If successful, decode the JSON response and print it.
• If an error occurs at any stage, print a descriptive error message.

Edge Cases to Consider:

• Invalid URL: The provided URL might be malformed or inaccessible.
• Network Issues: The server might be down or unreachable.
• Non-JSON Response: The server might return a response that is not valid JSON.
• Non-200 Status Code: The server might return an HTTP status code other than 200 OK.

Examples

Example 1:

Scenario: Sending a simple user profile to a mock API.

Input Data:
{
  "name": "Alice",
  "age": 30,
  "city": "New York"
}

Target URL: "https://httpbin.org/post" (a useful service for testing HTTP requests)

Output:
{
  "args": {},
  "data": "{\"age\":30,\"city\":\"New York\",\"name\":\"Alice\"}",
  "files": {},
  "form": {},
  "headers": {
    "Accept-Encoding": "gzip",
    "Content-Length": "42",
    "Content-Type": "application/json",
    "Host": "httpbin.org",
    "User-Agent": "Go-http-client/1.1"
  },
  "json": {
    "age": 30,
    "city": "New York",
    "name": "Alice"
  },
  "origin": "your.client.ip.address",
  "url": "https://httpbin.org/post"
}

Explanation: The Go program sends a JSON object containing "name", "age", and "city" to https://httpbin.org/post. The httpbin.org service echoes back the received data in its response, including the json field which shows the parsed JSON body.

Example 2:

Scenario: Sending an empty JSON object.

Input Data:
{}

Target URL: "https://httpbin.org/post"

Output:
{
  "args": {},
  "data": "{}",
  "files": {},
  "form": {},
  "headers": {
    "Accept-Encoding": "gzip",
    "Content-Length": "2",
    "Content-Type": "application/json",
    "Host": "httpbin.org",
    "User-Agent": "Go-http-client/1.1"
  },
  "json": {},
  "origin": "your.client.ip.address",
  "url": "https://httpbin.org/post"
}

Explanation: Similar to Example 1, but an empty JSON object is sent. The httpbin.org service correctly reflects this in its response.

Example 3: (Error Scenario)

Scenario: Attempting to POST to a non-existent URL.

Input Data:
{
  "message": "test"
}

Target URL: "http://localhost:9999/nonexistent" (assuming no server is running on this port)

Output:
Error: Post "http://localhost:9999/nonexistent": dial tcp 127.0.0.1:9999: connectex: No connection could be made because the target machine actively refused it.

Explanation: The program fails to connect to the specified URL, and an appropriate error message detailing the network issue is printed.

Constraints

• The input data to be sent will always be a valid Go map[string]interface{} which can be marshaled into JSON.
• The target URL will be a valid string.
• The program should handle responses up to 1MB in size.
• The program should complete within 5 seconds for typical network conditions.

Notes

• You will likely need to use the net/http package for making HTTP requests.
• The encoding/json package will be essential for marshaling your Go data structure into JSON and unmarshaling the JSON response.
• Consider using defer for closing response bodies to prevent resource leaks.
• The httpbin.org service is a great resource for testing HTTP requests as it echoes back the request details. You can use it as your target URL for examples and testing.
• Pay close attention to the Content-Type header; it should be set to application/json when sending JSON data.