leave http resolver alone for now.

Author: brianwcook

pkg/remoteresolution/resolver/http/resolver.go

@@ -18,7 +18,6 @@ import (
 	"errors"
 
 	"github.com/tektoncd/pipeline/pkg/apis/resolution/v1beta1"
-	"github.com/tektoncd/pipeline/pkg/remoteresolution/cache"
 	"github.com/tektoncd/pipeline/pkg/remoteresolution/resolver/framework"
 	"github.com/tektoncd/pipeline/pkg/resolution/common"
 	resolutionframework "github.com/tektoncd/pipeline/pkg/resolution/resolver/framework"
@@ -102,39 +101,7 @@ func (r *Resolver) Resolve(ctx context.Context, req *v1beta1.ResolutionRequestSp
 			return nil, err
 		}
 
-		// Check if caching is enabled
-		useCache := params[http.CacheParam] == "true"
-
-		if useCache {
-			// Initialize cache logger
-			cache.GetGlobalCache().InitializeLogger(ctx)
-
-			// Generate cache key
-			cacheKey, err := cache.GenerateCacheKey(LabelValueHttpResolverType, oParams)
-			if err != nil {
-				return nil, err
-			}
-
-			// Check cache first
-			if cached, ok := cache.GetGlobalCache().Get(cacheKey); ok {
-				if resource, ok := cached.(resolutionframework.ResolvedResource); ok {
-					return resource, nil
-				}
-			}
-		}
-
-		resource, err := http.FetchHttpResource(ctx, params, r.kubeClient, r.logger)
-		if err != nil {
-			return nil, err
-		}
-
-		// Cache the result if caching is enabled
-		if useCache {
-			cacheKey, _ := cache.GenerateCacheKey(LabelValueHttpResolverType, oParams)
-			cache.GetGlobalCache().Add(cacheKey, resource)
-		}
-
-		return resource, nil
+		return http.FetchHttpResource(ctx, params, r.kubeClient, r.logger)
 	}
 	// Remove this error once resolution of url has been implemented.
 	return nil, errors.New("the Resolve method has not been implemented.")

pkg/remoteresolution/resolver/http/resolver_test.go

