context("estimatr::iv_robust objects") skip_if_not_installed("estimatr") suppressMessages(library(estimatr, quietly = TRUE)) set.seed(20190513) # ------------------------------------------------- # Set up test data with IV structure # ------------------------------------------------- N <- 200L J <- 20L cluster <- rep(1:J, each = N / J) # Instruments z1 <- rnorm(N) z2 <- rnorm(N) # Exogenous regressor x_exog <- rnorm(N) # Endogenous regressor (correlated with instruments) x_endog <- 0.5 * z1 + 0.3 * z2 + rnorm(N) # Outcome y <- 1 + 2 * x_endog + 0.5 * x_exog + rnorm(N) # Weights w <- 1 + rpois(N, lambda = 3) dat <- data.frame( y = y, x_endog = x_endog, x_exog = x_exog, z1 = z1, z2 = z2, w = w, cluster = cluster ) CR_types <- paste0("CR", 0:4) # ------------------------------------------------- # Fit models # ------------------------------------------------- # Unweighted, no clusters in call iv_un <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat ) # Weighted, no clusters in call iv_wt <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat, weights = w ) # Clustered with CR2 iv_cl <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat, clusters = cluster, se_type = "CR2" ) # Clustered with CR0 iv_cl_cr0 <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat, clusters = cluster, se_type = "CR0" ) # Clustered with stata iv_cl_stata <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat, clusters = cluster, se_type = "stata" ) # Weighted, no clusters in call iv_cl_wt <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat, weights = w, clusters = cluster ) # Build manual matrices for verification mf <- model.frame(iv_un$terms, data = dat) X <- model.matrix(iv_un$terms_regressors, data = mf) inst_formula <- as.formula(paste("~", deparse(iv_un$formula[[3]][[3]]))) Z <- model.matrix(inst_formula, data = mf) y_vec <- mf$y # ------------------------------------------------- # Tests: model.frame # ------------------------------------------------- test_that("model.frame() works for iv_robust.", { mf_un <- model.frame(iv_un) expect_equal(ncol(mf_un), 5L) # y, x_endog, x_exog, z1, z2 expect_true(all(c("y", "x_endog", "x_exog", "z1", "z2") %in% names(mf_un))) expect_equal(nrow(mf_un), N) # Clustered model has (clusters) column mf_cl <- model.frame(iv_cl) expect_true("(clusters)" %in% names(mf_cl)) expect_equal(mf_cl[["(clusters)"]], dat$cluster) # Weighted model has (weights) column mf_wt <- model.frame(iv_wt) expect_true("(weights)" %in% names(mf_wt)) # Clustered and weighted model has (clusters) and (weights) columns mf_cl_wt <- model.frame(iv_cl_wt) expect_true("(weights)" %in% names(mf_cl_wt)) expect_true("(clusters)" %in% names(mf_cl_wt)) expect_equal(mf_cl[["(clusters)"]], dat$cluster) }) # ------------------------------------------------- # Tests: model_matrix (projected X) # ------------------------------------------------- test_that("model_matrix() returns projected matrix with correct dimensions.", { mm <- model_matrix(iv_un) expect_identical(dim(mm), c(N,ncol(X))) expect_equal(colnames(mm), colnames(X)) }) test_that("model_matrix() agrees with manual projection.", { # Unweighted model XZ <- model_matrix(iv_un) ZtZ_inv <- chol2inv(chol(crossprod(Z))) XZ_check <- Z %*% ZtZ_inv %*% crossprod(Z, X) expect_equal(XZ, XZ_check, check.attributes = FALSE) # Weighted model XZ_wt <- model_matrix(iv_wt) ZwZ_inv <- chol2inv(chol(crossprod(Z, w * Z))) XZ_check <- Z %*% ZwZ_inv %*% crossprod(Z, w * X) expect_equal(XZ_wt, XZ_check, check.attributes = FALSE) }) # ------------------------------------------------- # Tests: residuals # ------------------------------------------------- test_that("residuals_CS() matches y - X * beta.", { r_un <- residuals_CS(iv_un) r_check <- as.vector(y_vec - X %*% coef_CS(iv_un)) expect_equal(as.vector(r_un), r_check) r_wt <- residuals_CS(iv_wt) r_check_wt <- as.vector(y_vec - X %*% coef_CS(iv_wt)) expect_equal(as.vector(r_wt), r_check_wt) }) # ------------------------------------------------- # Tests: bread # ------------------------------------------------- test_that("bread() agrees with manual computation.", { # Unweighted model XZ <- model_matrix(iv_un) bread_check <- chol2inv(chol(crossprod(XZ))) * nobs(iv_un) expect_equal(bread(iv_un), bread_check, check.attributes = FALSE) expect_true(check_bread(iv_un, cluster = dat$cluster, y = dat$y)) # Weighted model XZ <- model_matrix(iv_wt) bread_check <- chol2inv(chol(crossprod(XZ, w * XZ))) * nobs(iv_wt) expect_equal(bread(iv_wt), bread_check, check.attributes = FALSE) expect_true(check_bread(iv_wt, cluster = dat$cluster, y = dat$y)) }) # ------------------------------------------------- # Tests: vcovCR runs with explicit args # ------------------------------------------------- test_that("vcovCR works with explicit cluster and type.", { for (cr in CR_types) { V <- vcovCR(iv_un, cluster = dat$cluster, type = cr) expect_s3_class(V, "clubSandwich") expect_identical(dim(V), rep(length(coef(iv_un)), 2L)) } }) test_that("vcovCR works for weighted model.", { for (cr in CR_types) { V <- vcovCR(iv_wt, cluster = dat$cluster, type = cr) expect_s3_class(V, "clubSandwich") } }) # ------------------------------------------------- # Tests: cluster auto-detection # ------------------------------------------------- test_that("vcovCR auto-detects cluster from iv_robust object.", { V_auto <- vcovCR(iv_cl) V_explicit <- vcovCR(iv_cl, cluster = dat$cluster, type = "CR2") expect_equal(V_auto, V_explicit, check.attributes = FALSE) }) test_that("vcovCR errors when cluster is missing on unclustered model.", { expect_error( vcovCR(iv_un, type = "CR2"), "You must specify a clustering variable" ) }) # ------------------------------------------------- # Tests: SE type inference # ------------------------------------------------- test_that("vcovCR inherits se_type from iv_robust object.", { # CR2 V_auto_cr2 <- vcovCR(iv_cl) V_explicit_cr2 <- vcovCR(iv_cl, cluster = dat$cluster, type = "CR2") expect_equal(V_auto_cr2, V_explicit_cr2, check.attributes = FALSE) V_auto_wt_cr2 <- vcovCR(iv_cl_wt) V_explicit_wt_cr2 <- vcovCR(iv_cl_wt, cluster = dat$cluster, type = "CR2") expect_equal(V_auto_wt_cr2, V_explicit_wt_cr2, check.attributes = FALSE) # CR0 V_auto_cr0 <- vcovCR(iv_cl_cr0) V_explicit_cr0 <- vcovCR(iv_cl_cr0, cluster = dat$cluster, type = "CR0") expect_equal(V_auto_cr0, V_explicit_cr0, check.attributes = FALSE) # stata -> CR1S V_auto_stata <- vcovCR(iv_cl_stata) V_explicit_stata <- vcovCR(iv_cl_stata, cluster = dat$cluster, type = "CR1S") expect_equal(V_auto_stata, V_explicit_stata, check.attributes = FALSE) }) test_that("vcovCR errors when se_type cannot be mapped.", { expect_error( vcovCR(iv_un, cluster = dat$cluster), "You must specify a `type`" ) }) # ------------------------------------------------- # Tests: inverse_var rejection # ------------------------------------------------- test_that("vcovCR rejects inverse_var = TRUE.", { expect_error( vcovCR(iv_un, cluster = dat$cluster, type = "CR2", inverse_var = TRUE), "inverse_var option is not available" ) }) # ------------------------------------------------- # Tests: na.action # ------------------------------------------------- test_that("na.action() works correctly.", { dat_na <- dat dat_na$y[c(5, 15, 25)] <- NA iv_na <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat_na, clusters = cluster, se_type = "CR2" ) na_act <- na.action(iv_na) expect_s3_class(na_act, "omit") expect_equal(as.integer(na_act), c(5L, 15L, 25L)) expect_equal(nobs(iv_na), N - 3L) }) # ------------------------------------------------- # Tests: vcovCR options # ------------------------------------------------- test_that("vcovCR options don't matter for CR0.", { CR0 <- vcovCR(iv_un, cluster = dat$cluster, type = "CR0") expect_output(print(CR0)) attr(CR0, "target") <- NULL attr(CR0, "inverse_var") <- NULL CR0_A <- vcovCR(iv_un, cluster = dat$cluster, type = "CR0", target = 1 / dat$w) attr(CR0_A, "target") <- NULL attr(CR0_A, "inverse_var") <- NULL expect_identical(CR0_A, CR0) CR0_B <- vcovCR(iv_un, cluster = dat$cluster, type = "CR0", target = 1 / dat$w, inverse_var = FALSE) attr(CR0_B, "target") <- NULL attr(CR0_B, "inverse_var") <- NULL expect_identical(CR0_B, CR0) expect_error( vcovCR(iv_un, cluster = dat$cluster, type = "CR0", target = 1 / dat$w, inverse_var = TRUE) ) }) test_that("vcovCR options work for CR2.", { CR2 <- vcovCR(iv_un, cluster = dat$cluster, type = "CR2") expect_equal( vcovCR(iv_un, cluster = dat$cluster, type = "CR2", target = rep(1, nobs(iv_un))), CR2 ) expect_false(identical( vcovCR(iv_un, cluster = dat$cluster, type = "CR2", target = 1 / dat$w), CR2 )) }) test_that("vcovCR options work for CR4.", { CR4 <- vcovCR(iv_un, cluster = dat$cluster, type = "CR4") expect_identical( vcovCR(iv_un, cluster = dat$cluster, type = "CR4", target = rep(1, nobs(iv_un))), CR4 ) expect_false(identical( vcovCR(iv_un, cluster = dat$cluster, type = "CR4", target = 1 / dat$w), CR4 )) }) # ------------------------------------------------- # Tests: CR2 target-unbiasedness # ------------------------------------------------- test_that("CR2 is target-unbiased.", { expect_true(check_CR(iv_un, vcov = "CR2", cluster = dat$cluster)) expect_true(check_CR(iv_wt, vcov = "CR2", cluster = dat$cluster)) }) test_that("CR4 is target-unbiased.", { skip("Need to understand target-unbiasedness for iv_robust objects.") expect_true(check_CR(iv_un, vcov = "CR4", cluster = dat$cluster)) expect_true(check_CR(iv_wt, vcov = "CR4", cluster = dat$cluster)) }) # ------------------------------------------------- # Tests: equivalence to vcovHC with size-1 clusters # ------------------------------------------------- test_that("vcovCR is equivalent to vcovHC (with HC0-HC3) when clusters are all of size 1.", { suppressMessages(library(sandwich, quietly = TRUE)) iv_fit <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat, se_type = "HC0" ) CR0 <- vcovCR(iv_fit, cluster = 1:nobs(iv_fit), type = "CR0") expect_equal(as.matrix(CR0), vcov(iv_fit), check.attributes = FALSE) CR1 <- vcovCR(iv_fit, cluster = 1:nobs(iv_fit), type = "CR1p") expect_equal(as.matrix(CR1), vcov(update(iv_fit, se_type = "HC1")), check.attributes = FALSE) CR2 <- vcovCR(iv_fit, cluster = 1:nobs(iv_fit), type = "CR2") expect_equal(as.matrix(CR2), vcov(update(iv_fit, se_type = "HC2")), check.attributes = FALSE) CR3 <- vcovCR(iv_fit, cluster = 1:nobs(iv_fit), type = "CR3") expect_equal(as.matrix(CR3), vcov(update(iv_fit, se_type = "HC3")), check.attributes = FALSE) }) # ------------------------------------------------- # Tests: sort-order invariance # ------------------------------------------------- test_that("Order doesn't matter.", { check_sort_order(iv_un, dat, "cluster") check_sort_order(iv_wt, dat, "cluster") check_sort_order(iv_cl, dat, "cluster") check_sort_order(iv_cl_wt, dat, "cluster") }) # ------------------------------------------------- # Tests: dropped observations # ------------------------------------------------- test_that("clubSandwich works with dropped observations", { dat_miss <- dat dat_miss$x_exog[sample.int(N, size = round(N / 10))] <- NA iv_dropped <- update(iv_un, data = dat_miss) dat_complete <- subset(dat_miss, !is.na(x_exog)) iv_complete <- update(iv_un, data = dat_complete) CR_drop <- lapply(CR_types, function(x) vcovCR(iv_dropped, cluster = dat_miss$cluster, type = x)) CR_complete <- lapply(CR_types, function(x) vcovCR(iv_complete, cluster = dat_complete$cluster, type = x)) expect_equal(CR_drop, CR_complete) test_drop <- lapply(CR_types, function(x) coef_test(iv_dropped, vcov = x, cluster = dat_miss$cluster, test = "All", p_values = FALSE)) test_complete <- lapply(CR_types, function(x) coef_test(iv_complete, vcov = x, cluster = dat_complete$cluster, test = "All", p_values = FALSE)) expect_equal(test_drop, test_complete) }) # ------------------------------------------------- # Tests: weight scale invariance # ------------------------------------------------- test_that("weight scale doesn't matter", { iv_fit_w <- update(iv_un, weights = rep(4, nobs(iv_un))) unweighted_fit <- lapply(CR_types, function(x) vcovCR(iv_un, cluster = dat$cluster, type = x)) weighted_fit <- lapply(CR_types, function(x) vcovCR(iv_fit_w, cluster = dat$cluster, type = x)) expect_equal(lapply(unweighted_fit, as.matrix), lapply(weighted_fit, as.matrix), tol = 5 * 10^-7) target <- 1 + rpois(N, lambda = 8) unweighted_fit <- lapply(CR_types, function(x) vcovCR(iv_un, cluster = dat$cluster, type = x, target = target)) weighted_fit <- lapply(CR_types, function(x) vcovCR(iv_fit_w, cluster = dat$cluster, type = x, target = target * 15)) expect_equal(lapply(unweighted_fit, as.matrix), lapply(weighted_fit, as.matrix), tol = 5 * 10^-7) }) # ------------------------------------------------- # Tests: weights of zero # ------------------------------------------------- test_that("clubSandwich works with weights of zero.", { dat$awt <- rpois(N, lambda = 1.4) iv_full <- update(iv_un, weights = awt) dat_sub <- subset(dat, awt > 0) iv_sub <- update(iv_full, data = dat_sub) CR_full <- lapply(CR_types, function(x) vcovCR(iv_full, cluster = dat$cluster, type = x)) CR_sub <- lapply(CR_types, function(x) vcovCR(iv_sub, cluster = dat_sub$cluster, type = x)) expect_equal(CR_full, CR_sub, check.attributes = FALSE) test_full <- lapply(CR_types, function(x) coef_test(iv_full, vcov = x, cluster = dat$cluster, test = c("z", "naive-t", "Satterthwaite"), p_values = TRUE)) test_sub <- lapply(CR_types, function(x) coef_test(iv_sub, vcov = x, cluster = dat_sub$cluster, test = c("z", "naive-t", "Satterthwaite"), p_values = TRUE)) expect_equal(test_full, test_sub, check.attributes = FALSE) }) # ------------------------------------------------- # Tests: fixed_effects # ------------------------------------------------- iv_fe <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat, clusters = cluster, fixed_effects = ~ cluster, se_type = "CR2" ) test_that("model.frame() includes fixed-effects variables", { mf_fe <- model.frame(iv_fe) expect_true("cluster" %in% names(mf_fe)) }) test_that("augmented_model_matrix() returns the FE design matrix", { amm <- augmented_model_matrix(iv_fe, cluster = dat$cluster, inverse_var = FALSE, ignore_FE = FALSE) expect_equal(nrow(amm), N) expect_equal(ncol(amm), J) expect_equal(colnames(amm), paste0("cluster", levels(as.factor(dat$cluster)))) # For a non-FE model, augmented_model_matrix() returns NULL expect_null(augmented_model_matrix(iv_un, cluster = dat$cluster, inverse_var = FALSE, ignore_FE = FALSE)) }) test_that("model_matrix() returns FE-residualized projected matrix", { XP <- model_matrix(iv_fe) expect_equal(nrow(XP), N) expect_equal(ncol(XP), length(coef(iv_fe))) # Coefficients should be recoverable from X_proj and FE-residualized outcome F_mat <- model.matrix(~ 0 + cluster, data = dat) y_demean <- lm.fit(F_mat, dat$y)$residuals expect_equal(lm.fit(XP, y_demean)$coefficients, coef(iv_fe), check.attributes = FALSE) # Projected columns should be centered within each cluster within_means <- apply(XP, 2, function(x) tapply(x, dat$cluster, mean)) expect_lt(max(abs(within_means)), 1e-12) }) test_that("model_matrix() FE path agrees without fixest", { local_mocked_bindings( requireNamespace = function(...) FALSE ) expect_false(requireNamespace("fixest", quietly = TRUE)) XP <- model_matrix(iv_fe) F_mat <- model.matrix(~ 0 + cluster, data = dat) y_demean <- lm.fit(F_mat, dat$y)$residuals expect_equal(lm.fit(XP, y_demean)$coefficients, coef(iv_fe), check.attributes = FALSE) expect_message( vcovCR(iv_fe, type = "CR0"), "For improved performance in models with fixed effects, install the \\{fixest\\} package." ) }) test_that("vcovCR works with fixed effects", { for (cr in CR_types) { V <- vcovCR(iv_fe, cluster = dat$cluster, type = cr) expect_s3_class(V, "clubSandwich") expect_equal(nrow(V), length(coef(iv_fe))) expect_equal(ncol(V), length(coef(iv_fe))) } }) test_that("bread() works with fixed effects", { expect_true(check_bread(iv_fe, cluster = dat$cluster, y = dat$y)) }) test_that("CR2 is target-unbiased with fixed effects", { expect_true(check_CR(iv_fe, vcov = "CR2")) }) test_that("vcovCR matches iv_robust$vcov for FE model with se_type='CR0'", { iv_fe_cr0 <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat, clusters = cluster, fixed_effects = ~ cluster, se_type = "CR0" ) V_cr0 <- vcovCR(iv_fe_cr0, type = "CR0") expect_equal(as.matrix(V_cr0), vcov(iv_fe_cr0), check.attributes = FALSE) }) test_that("model_matrix() weighted FE path agrees without fixest", { iv_fe_wt <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat, weights = w, clusters = cluster, fixed_effects = ~ cluster, se_type = "CR0" ) local_mocked_bindings( requireNamespace = function(...) FALSE ) expect_false(requireNamespace("fixest", quietly = TRUE)) XP <- model_matrix(iv_fe_wt) F_mat <- model.matrix(~ 0 + cluster, data = dat) y_demean <- stats::lm.wfit(F_mat, dat$y, w)$residuals expect_equal(stats::lm.wfit(XP, y_demean, w)$coefficients, coef(iv_fe_wt), check.attributes = FALSE) # Projected columns should be weighted-centered within each cluster within_means <- apply(XP, 2, function(x) tapply(x * w, dat$cluster, sum) / tapply(w, dat$cluster, sum) ) expect_lt(max(abs(within_means)), 1e-12) }) test_that("model.frame() handles misaligned NAs between regressor frame and FE frame", { dat_mis <- dat dat_mis$fe_var <- factor(rep(1:10, each = N / 10)) # NAs in regressor on rows {5, 15, 25}; NAs in FE on rows {7, 17, 27}. # The two model frames drop different rows, exercising the reconciliation else-branch. dat_mis$x_exog[c(5, 15, 25)] <- NA dat_mis$fe_var[c(7, 17, 27)] <- NA iv_mis <- suppressWarnings(iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat_mis, clusters = cluster, fixed_effects = ~ fe_var, se_type = "CR0" )) mf <- model.frame(iv_mis) expect_equal(nrow(mf), N - 6L) expect_true(all(c("x_endog", "x_exog", "fe_var") %in% names(mf))) na_act <- attr(mf, "na.action") expect_s3_class(na_act, "omit") expect_equal(length(na_act), 6L) dropped <- as.integer(as.character(na_act)) expect_setequal(dropped, c(5L, 7L, 15L, 17L, 25L, 27L)) expect_s3_class(vcovCR(iv_mis, type = "CR0"), "clubSandwich") }) # ------------------------------------------------- # Tests: missing cluster # ------------------------------------------------- test_that("clubSandwich requires no missing values on the clustering variable", { dat_miss <- dat miss_indicator <- sample.int(N, size = round(N / 10)) dat_miss$cluster[miss_indicator] <- NA iv_dropped <- iv_robust(y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat_miss) expect_error(vcovCR(iv_dropped, cluster = dat_miss$cluster, type = "CR0"), "Clustering variable cannot have missing values.") expect_error(coef_test(iv_dropped, vcov = "CR0", cluster = dat_miss$cluster, test = "All"), "Clustering variable cannot have missing values.") }) # ------------------------------------------------- # Higher-level inference tests: compare against ivreg::ivreg # ------------------------------------------------- skip_if_not_installed("ivreg") iv_reg <- ivreg::ivreg( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat ) iv_est <- iv_robust( y ~ x_endog + x_exog | x_exog + z1 + z2, data = dat ) test_that("Wald_test() agrees between iv_robust and ivreg", { W_reg <- Wald_test(iv_reg, constraints = constrain_zero("x_endog"), vcov = "CR2", cluster = dat$cluster) W_est <- Wald_test(iv_est, constraints = constrain_zero("x_endog"), vcov = "CR2", cluster = dat$cluster) expect_equal(W_reg, W_est) }) test_that("conf_int() agrees between iv_robust and ivreg", { ci_reg <- conf_int(iv_reg, vcov = "CR2", cluster = dat$cluster) ci_est <- conf_int(iv_est, vcov = "CR2", cluster = dat$cluster) expect_equal(ci_reg, ci_est) }) test_that("coef_test() agrees between iv_robust and ivreg", { ct_reg <- coef_test(iv_reg, vcov = "CR2", cluster = dat$cluster) ct_est <- coef_test(iv_est, vcov = "CR2", cluster = dat$cluster) expect_equal(ct_reg, ct_est) })