deafult to anonymous auth when no credentials

Author: lkingland

e2e/e2e_test.go

@@ -128,11 +128,11 @@ var (
 	// MatrixRuntimes for which runtime-specific tests should be run.  Defaults
 	// to all core language runtimes.  Can be set with FUNC_E2E_MATRIX_RUNTIMES
 	// MatrixRuntimes = []string{"go", "python", "node", "typescript", "rust", "quarkus", "springboot"}
-	MatrixRuntimes = []string{"go", "python", "node", "typescript", "rust", "quarkus", "springboot"}
+	MatrixRuntimes = []string{"quarkus", "springboot"}
 
 	// MatrixTemplates specifies the templates to check during matrix tests.
 	// MatrixTemplates = []string{"http", "cloudevents"}
-	MatrixTemplates = []string{"cloudevents"}
+	MatrixTemplates = []string{"http", "cloudevents"}
 
 	// Plugin indicates func is being run as a plugin within Bin, and
 	// the value of this argument is the subcommand.  For example, when

generate/zz_filesystem_generated.go

@@ -19,13 +19,13 @@ init() {
 }
 
 find_executables() {
-  KUBECTL=$(find_executable "kubectl")
-  KIND=$(find_executable "kind")
-  DAPR=$(find_executable "dapr")
-  HELM=$(find_executable "helm")
-  STERN=$(find_executable "stern")
-  KN=$(find_executable "kn")
-  JQ=$(find_executable "jq")
+  KUBECTL=$(find_executable "kubectl" || true)
+  KIND=$(find_executable "kind" || true)
+  DAPR=$(find_executable "dapr" || true)
+  HELM=$(find_executable "helm" || true)
+  STERN=$(find_executable "stern" || true)
+  KN=$(find_executable "kn" || true)
+  JQ=$(find_executable "jq" || true)
 }
 
 populate_environment() {

hack/common.sh

@@ -25,10 +25,14 @@ source "$(dirname "$(realpath "$0")")/common.sh"
 output_file="${1:-cluster_log.txt}"
 
 echo "::group::cluster events" >> "$output_file"
-kubectl get events -A >> "$output_file" 2>&1
+"$KUBECTL" get events -A >> "$output_file" 2>&1
 echo "::endgroup::" >> "$output_file"
 
 echo "::group::cluster containers logs" >> "$output_file"
-stern '.*' --all-namespaces --no-follow >> "$output_file" 2>&1
+if [[ -n "${STERN:-}" && -x "${STERN}" ]]; then
+  "$STERN" '.*' --all-namespaces --no-follow >> "$output_file" 2>&1
+else
+  echo "stern not available, skipping container logs" >> "$output_file" 2>&1
+fi
 echo "::endgroup::" >> "$output_file"
 

hack/dump-logs.sh

@@ -178,7 +178,7 @@ echo "mode: atomic" > coverage.txt
 echo ""
 echo "Running E2E tests..."
 cd "${PROJECT_ROOT}/e2e"
-go test -tags e2e -timeout 120m -coverprofile=coverage-e2e.txt -coverpkg=../... -v -run TestMatrix_Deploy
+go test -tags e2e -timeout 120m -coverprofile=coverage-e2e.txt -coverpkg=../... -v -run TestMatrix_Run
 # go test -tags e2e -timeout 120m -coverprofile=coverage-e2e.txt -coverpkg=../... -v
 tail -n +2 coverage-e2e.txt >> ../coverage.txt
 rm -f coverage-e2e.txt

hack/test-full.sh

@@ -172,9 +172,6 @@ func (p *Pusher) writeIndex(ctx context.Context, ref name.Reference, ii v1.Image
 		if err != nil {
 			return err
 		}
-		if a == nil {
-			return errors.New("no authentication option provided")
-		}
 		oo = append(oo, a)
 	}
 
@@ -210,5 +207,6 @@ func (p *Pusher) authOption(ctx context.Context, creds Credentials) (remote.Opti
 		return remote.WithAuth(&authn.Basic{Username: creds.Username, Password: creds.Password}), nil
 	}
 
-	return nil, nil
+	// Return anonymous auth when no credentials are provided (e.g., for localhost registries)
+	return remote.WithAuth(authn.Anonymous), nil
 }

pkg/oci/pusher.go

@@ -11,17 +11,35 @@ pub async fn handle(
 ) -> Result<Event, actix_web::Error> {
     info!("event: {}", event);
 
-    let input = match event.data() {
-        Some(Data::Binary(v)) => from_slice(v)?,
-        Some(Data::String(v)) => from_str(v)?,
-        Some(Data::Json(v)) => v.to_owned(),
-        None => json!({ "name": config.name }),
+    // Extract message from event data, or use default
+    let message = match event.data() {
+        Some(Data::Binary(v)) => {
+            let input: serde_json::Value = from_slice(v)?;
+            input.get("message")
+                .and_then(|v| v.as_str())
+                .unwrap_or(&config.name)
+                .to_string()
+        },
+        Some(Data::String(v)) => {
+            let input: serde_json::Value = from_str(v)?;
+            input.get("message")
+                .and_then(|v| v.as_str())
+                .unwrap_or(&config.name)
+                .to_string()
+        },
+        Some(Data::Json(v)) => {
+            v.get("message")
+                .and_then(|v| v.as_str())
+                .unwrap_or(&config.name)
+                .to_string()
+        },
+        None => config.name.clone(),
     };
 
     EventBuilderV10::from(event)
         .source("func://handler")
-        .ty("func.example")
-        .data("application/json", json!({ "hello": input["name"] }))
+        .ty("func.echo")
+        .data("application/json", json!({ "message": message }))
         .build()
         .map_err(ErrorInternalServerError)
 }
@@ -37,11 +55,11 @@ mod tests {
     #[actix_rt::test]
     async fn valid_input() {
         let mut input = Event::default();
-        input.set_data("application/json", json!({"name": "bootsy"}));
+        input.set_data("application/json", json!({"message": "test-echo"}));
         let resp = handle(input, config()).await;
         assert!(resp.is_ok());
         match resp.unwrap().data() {
-            Some(Data::Json(output)) => assert_eq!("bootsy", output["hello"]),
+            Some(Data::Json(output)) => assert_eq!("test-echo", output["message"]),
             _ => panic!(),
         }
     }
@@ -51,7 +69,7 @@ mod tests {
         let resp = handle(Event::default(), config()).await;
         assert!(resp.is_ok());
         match resp.unwrap().data() {
-            Some(Data::Json(output)) => assert_eq!("world", output["hello"]),
+            Some(Data::Json(output)) => assert_eq!("world", output["message"]),
             _ => panic!(),
         }
     }

templates/rust/cloudevents/src/handler.rs

@@ -6,7 +6,13 @@ use log::info;
 pub async fn index(req: HttpRequest, config: Data<HandlerConfig>) -> HttpResponse {
     info!("{:#?}", req);
     if req.method() == Method::GET {
-        HttpResponse::Ok().body(format!("Hello {}!\n", config.name))
+        // Echo back the query string if present, otherwise return greeting
+        let query = req.query_string();
+        if !query.is_empty() {
+            HttpResponse::Ok().body(query.to_string())
+        } else {
+            HttpResponse::Ok().body(format!("Hello {}!\n", config.name))
+        }
     } else {
         HttpResponse::Ok().body(format!("Thanks {}!\n", config.name))
     }
@@ -32,6 +38,19 @@ mod tests {
         );
     }
 
+    #[actix_rt::test]
+    async fn get_with_query() {
+        let req = TestRequest::get()
+            .uri("/?test=param&message=hello")
+            .to_http_request();
+        let resp = index(req, config()).await;
+        assert_eq!(resp.status(), http::StatusCode::OK);
+        assert_eq!(
+            &Bytes::from("test=param&message=hello"),
+            to_bytes(resp.into_body()).await.unwrap().as_ref()
+        );
+    }
+
     #[actix_rt::test]
     async fn post() {
         let req = TestRequest::post().to_http_request();

templates/rust/http/src/handler.rs

@@ -50,8 +50,8 @@ ${JSON.stringify(body)}
       }
     };
   } else {
-    return { 
-      statusCode: 405, 
+    return {
+      statusCode: 405,
       body: { error: 'Method not allowed' },
       headers: {
         'content-type': 'application/json'

templates/typescript/http/src/index.ts

@@ -14,7 +14,7 @@ test('Unit: handles a valid request', async (t) => {
   };
 
   // Invoke the function which should complete without error and echo the data
-  const result = await handle({ log: { info: (_) => _ } } as Context, body);
+  const result = await handle({ method: 'POST', log: { info: (_) => _ } } as Context, body);
   t.ok(result);
   t.equal(result.body, body);
   t.end();