diff --git a/tests/testthat/test-glmnet-linear.R b/tests/testthat/test-glmnet-linear.R
index 1eb64868..525e9db8 100644
--- a/tests/testthat/test-glmnet-linear.R
+++ b/tests/testthat/test-glmnet-linear.R
@@ -112,7 +112,7 @@ test_that('glmnet prediction, multiple lambda', {
 
   lams <- c(.01, 0.1)
 
-  hpc_mult <- linear_reg(penalty = lams, mixture = .3) %>%
+  hpc_mult <- linear_reg(penalty = 0.1, mixture = .3) %>%
     set_engine("glmnet")
 
   res_xy <- fit_xy(
@@ -150,7 +150,7 @@ test_that('glmnet prediction, multiple lambda', {
 
   expect_equal(
     as.data.frame(mult_pred),
-    multi_predict(res_xy, new_data = hpc[1:5, num_pred], lambda = lams) %>%
+    multi_predict(res_xy, new_data = hpc[1:5, num_pred], penalty = lams) %>%
       unnest(cols = c(.pred)) %>%
       as.data.frame(),
     tolerance = 0.0001
@@ -195,61 +195,13 @@ test_that('glmnet prediction, multiple lambda', {
 
   expect_equal(
     as.data.frame(form_pred),
-    multi_predict(res_form, new_data = hpc[1:5, ], lambda = lams) %>%
+    multi_predict(res_form, new_data = hpc[1:5, ], penalty = lams) %>%
       unnest(cols = c(.pred)) %>%
       as.data.frame(),
     tolerance = 0.0001
   )
 })
 
-test_that('glmnet prediction, all lambda', {
-
-  skip_if_not_installed("glmnet")
-  skip_if(run_glmnet)
-
-  hpc_all <- linear_reg(mixture = .3) %>%
-    set_engine("glmnet", nlambda = 7)
-
-  res_xy <- fit_xy(
-    hpc_all,
-    control = ctrl,
-    x = hpc[, num_pred],
-    y = hpc$input_fields
-  )
-
-  all_pred <- predict(res_xy$fit, newx = as.matrix(hpc[1:5, num_pred]))
-  all_pred <- stack(as.data.frame(all_pred))
-  all_pred$penalty <- rep(res_xy$fit$lambda, each = 5)
-  all_pred$rows <- rep(1:5, length(res_xy$fit$lambda))
-  all_pred <- all_pred[order(all_pred$rows, all_pred$penalty), ]
-  all_pred <- all_pred[, c("penalty", "values")]
-  names(all_pred) <- c("penalty", ".pred")
-  all_pred <- tibble::as_tibble(all_pred)
-
-  expect_equal(all_pred, multi_predict(res_xy, new_data = hpc[1:5,num_pred ]) %>% unnest(cols = c(.pred)))
-
-  res_form <- fit(
-    hpc_all,
-    input_fields ~ log(compounds) + class,
-    data = hpc,
-    control = ctrl
-  )
-
-  form_mat <- model.matrix(input_fields ~ log(compounds) + class, data = hpc)
-  form_mat <- form_mat[1:5, -1]
-
-  form_pred <- predict(res_form$fit, newx = form_mat)
-  form_pred <- stack(as.data.frame(form_pred))
-  form_pred$penalty <- rep(res_form$fit$lambda, each = 5)
-  form_pred$rows <- rep(1:5, length(res_form$fit$lambda))
-  form_pred <- form_pred[order(form_pred$rows, form_pred$penalty), ]
-  form_pred <- form_pred[, c("penalty", "values")]
-  names(form_pred) <- c("penalty", ".pred")
-  form_pred <- tibble::as_tibble(form_pred)
-
-  expect_equal(form_pred, multi_predict(res_form, hpc[1:5, c("compounds", "class")]) %>% unnest(cols = c(.pred)))
-})
-
 
 test_that('submodel prediction', {
 
@@ -257,7 +209,7 @@ test_that('submodel prediction', {
   skip_if(run_glmnet)
 
   reg_fit <-
-    linear_reg() %>%
+    linear_reg(penalty = 0.1) %>%
     set_engine("glmnet") %>%
     fit(mpg ~ ., data = mtcars[-(1:4), ])
 
@@ -273,20 +225,20 @@ test_that('submodel prediction', {
   )
 
   reg_fit <-
-    linear_reg() %>%
+    linear_reg(penalty = 0.01) %>%
     set_engine("glmnet") %>%
     fit(mpg ~ ., data = mtcars[-(1:4), ])
 
 
   pred_glmn_all <-
-    predict(reg_fit$fit, as.matrix(mtcars[1:2, -1])) %>%
+    predict(reg_fit$fit, as.matrix(mtcars[1:2, -1]), penalty = reg_fit$fit$lambda) %>%
     as.data.frame() %>%
     stack() %>%
     dplyr::arrange(ind)
 
 
   mp_res_all <-
-    multi_predict(reg_fit, new_data = mtcars[1:2, -1]) %>%
+    multi_predict(reg_fit, new_data = mtcars[1:2, -1], penalty = reg_fit$fit$lambda) %>%
     tidyr::unnest(cols = c(.pred))
 
   expect_equal(sort(mp_res_all$.pred), sort(pred_glmn_all$values))
@@ -300,7 +252,7 @@ test_that('error traps', {
   skip_if(run_glmnet)
 
   expect_error(
-    linear_reg() %>%
+    linear_reg(penalty = 0.01) %>%
       set_engine("glmnet") %>%
       fit(mpg ~ ., data = mtcars[-(1:4), ]) %>%
       predict(mtcars[-(1:4), ], penalty = 0:1)
diff --git a/tests/testthat/test-glmnet-logistic.R b/tests/testthat/test-glmnet-logistic.R
index 93793c35..8b849966 100644
--- a/tests/testthat/test-glmnet-logistic.R
+++ b/tests/testthat/test-glmnet-logistic.R
@@ -21,7 +21,7 @@ lending_club <- head(lending_club, 200)
 lc_form <- as.formula(Class ~ log(funded_amnt) + int_rate)
 num_pred <- c("funded_amnt", "annual_inc", "num_il_tl")
 lc_bad_form <- as.formula(funded_amnt ~ term)
-lc_basic <- logistic_reg() %>% set_engine("glmnet")
+lc_basic <- logistic_reg(penalty = 0.1) %>% set_engine("glmnet")
 
 # ------------------------------------------------------------------------------
 
@@ -116,92 +116,19 @@ test_that('glmnet prediction, mulitiple lambda', {
   lams <- c(0.01, 0.1)
 
   xy_fit <- fit_xy(
-    logistic_reg(penalty = lams) %>% set_engine("glmnet"),
+    logistic_reg(penalty = 0.1) %>% set_engine("glmnet"),
     control = ctrl,
     x = lending_club[, num_pred],
     y = lending_club$Class
   )
 
-  mult_pred <-
-    predict(xy_fit$fit,
-            newx = as.matrix(lending_club[1:7, num_pred]),
-            s = lams, type = "response")
-  mult_pred <- stack(as.data.frame(mult_pred))
-  mult_pred$values <- ifelse(mult_pred$values >= 0.5, "good", "bad")
-  mult_pred$values <- factor(mult_pred$values, levels = levels(lending_club$Class))
-  mult_pred$penalty <- rep(lams, each = 7)
-  mult_pred$rows <- rep(1:7, 2)
-  mult_pred <- mult_pred[order(mult_pred$rows, mult_pred$penalty), ]
-  mult_pred <- mult_pred[, c("penalty", "values")]
-  names(mult_pred) <- c("penalty", ".pred_class")
-  mult_pred <- tibble::as_tibble(mult_pred)
-
-  expect_equal(
-    mult_pred,
-    multi_predict(xy_fit, lending_club[1:7, num_pred], type = "class") %>% unnest(cols = c(.pred))
-    )
-
-  res_form <- fit(
-    logistic_reg(penalty = lams) %>% set_engine("glmnet"),
-    Class ~ log(funded_amnt) + int_rate,
-    data = lending_club,
-    control = ctrl
-  )
-
-  form_mat <- model.matrix(Class ~ log(funded_amnt) + int_rate, data = lending_club)
-  form_mat <- form_mat[1:7, -1]
-
-  form_pred <-
-    predict(res_form$fit,
-            newx = form_mat,
-            s = lams)
-  form_pred <- stack(as.data.frame(form_pred))
-  form_pred$values <- ifelse(form_pred$values >= 0.5, "good", "bad")
-  form_pred$values <- factor(form_pred$values, levels = levels(lending_club$Class))
-  form_pred$penalty <- rep(lams, each = 7)
-  form_pred$rows <- rep(1:7, 2)
-  form_pred <- form_pred[order(form_pred$rows, form_pred$penalty), ]
-  form_pred <- form_pred[, c("penalty", "values")]
-  names(form_pred) <- c("penalty", ".pred_class")
-  form_pred <- tibble::as_tibble(form_pred)
-
   expect_equal(
-    form_pred,
-    multi_predict(res_form, lending_club[1:7, c("funded_amnt", "int_rate")]) %>% unnest(cols = c(.pred))
+    tibble(penalty = rep(lams, 7), .pred_class = factor(rep("good", 14), levels = c("bad", "good"))),
+    multi_predict(xy_fit, lending_club[1:7, num_pred], type = "class", penalty = lams) %>% unnest(cols = c(.pred))
   )
 
-})
-
-test_that('glmnet prediction, no lambda', {
-
-  skip_if_not_installed("glmnet")
-  skip_if(run_glmnet)
-
-  xy_fit <- fit_xy(
-    logistic_reg() %>% set_engine("glmnet", nlambda =  11),
-    control = ctrl,
-    x = lending_club[, num_pred],
-    y = lending_club$Class
-  )
-
-  mult_pred <-
-    predict(xy_fit$fit,
-            newx = as.matrix(lending_club[1:7, num_pred]),
-            s = xy_fit$fit$lambda, type = "response")
-  mult_pred <- stack(as.data.frame(mult_pred))
-  mult_pred$values <- ifelse(mult_pred$values >= 0.5, "good", "bad")
-  mult_pred$values <- factor(mult_pred$values, levels = levels(lending_club$Class))
-  mult_pred$penalty <- rep(xy_fit$fit$lambda, each = 7)
-  mult_pred$rows <- rep(1:7, 2)
-  mult_pred <- mult_pred[order(mult_pred$rows, mult_pred$penalty), ]
-  mult_pred <- mult_pred[, c("penalty", "values")]
-  names(mult_pred) <- c("penalty", ".pred_class")
-  mult_pred <- tibble::as_tibble(mult_pred)
-
-  expect_equal(mult_pred, multi_predict(xy_fit, lending_club[1:7, num_pred]) %>% unnest(cols = c(.pred)))
-
   res_form <- fit(
-    logistic_reg() %>% set_engine("glmnet", nlambda =  11),
+    logistic_reg(penalty = 0.01) %>% set_engine("glmnet"),
     Class ~ log(funded_amnt) + int_rate,
     data = lending_club,
     control = ctrl
@@ -210,23 +137,9 @@ test_that('glmnet prediction, no lambda', {
   form_mat <- model.matrix(Class ~ log(funded_amnt) + int_rate, data = lending_club)
   form_mat <- form_mat[1:7, -1]
 
-  form_pred <-
-    predict(res_form$fit,
-            newx = form_mat,
-            type = "response")
-  form_pred <- stack(as.data.frame(form_pred))
-  form_pred$values <- ifelse(form_pred$values >= 0.5, "good", "bad")
-  form_pred$values <- factor(form_pred$values, levels = levels(lending_club$Class))
-  form_pred$penalty <- rep(res_form$fit$lambda, each = 7)
-  form_pred$rows <- rep(1:7, 2)
-  form_pred <- form_pred[order(form_pred$rows, form_pred$penalty), ]
-  form_pred <- form_pred[, c("penalty", "values")]
-  names(form_pred) <- c("penalty", ".pred_class")
-  form_pred <- tibble::as_tibble(form_pred)
-
   expect_equal(
-    form_pred,
-    multi_predict(res_form, lending_club[1:7, c("funded_amnt", "int_rate")]) %>% unnest(cols = c(.pred))
+    tibble(penalty = rep(lams, 7), .pred_class = factor(rep("good", 14), levels = c("bad", "good"))),
+    multi_predict(res_form, lending_club[1:7, c("funded_amnt", "int_rate")], penalty = lams) %>% unnest(cols = c(.pred))
   )
 
 })
@@ -253,7 +166,7 @@ test_that('glmnet probabilities, one lambda', {
   expect_equal(
     uni_pred,
     predict(xy_fit, lending_club[1:7, num_pred], type = "prob")
-    )
+  )
 
   res_form <- fit(
     logistic_reg(penalty = 0.1)  %>% set_engine("glmnet"),
@@ -267,14 +180,14 @@ test_that('glmnet probabilities, one lambda', {
 
   form_pred <-
     unname(predict(res_form$fit,
-            newx = form_mat,
-            s = 0.1, type = "response")[, 1])
+                   newx = form_mat,
+                   s = 0.1, type = "response")[, 1])
   form_pred <- tibble(.pred_bad = 1 - form_pred, .pred_good = form_pred)
 
   expect_equal(
     form_pred,
     predict(res_form, lending_club[1:7, c("funded_amnt", "int_rate")], type = "prob")
-    )
+  )
 
   one_row <- predict(res_form, lending_club[1, c("funded_amnt", "int_rate")], type = "prob")
   expect_equal(form_pred[1,], one_row, ignore_attr = TRUE)
@@ -289,120 +202,62 @@ test_that('glmnet probabilities, mulitiple lambda', {
   lams <- c(0.01, 0.1)
 
   xy_fit <- fit_xy(
-    logistic_reg(penalty = lams)  %>% set_engine("glmnet"),
-    control = ctrl,
-    x = lending_club[, num_pred],
-    y = lending_club$Class
-  )
-
-  mult_pred <-
-    predict(xy_fit$fit,
-            newx = as.matrix(lending_club[1:7, num_pred]),
-            s = lams, type = "response")
-  mult_pred <- stack(as.data.frame(mult_pred))
-  mult_pred$penalty <- rep(lams, each = 7)
-  mult_pred$rows <- rep(1:7, 2)
-  mult_pred <- mult_pred[order(mult_pred$rows, mult_pred$penalty), ]
-  mult_pred$.pred_bad <- 1 - mult_pred$values
-  mult_pred <- mult_pred[, c("penalty", ".pred_bad", "values")]
-  names(mult_pred) <- c("penalty", ".pred_bad", ".pred_good")
-  mult_pred <- tibble::as_tibble(mult_pred)
-
-  expect_equal(
-    mult_pred,
-    multi_predict(xy_fit, lending_club[1:7, num_pred], lambda = lams, type = "prob") %>%
-      unnest(cols = c(.pred))
-    )
-
-  res_form <- fit(
-    logistic_reg(penalty = lams)  %>% set_engine("glmnet"),
-    Class ~ log(funded_amnt) + int_rate,
-    data = lending_club,
-    control = ctrl
-  )
-
-  form_mat <- model.matrix(Class ~ log(funded_amnt) + int_rate, data = lending_club)
-  form_mat <- form_mat[1:7, -1]
-
-  form_pred <-
-    predict(res_form$fit,
-            newx = form_mat,
-            s = lams, type = "response")
-  form_pred <- stack(as.data.frame(form_pred))
-  form_pred$penalty <- rep(lams, each = 7)
-  form_pred$rows <- rep(1:7, 2)
-  form_pred <- form_pred[order(form_pred$rows, form_pred$penalty), ]
-  form_pred$.pred_bad <- 1 - form_pred$values
-  form_pred <- form_pred[, c("penalty", ".pred_bad", "values")]
-  names(form_pred) <- c("penalty", ".pred_bad", ".pred_good")
-  form_pred <- tibble::as_tibble(form_pred)
-
-  expect_equal(
-    form_pred,
-    multi_predict(res_form, lending_club[1:7, c("funded_amnt", "int_rate")], type = "prob") %>%
-      unnest(cols = c(.pred))
-    )
-
-})
-
-
-test_that('glmnet probabilities, no lambda', {
-
-  skip_if_not_installed("glmnet")
-  skip_if(run_glmnet)
-
-  xy_fit <- fit_xy(
-    logistic_reg()  %>% set_engine("glmnet"),
+    logistic_reg(penalty = 0.01)  %>% set_engine("glmnet"),
     control = ctrl,
     x = lending_club[, num_pred],
     y = lending_club$Class
   )
 
   mult_pred <-
-    predict(xy_fit$fit,
-            newx = as.matrix(lending_club[1:7, num_pred]),
-            type = "response")
-  mult_pred <- stack(as.data.frame(mult_pred))
-  mult_pred$penalty <- rep(xy_fit$fit$lambda, each = 7)
-  mult_pred$rows <- rep(1:7, length(xy_fit$fit$lambda))
-  mult_pred <- mult_pred[order(mult_pred$rows, mult_pred$penalty), ]
-  mult_pred$.pred_bad <- 1 - mult_pred$values
-  mult_pred <- mult_pred[, c("penalty", ".pred_bad", "values")]
-  names(mult_pred) <- c("penalty", ".pred_bad", ".pred_good")
-  mult_pred <- tibble::as_tibble(mult_pred)
+    structure(list(penalty = c(0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01,
+                               0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1),
+                   .pred_bad = c(0.0248234347196115,
+                                 0.0549999999999999, 0.0539668350997529, 0.0549999999999999, 0.0410602871701227,
+                                 0.0549999999999999, 0.0614587344673951, 0.0549999999999999, 0.0246284512328244,
+                                 0.0549999999999999, 0.0275287859173489, 0.0549999999999999, 0.0361787791778279,
+                                 0.0549999999999999),
+                   .pred_good = c(0.975176565280389, 0.945,
+                                  0.946033164900247, 0.945, 0.958939712829877, 0.945, 0.938541265532605,
+                                  0.945, 0.975371548767176, 0.945, 0.972471214082651, 0.945, 0.963821220822172,
+                                  0.945)), row.names = c(NA, -14L),
+              class = c("tbl_df", "tbl",
+                        "data.frame"))
 
   expect_equal(
     mult_pred,
-    multi_predict(xy_fit, lending_club[1:7, num_pred], type = "prob") %>%
-      unnest(cols = c(.pred))
+    multi_predict(xy_fit, lending_club[1:7, num_pred], lambda = lams, type = "prob", penalty = lams) %>%
+      unnest(cols = c(.pred)),
+    tolerance = 0.0001
   )
 
   res_form <- fit(
-    logistic_reg() %>% set_engine("glmnet"),
+    logistic_reg(penalty = 0.01)  %>% set_engine("glmnet"),
     Class ~ log(funded_amnt) + int_rate,
     data = lending_club,
     control = ctrl
   )
 
-  form_mat <- model.matrix(Class ~ log(funded_amnt) + int_rate, data = lending_club)
-  form_mat <- form_mat[1:7, -1]
 
   form_pred <-
-    predict(res_form$fit,
-            newx = form_mat,
-            type = "response")
-  form_pred <- stack(as.data.frame(form_pred))
-  form_pred$penalty <- rep(res_form$fit$lambda, each = 7)
-  form_pred$rows <- rep(1:7, length(res_form$fit$lambda))
-  form_pred <- form_pred[order(form_pred$rows, form_pred$penalty), ]
-  form_pred$.pred_bad <- 1 - form_pred$values
-  form_pred <- form_pred[, c("penalty", ".pred_bad", "values")]
-  names(form_pred) <- c("penalty", ".pred_bad", ".pred_good")
-  form_pred <- tibble::as_tibble(form_pred)
+    structure(list(penalty = c(0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01,
+                               0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1),
+                   .pred_bad = c(0.0578012324911684,
+                                 0.0549999999999999, 0.0637405836452112, 0.0549999999999999, 0.0632245768025071,
+                                 0.0549999999999999, 0.0562134258323885, 0.0549999999999999, 0.00637189559769558,
+                                 0.0549999999999999, 0.0271083211970798, 0.0549999999999999, 0.00952896597808395,
+                                 0.0549999999999999),
+                   .pred_good = c(0.942198767508832, 0.945,
+                                  0.936259416354789, 0.945, 0.936775423197493, 0.945, 0.943786574167611,
+                                  0.945, 0.993628104402304, 0.945, 0.97289167880292, 0.945, 0.990471034021916,
+                                  0.945)), row.names = c(NA, -14L),
+              class = c("tbl_df", "tbl",
+                        "data.frame"))
 
   expect_equal(
     form_pred,
-    multi_predict(res_form, lending_club[1:7, c("funded_amnt", "int_rate")], type = "prob") %>% unnest(cols = c(.pred))
+    multi_predict(res_form, lending_club[1:7, c("funded_amnt", "int_rate")], type = "prob", penalty = lams) %>%
+      unnest(cols = c(.pred)),
+    tolerance = 0.0001
   )
 
 })
@@ -415,7 +270,7 @@ test_that('submodel prediction', {
 
   vars <- c("female", "tenure", "total_charges", "phone_service", "monthly_charges")
   class_fit <-
-    logistic_reg() %>%
+    logistic_reg(penalty = 0.01) %>%
     set_engine("glmnet") %>%
     fit(churn ~ ., data = wa_churn[-(1:4), c("churn", vars)])
 
diff --git a/tests/testthat/test-glmnet-multinom.R b/tests/testthat/test-glmnet-multinom.R
index 512e66dc..4cab2ab0 100644
--- a/tests/testthat/test-glmnet-multinom.R
+++ b/tests/testthat/test-glmnet-multinom.R
@@ -25,7 +25,7 @@ test_that('glmnet execution', {
 
   expect_error(
     res <- fit_xy(
-      multinom_reg() %>% set_engine("glmnet"),
+      multinom_reg(penalty = 0.1) %>% set_engine("glmnet"),
       control = ctrl,
       x = hpc[, 1:4],
       y = hpc$class
@@ -38,7 +38,7 @@ test_that('glmnet execution', {
 
   expect_error(
     glmnet_xy_catch <- fit_xy(
-      multinom_reg() %>% set_engine("glmnet"),
+      multinom_reg(penalty = 0.1) %>% set_engine("glmnet"),
       x = hpc[, 2:5],
       y = hpc$compounds,
       control = caught_ctrl
@@ -104,14 +104,14 @@ test_that('glmnet probabilities, mulitiple lambda', {
   lams <- c(0.01, 0.1)
 
   xy_fit <- fit_xy(
-    multinom_reg(penalty = lams) %>% set_engine("glmnet"),
+    multinom_reg(penalty = 0.1) %>% set_engine("glmnet"),
     control = ctrl,
     x = hpc[, 1:4],
     y = hpc$class
   )
 
-  expect_error(predict(xy_fit, hpc[rows, 1:4], type = "class"))
-  expect_error(predict(xy_fit, hpc[rows, 1:4], type = "prob"))
+  expect_error(predict(xy_fit, hpc[rows, 1:4], type = "class"), NA)
+  expect_error(predict(xy_fit, hpc[rows, 1:4], type = "prob"), NA)
 
   mult_pred <-
     predict(xy_fit$fit,
@@ -175,7 +175,7 @@ test_that("class predictions are factors with all levels", {
   skip_if_not_installed("glmnet")
   skip_if(run_glmnet)
 
-  basic <- multinom_reg() %>% set_engine("glmnet") %>% fit(class ~ ., data = hpc)
+  basic <- multinom_reg(penalty = 0.1) %>% set_engine("glmnet") %>% fit(class ~ ., data = hpc)
   nd <- hpc[hpc$class == "VF", ]
   yhat <- predict(basic, new_data = nd, penalty = .1)
   yhat_multi <- multi_predict(basic, new_data =  nd, penalty = .1)$.pred