Merge pull request #2 from TimothyStiles/req-resp-refactor

Req resp refactor

Author: TimothyStiles

.ditto/2706164f318da155

@@ -36,13 +36,11 @@ type CachedResponse struct {
 func (c *CachingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
 
 	// So I originally tried implementing this to be a lot cleaner with a majority of the logic in retrieve and cache functions. However,
-	// I'm not sure what was going on but there was some sort of data race where the cache file was being written to correctly but if the
+	// I'm not sure what was going on but there was some sort of data race where the cache file was being written to correctly but if
 	// RoundTrip called cache then the GitHub example test would panic and not receive the data from the same response the cache file was
 	// being written from in the same call to this function (RoundTrip).
 
-	endpoint := req.URL.String()
-
-	data, err := retrieve(endpoint)
+	data, err := retrieve(req)
 	if err == nil {
 
 		var cachedResp CachedResponse
@@ -83,7 +81,7 @@ func (c *CachingTransport) RoundTrip(req *http.Request) (*http.Response, error)
 		return nil, err
 	}
 
-	err = cache(endpoint, marshalledResponse)
+	err = cache(req, marshalledResponse)
 	if err != nil {
 		return nil, err
 	}
@@ -92,23 +90,26 @@ func (c *CachingTransport) RoundTrip(req *http.Request) (*http.Response, error)
 	return resp, nil
 }
 
-func getCacheFilePath(endpoint string) string {
+func getCacheFilePath(req *http.Request) string {
 	hash := fnv.New64a()
-	hash.Write([]byte(endpoint))
+	url := req.URL.String()
+	method := req.Method
+	endpointPlusMethod := fmt.Sprintf("%s:%s", method, url)
+	hash.Write([]byte(endpointPlusMethod))
 	hashedEndpoint := fmt.Sprintf("%x", hash.Sum(nil))
 	return filepath.Join(".ditto", hashedEndpoint)
 }
 
-func retrieve(endpoint string) ([]byte, error) {
-	cacheFilePath := getCacheFilePath(endpoint)
+func retrieve(req *http.Request) ([]byte, error) {
+	cacheFilePath := getCacheFilePath(req)
 	if _, err := os.Stat(cacheFilePath); os.IsNotExist(err) {
 		return nil, err
 	}
 	return os.ReadFile(cacheFilePath)
 }
 
-func cache(endpoint string, data []byte) error {
-	cacheFilePath := getCacheFilePath(endpoint)
+func cache(req *http.Request, data []byte) error {
+	cacheFilePath := getCacheFilePath(req)
 	os.MkdirAll(filepath.Dir(cacheFilePath), os.ModePerm)
 	return os.WriteFile(cacheFilePath, data, 0644)
 }

.ditto/e5daf97c0fa2c6f7

@@ -1,128 +1,53 @@
 package ditto
 
 import (
-	"bytes"
-	"context"
-	"fmt"
-	"io"
+	"net"
 	"net/http"
+	"net/http/httptest"
 	"os"
-	"path/filepath"
 	"testing"
-
-	"github.com/google/go-github/v57/github"
 )
 
-func TestMain(m *testing.M) {
-	os.Exit(m.Run())
-}
-
-func TestGetCacheFilePath(t *testing.T) {
-	endpoint := "https://example.com/api"
-	expected := filepath.Join(".ditto", "362656336a5f086c")
-	result := getCacheFilePath(endpoint)
-	if result != expected {
-		t.Errorf("Expected` %s, but got %s", expected, result)
-	}
-}
-func TestCache(t *testing.T) {
-	endpoint := "https://example.com/api"
-	data := []byte("test data")
-	expectedFilePath := getCacheFilePath(endpoint)
-
-	err := cache(endpoint, data)
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	// Check if the cache file exists
-	_, err = os.Stat(expectedFilePath)
-	if err != nil {
-		t.Errorf("Cache file does not exist: %v", err)
-	}
-
-	// Clean up the cache file
-	err = os.Remove(expectedFilePath)
-	if err != nil {
-		t.Errorf("Failed to remove cache file: %v", err)
-	}
-}
-func TestRetrieve(t *testing.T) {
-	endpoint := "https://example.com/api"
-	expectedData := []byte("test data")
-	expectedFilePath := getCacheFilePath(endpoint)
-
-	// Create a cache file with test data
-	err := os.WriteFile(expectedFilePath, expectedData, 0644)
-	if err != nil {
-		t.Fatalf("Failed to create cache file: %v", err)
-	}
-	defer os.Remove(expectedFilePath)
-
-	// Test loading cache
-	result, err := retrieve(endpoint)
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
+func TestCachingTransport_RoundTrip(t *testing.T) {
+	// Create a test server
+	server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("Hello, World!"))
+	}))
 
-	// Compare loaded data with expected data
-	if !bytes.Equal(result, expectedData) {
-		t.Errorf("Expected data: %s, but got: %s", expectedData, result)
-	}
-}
-func TestCachingTransport_RoundTrip_CachedResponse(t *testing.T) {
-	// Define the test URL and expected response
-	url := "https://example.com/api"
+	// Set the server to listen on a specific address
+	server.Listener, _ = net.Listen("tcp", "localhost:56560")
 
-	// Remove any existing cache for the test URL
-	cacheFilePath := getCacheFilePath(url)
-	_ = os.Remove(cacheFilePath)
+	server.Start()
+	defer server.Close()
 
-	// Create a new caching HTTP client
-	client := &CachingTransport{
+	// Create a new CachingTransport
+	cachingTransport := &CachingTransport{
 		Transport: http.DefaultTransport,
 	}
 
-	// Create a new HTTP request
-	req, err := http.NewRequest("GET", url, nil)
+	// Create a new request
+	req, err := http.NewRequest(http.MethodGet, server.URL, nil)
 	if err != nil {
-		t.Fatalf("Failed to create HTTP request: %v", err)
+		t.Fatalf("Failed to create request: %v", err)
 	}
 
-	// Make the HTTP request using the caching HTTP client
-	resp, err := client.RoundTrip(req)
-	if err != nil {
-		t.Fatalf("Failed to make HTTP request: %v", err)
-	}
-	defer resp.Body.Close()
+	// remove the cache file if it exists and defer removing it again until the end of the test
+	cacheFilePath := getCacheFilePath(req)
+	os.Remove(cacheFilePath)
+	defer os.Remove(cacheFilePath)
 
-	// Read the response body
-	_, err = io.ReadAll(resp.Body)
+	// Call the RoundTrip method
+	resp, err := cachingTransport.RoundTrip(req)
 	if err != nil {
-		t.Fatalf("Failed to read response body: %v", err)
+		t.Fatalf("RoundTrip failed: %v", err)
 	}
+	defer resp.Body.Close()
 
-	// clean up the cache file again just for good measure
-	_ = os.Remove(cacheFilePath)
-
-}
-
-func TestGitHubExampleRegression(t *testing.T) {
-	os.Remove("ditto/028587485a8f03d6")
-	defer os.Remove(".ditto/028587485a8f03d6")
-	token := os.Getenv("GITHUB_TOKEN")
-
-	// instead of http.DefaultClient we use ditto.Client()
-	client := github.NewClient(Client()).WithAuthToken(token) // auth token is optional
-
-	// Use client...
-	repos, _, err := client.Repositories.List(context.Background(), "TimothyStiles", nil)
-	if err != nil {
-		fmt.Println("Error:", err)
-		return
+	// Check the response
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected status code %d, got %d", http.StatusOK, resp.StatusCode)
 	}
 
-	if repos[0].GetName() != "action-discord" {
-		t.Errorf("Expected %s, but got %s", "action-discord", repos[0].GetName())
-	}
+	// TODO: Add more assertions as needed
 }