@@ -17,7 +17,6 @@ limitations under the License.
 package http
 
 import (
-	"bytes"
 	"context"
 	"crypto/sha256"
 	"encoding/base64"
@@ -26,6 +25,7 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"regexp"
 	"testing"
 	"time"
 
@@ -105,22 +105,15 @@ func TestValidate(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			resolver := Resolver{}
-			params := []pipelinev1.Param{}
+			params := map[string]string{}
 			if tc.url != "nourl" {
-				params = append(params, pipelinev1.Param{
-					Name:  "url",
-					Value: *pipelinev1.NewStructuredValues(tc.url),
-				})
+				params[httpresolution.UrlParam] = tc.url
 			} else {
 				// inject a fake param so that it can validate that the url is actually missing.
-				params = append(params, pipelinev1.Param{
-					Name:  "foo",
-					Value: *pipelinev1.NewStructuredValues("bar"),
-				})
+				params["foo"] = "bar"
 			}
-
 			req := v1beta1.ResolutionRequestSpec{
-				Params: params,
+				Params: toParams(params),
 			}
 			err := resolver.Validate(contextWithConfig(defaultHttpTimeoutValue), &req)
 			if tc.expectedErr != nil {
@@ -133,115 +126,79 @@ func TestValidate(t *testing.T) {
 }
 
 func TestResolve(t *testing.T) {
-	testCases := []struct {
+	tests := []struct {
 		name           string
-		expectedError  error
+		expectedErr    string
 		input          string
-		paramsSet      bool
-		useCache       bool
+		paramSet       bool
 		expectedStatus int
 	}{
 		{
-			name:           "valid params set with cache",
-			expectedError:  nil,
-			input:          "https://example.com/script.yaml",
-			paramsSet:      true,
-			useCache:       true,
-			expectedStatus: http.StatusOK,
-		},
-		{
-			name:           "valid params set without cache",
-			expectedError:  nil,
-			input:          "https://example.com/script.yaml",
-			paramsSet:      true,
-			useCache:       false,
-			expectedStatus: http.StatusOK,
-		},
-		{
-			name:           "missing required params",
-			expectedError:  fmt.Errorf("missing required param: url"),
-			input:          "",
-			paramsSet:      false,
-			useCache:       false,
-			expectedStatus: http.StatusBadRequest,
-		},
-		{
-			name:           "not found error",
-			expectedError:  fmt.Errorf("error accessing resource from \"https://example.com/not-found.yaml\": 404 Not Found"),
-			input:          "https://example.com/not-found.yaml",
-			paramsSet:      true,
-			useCache:       false,
+			name:     "good/params set",
+			input:    "task",
+			paramSet: true,
+		}, {
+			name:        "bad/params not set",
+			input:       "task",
+			expectedErr: `missing required http resolver params: url`,
+		}, {
+			name:           "bad/not found",
+			input:          "task",
+			paramSet:       true,
 			expectedStatus: http.StatusNotFound,
+			expectedErr:    `requested URL 'http://([^']*)' is not found`,
 		},
 	}
-
-	for _, tc := range testCases {
+	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				w.WriteHeader(tc.expectedStatus)
-				if tc.expectedStatus == http.StatusOK {
-					w.Write([]byte("test content"))
+			svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if tc.expectedStatus != 0 {
+					w.WriteHeader(tc.expectedStatus)
 				}
+				fmt.Fprint(w, tc.input)
 			}))
-			defer server.Close()
-
-			resolver := &Resolver{}
 			params := []pipelinev1.Param{}
-			if tc.paramsSet {
+			if tc.paramSet {
 				params = append(params, pipelinev1.Param{
-					Name:  "url",
-					Value: *pipelinev1.NewStructuredValues(tc.input),
+					Name:  httpresolution.UrlParam,
+					Value: *pipelinev1.NewStructuredValues(svr.URL),
+				})
+			} else {
+				params = append(params, pipelinev1.Param{
+					Name:  "foo",
+					Value: *pipelinev1.NewStructuredValues("bar"),
 				})
-				if tc.useCache {
-					params = append(params, pipelinev1.Param{
-						Name:  "cache",
-						Value: *pipelinev1.NewStructuredValues("true"),
-					})
-				}
 			}
-
+			resolver := Resolver{}
 			req := v1beta1.ResolutionRequestSpec{
 				Params: params,
 			}
-
-			ctx := contextWithConfig(defaultHttpTimeoutValue)
-			resolved, err := resolver.Resolve(ctx, &req)
-
-			if tc.expectedError != nil {
-				if err == nil {
-					t.Errorf("expected error %v but got nil", tc.expectedError)
-				} else if err.Error() != tc.expectedError.Error() {
-					t.Errorf("expected error %v but got %v", tc.expectedError, err)
+			output, err := resolver.Resolve(contextWithConfig(defaultHttpTimeoutValue), &req)
+			if tc.expectedErr != "" {
+				re := regexp.MustCompile(tc.expectedErr)
+				if !re.MatchString(err.Error()) {
+					t.Fatalf("expected error '%v' but got '%v'", tc.expectedErr, err)
 				}
 				return
+			} else if err != nil {
+				t.Fatalf("unexpected error validating params: %v", err)
 			}
-
-			if err != nil {
-				t.Errorf("unexpected error: %v", err)
-				return
+			if o := cmp.Diff(tc.input, string(output.Data())); o != "" {
+				t.Fatalf("expected output '%v' but got '%v'", tc.input, string(output.Data()))
+			}
+			if o := cmp.Diff(svr.URL, output.RefSource().URI); o != "" {
+				t.Fatalf("expected url '%v' but got '%v'", svr.URL, output.RefSource().URI)
 			}
 
-			if resolved == nil {
-				t.Error("expected resolved resource but got nil")
-				return
+			eSum := sha256.New()
+			eSum.Write([]byte(tc.input))
+			eSha256 := hex.EncodeToString(eSum.Sum(nil))
+			if o := cmp.Diff(eSha256, output.RefSource().Digest["sha256"]); o != "" {
+				t.Fatalf("expected sha256 '%v' but got '%v'", eSha256, output.RefSource().Digest["sha256"])
 			}
 
-			// Test cache functionality
-			if tc.useCache {
-				// Try resolving again with the same parameters
-				cached, err := resolver.Resolve(ctx, &req)
-				if err != nil {
-					t.Errorf("unexpected error when resolving cached resource: %v", err)
-					return
-				}
-				if cached == nil {
-					t.Error("expected cached resource but got nil")
-					return
-				}
-				// Verify that the cached resource matches the original
-				if !bytes.Equal(resolved.Data(), cached.Data()) {
-					t.Error("cached resource does not match original resource")
-				}
+			if output.Annotations() != nil {
+				t.Fatalf("output annotations should be nil")
 			}
 		})
 	}