coverband 6.2.1 → 6.2.2

data/public/application.js

@@ -33,8 +33,14 @@ $(document).ready(function () {
     ],
   }
 
+  tableOptions.fnDrawCallback = function (oSettings) {
+    if (window.deadCodeOnDraw) window.deadCodeOnDraw(oSettings);
+  };
+
   $(".file_list").dataTable(tableOptions);
 
+  initDeadCodeSession();
+
   // TODO: add support for searching on server side
   // best docs on our version of datatables 1.7 https://datatables.net/beta/1.7/examples/server_side/server_side.html
   if ($(".file_list.unsorted").length == 1) {
@@ -220,4 +226,244 @@ $(document).ready(function () {
   $("#loading").fadeOut();
   $("#wrapper").show();
   $(".dataTables_filter input").focus();
+
+  function initDeadCodeSession() {
+    if (!window.CoverbandDeadCode || !$(".file_list").length) return;
+    var D = window.CoverbandDeadCode;
+    var storageKey = "coverband_deadcode_session:" + ($(".file_list").data("coverageurl") || "/");
+    var state;
+    try {
+      state = D.parseState(window.localStorage.getItem(storageKey));
+    } catch (e) {
+      console && console.warn && console.warn("coverband dead-code session: localStorage unavailable", e);
+      state = D.emptyState();
+    }
+    if (!state.startedAt) state.startedAt = new Date().toISOString();
+
+    function saveState() {
+      try {
+        window.localStorage.setItem(storageKey, JSON.stringify(state));
+      } catch (e) { /* private mode etc.; session still works in-memory */ }
+    }
+    saveState();
+
+    var extractPath = D.extractPath;
+    var rowRuntime = D.rowRuntime;
+
+    // Custom filter: hide rows excluded by the session (DataTables 1.7 API)
+    $.fn.dataTableExt.afnFiltering.push(function (oSettings, aData, iDataIndex) {
+      if (!$(oSettings.nTable).hasClass("file_list")) return true;
+      return !D.isExcluded(state, extractPath(aData[0]), rowRuntime(aData));
+    });
+
+    function redrawTables() {
+      $(".file_list").each(function () {
+        $(this).dataTable().fnDraw();
+      });
+      updateBadges();
+    }
+
+    function updateBadges() {
+      var hidden = 0;
+      $(".file_list").each(function () {
+        var data = $(this).dataTable().fnGetData();
+        for (var i = 0; i < data.length; i++) {
+          if (D.isExcludedIgnoringMarks(state, extractPath(data[i][0]), rowRuntime(data[i]))) hidden++;
+        }
+      });
+      $("#dcs-hidden-count").text(hidden + " hidden");
+      $("#dcs-marked-count").text(state.markedPaths.length);
+      var chips = $("#dcs-chips").empty();
+      $.each(state.hiddenPaths, function (_i, entry) {
+        var chip = $('<span class="dcs-chip"></span>').text(entry);
+        $('<button class="dcs-chip-x" title="Unhide">&times;</button>')
+          .appendTo(chip)
+          .bind("click", function () {
+            D.removeHidden(state, entry);
+            saveState();
+            redrawTables();
+          });
+        chips.append(chip);
+      });
+      chips.toggle(state.hiddenPaths.length > 0 && chips.data("open") === true);
+      $("#dcs-chips-toggle").toggle(state.hiddenPaths.length > 0)
+        .text("Hidden items (" + state.hiddenPaths.length + ")");
+    }
+
+    // Toolbar
+    var toolbar = $(
+      '<div id="dcs-toolbar">' +
+      '  <strong>Dead-code session</strong>' +
+      '  <label><input type="checkbox" id="dcs-runtime-toggle"> Hide files with runtime % &gt; 0</label>' +
+      '  <span class="dcs-badge" id="dcs-hidden-count">0 hidden</span>' +
+      '  <button type="button" id="dcs-marked-btn">Marked for deletion: <span id="dcs-marked-count">0</span></button>' +
+      '  <button type="button" id="dcs-chips-toggle">Hidden items</button>' +
+      '  <button type="button" id="dcs-reset">Reset session</button>' +
+      '  <div id="dcs-chips"></div>' +
+      '</div>'
+    );
+    $("#content").prepend(toolbar);
+
+    $("#dcs-runtime-toggle")
+      .prop("checked", state.hideRuntimeUsed)
+      .bind("change", function () {
+        state.hideRuntimeUsed = this.checked;
+        saveState();
+        redrawTables();
+      });
+
+    $("#dcs-chips-toggle").bind("click", function () {
+      var chips = $("#dcs-chips");
+      chips.data("open", chips.data("open") !== true);
+      updateBadges();
+    });
+
+    $("#dcs-reset").bind("click", function () {
+      if (!confirm("Reset session? This unhides everything (marked-for-deletion list is kept).")) return;
+      window.CoverbandDeadCode.clearHides(state);
+      $("#dcs-runtime-toggle").prop("checked", false);
+      saveState();
+      redrawTables();
+    });
+
+    // Exposed for Tasks 3-4 and the shared fnDrawCallback
+    window.deadCodeSession = {
+      D: D, state: state, saveState: saveState,
+      redrawTables: redrawTables, updateBadges: updateBadges,
+      extractPath: extractPath
+    };
+    window.deadCodeOnDraw = function (oSettings) {
+      if (window.deadCodeDecorate) window.deadCodeDecorate(oSettings);
+      updateBadges();
+    };
+
+    var escapeHtml = D.escapeHtml;
+
+    window.deadCodeDecorate = function (oSettings) {
+      $(oSettings.nTable).find("tbody td a.src_link").not(".dcs-done").each(function () {
+        var link = $(this);
+        var fullPath = link.attr("title");
+        if (!fullPath) return;
+        var segs = D.segmentPrefixes(fullPath);
+        var html = "";
+        for (var i = 0; i < segs.length; i++) {
+          html += '<span class="dcs-seg" data-prefix="' + escapeHtml(segs[i].prefix) + '">' +
+            escapeHtml(segs[i].label) +
+            '<span class="dcs-actions">' +
+            '<button type="button" class="dcs-hide" title="Hide ' + escapeHtml(segs[i].prefix) + (segs[i].isFile ? "" : " and everything under it") + '">&times;</button>' +
+            '<button type="button" class="dcs-mark" title="Mark ' + escapeHtml(segs[i].prefix) + ' for deletion">&#128465;</button>' +
+            '</span></span>' + (segs[i].isFile ? "" : "/");
+        }
+        link.html(html).addClass("dcs-done");
+
+        link.find(".dcs-hide").bind("click", function (e) {
+          e.preventDefault();
+          e.stopPropagation();
+          D.addHidden(state, $(this).closest(".dcs-seg").attr("data-prefix"));
+          saveState();
+          redrawTables();
+          return false;
+        });
+        link.find(".dcs-mark").bind("click", function (e) {
+          e.preventDefault();
+          e.stopPropagation();
+          openMarkPopup($(this).closest(".dcs-seg").attr("data-prefix"), e.pageX, e.pageY);
+          return false;
+        });
+      });
+    };
+
+    function closeMarkPopup() { $("#dcs-mark-popup").remove(); }
+
+    function openMarkPopup(prefix, x, y) {
+      closeMarkPopup();
+      var popup = $(
+        '<div id="dcs-mark-popup">' +
+        '  <div class="dcs-popup-path"></div>' +
+        '  <textarea id="dcs-mark-comment" rows="2" placeholder="Optional comment (why is this dead?)"></textarea>' +
+        '  <div class="dcs-popup-actions">' +
+        '    <button type="button" id="dcs-mark-confirm">Mark for deletion</button>' +
+        '    <button type="button" id="dcs-mark-cancel">Cancel</button>' +
+        '  </div>' +
+        '</div>'
+      );
+      popup.find(".dcs-popup-path").text(prefix);
+      popup.css({ left: Math.min(x, $(window).width() - 340) + "px", top: (y + 8) + "px" });
+      $("body").append(popup);
+      $("#dcs-mark-comment").focus();
+      $("#dcs-mark-cancel").bind("click", closeMarkPopup);
+      $("#dcs-mark-confirm").bind("click", function () {
+        D.addMark(state, prefix, $("#dcs-mark-comment").val(), new Date().toISOString());
+        saveState();
+        closeMarkPopup();
+        redrawTables();
+      });
+    }
+
+    function closeMarkedModal() { $("#dcs-modal-overlay").remove(); }
+
+    function downloadCSV() {
+      var blob = new Blob([D.toCSV(state.markedPaths)], { type: "text/csv;charset=utf-8" });
+      var a = document.createElement("a");
+      a.href = URL.createObjectURL(blob);
+      a.download = D.csvFilename(new Date());
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(a.href);
+    }
+
+    function openMarkedModal() {
+      closeMarkedModal();
+      var overlay = $('<div id="dcs-modal-overlay"><div id="dcs-modal">' +
+        '<div id="dcs-modal-head"><strong>Marked for deletion</strong>' +
+        '<button type="button" id="dcs-modal-close">&times;</button></div>' +
+        '<table id="dcs-modal-table"><thead><tr>' +
+        '<th>Path</th><th>Comment</th><th>Marked at</th><th></th>' +
+        '</tr></thead><tbody></tbody></table>' +
+        '<div id="dcs-modal-foot">' +
+        '<button type="button" id="dcs-csv">Download CSV</button>' +
+        '<button type="button" id="dcs-start-over">Start over</button>' +
+        '</div></div></div>');
+      var tbody = overlay.find("tbody");
+      if (state.markedPaths.length === 0) {
+        tbody.append('<tr><td colspan="4"><em>Nothing marked yet.</em></td></tr>');
+      }
+      $.each(state.markedPaths.slice(), function (_i, m) {
+        var tr = $("<tr></tr>");
+        $('<td class="dcs-mono"></td>').text(m.path).appendTo(tr);
+        var commentInput = $('<input type="text" class="dcs-comment-edit">').val(m.comment)
+          .bind("change", function () {
+            D.updateComment(state, m.path, $(this).val());
+            saveState();
+          });
+        $("<td></td>").append(commentInput).appendTo(tr);
+        $('<td class="dcs-mono"></td>').text(m.markedAt).appendTo(tr);
+        $("<td></td>").append(
+          $('<button type="button" title="Unmark">&times;</button>').bind("click", function () {
+            D.removeMark(state, m.path);
+            saveState();
+            redrawTables();
+            openMarkedModal(); // rebuild
+          })
+        ).appendTo(tr);
+        tbody.append(tr);
+      });
+      $("body").append(overlay);
+      $("#dcs-modal-close").bind("click", closeMarkedModal);
+      overlay.bind("click", function (e) { if (e.target === this) closeMarkedModal(); });
+      $("#dcs-csv").bind("click", downloadCSV);
+      $("#dcs-start-over").bind("click", function () {
+        if (!confirm("Clear the entire marked-for-deletion list?")) return;
+        D.clearMarks(state);
+        saveState();
+        redrawTables();
+        openMarkedModal();
+      });
+    }
+
+    $("#dcs-marked-btn").bind("click", openMarkedModal);
+
+    redrawTables();
+  }
 });

data/public/dead_code_session.js

@@ -0,0 +1,173 @@
+// Pure logic for the dead-code review session. Loaded in the browser as
+// window.CoverbandDeadCode and in Node (tests) via require.
+(function (root, factory) {
+  if (typeof module === "object" && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CoverbandDeadCode = factory();
+  }
+})(typeof self !== "undefined" ? self : this, function () {
+  function emptyState() {
+    return { hiddenPaths: [], markedPaths: [], hideRuntimeUsed: false, startedAt: null };
+  }
+
+  function parseState(json) {
+    var raw;
+    try { raw = JSON.parse(json); } catch (e) { raw = null; }
+    var state = emptyState();
+    if (!raw || typeof raw !== "object") return state;
+    if (Object.prototype.toString.call(raw.hiddenPaths) === "[object Array]") {
+      state.hiddenPaths = raw.hiddenPaths.filter(function (p) {
+        return typeof p === "string" && p.length > 0;
+      });
+    }
+    if (Object.prototype.toString.call(raw.markedPaths) === "[object Array]") {
+      state.markedPaths = raw.markedPaths.filter(function (m) {
+        return m && typeof m.path === "string" && m.path.length > 0;
+      }).map(function (m) {
+        return {
+          path: m.path,
+          comment: typeof m.comment === "string" ? m.comment : "",
+          markedAt: typeof m.markedAt === "string" ? m.markedAt : ""
+        };
+      });
+    }
+    state.hideRuntimeUsed = raw.hideRuntimeUsed === true;
+    state.startedAt = typeof raw.startedAt === "string" ? raw.startedAt : null;
+    return state;
+  }
+
+  function pathMatches(entry, path) {
+    if (entry.charAt(entry.length - 1) === "/") return path.indexOf(entry) === 0;
+    return path === entry;
+  }
+
+  function matchesAny(entries, path) {
+    for (var i = 0; i < entries.length; i++) {
+      if (pathMatches(entries[i], path)) return true;
+    }
+    return false;
+  }
+
+  function isMarked(state, path) {
+    for (var i = 0; i < state.markedPaths.length; i++) {
+      if (pathMatches(state.markedPaths[i].path, path)) return true;
+    }
+    return false;
+  }
+
+  function isExcludedIgnoringMarks(state, path, runtimePercent) {
+    if (matchesAny(state.hiddenPaths, path)) return true;
+    if (state.hideRuntimeUsed && typeof runtimePercent === "number" && runtimePercent > 0) return true;
+    return false;
+  }
+
+  function isExcluded(state, path, runtimePercent) {
+    return isExcludedIgnoringMarks(state, path, runtimePercent) || isMarked(state, path);
+  }
+
+  function addHidden(state, entry) {
+    if (state.hiddenPaths.indexOf(entry) === -1) state.hiddenPaths.push(entry);
+  }
+
+  function removeHidden(state, entry) {
+    var i = state.hiddenPaths.indexOf(entry);
+    if (i !== -1) state.hiddenPaths.splice(i, 1);
+  }
+
+  function clearHides(state) {
+    state.hiddenPaths = [];
+    state.hideRuntimeUsed = false;
+  }
+
+  function addMark(state, path, comment, markedAt) {
+    removeMark(state, path);
+    state.markedPaths.push({ path: path, comment: comment || "", markedAt: markedAt || "" });
+  }
+
+  function removeMark(state, path) {
+    for (var i = state.markedPaths.length - 1; i >= 0; i--) {
+      if (state.markedPaths[i].path === path) state.markedPaths.splice(i, 1);
+    }
+  }
+
+  function updateComment(state, path, comment) {
+    for (var i = 0; i < state.markedPaths.length; i++) {
+      if (state.markedPaths[i].path === path) state.markedPaths[i].comment = comment;
+    }
+  }
+
+  function clearMarks(state) {
+    state.markedPaths = [];
+  }
+
+  function csvField(value) {
+    var s = String(value == null ? "" : value);
+    if (/[",\n\r]/.test(s)) return '"' + s.replace(/"/g, '""') + '"';
+    return s;
+  }
+
+  function toCSV(markedPaths) {
+    var lines = ["path,comment,marked_at"];
+    for (var i = 0; i < markedPaths.length; i++) {
+      var m = markedPaths[i];
+      lines.push([csvField(m.path), csvField(m.comment), csvField(m.markedAt)].join(","));
+    }
+    return lines.join("\r\n") + "\r\n";
+  }
+
+  function segmentPrefixes(path) {
+    var parts = path.split("/");
+    var out = [];
+    var prefix = "";
+    for (var i = 0; i < parts.length; i++) {
+      var isFile = i === parts.length - 1;
+      prefix += parts[i] + (isFile ? "" : "/");
+      out.push({ label: parts[i], prefix: prefix, isFile: isFile });
+    }
+    return out;
+  }
+
+  // Extracts the full path from a DataTables cell's rendered HTML (the
+  // title attribute on the source link), e.g. '<a title="app/foo.rb">foo.rb</a>'.
+  function extractPath(cellHtml) {
+    var m = String(cellHtml).match(/title="([^"]*)"/);
+    return m ? m[1] : "";
+  }
+
+  // Parses the runtime % column (aData[2]) of a report row into a number,
+  // or null when it isn't numeric (e.g. "-" for untracked files).
+  function rowRuntime(aData) {
+    var n = parseFloat(String(aData[2]));
+    return isNaN(n) ? null : n;
+  }
+
+  function escapeHtml(s) {
+    return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+
+  function csvFilename(date) {
+    return "coverband-dead-code-" + date.toISOString().slice(0, 10) + ".csv";
+  }
+
+  return {
+    emptyState: emptyState,
+    parseState: parseState,
+    pathMatches: pathMatches,
+    isExcluded: isExcluded,
+    isExcludedIgnoringMarks: isExcludedIgnoringMarks,
+    addHidden: addHidden,
+    removeHidden: removeHidden,
+    clearHides: clearHides,
+    addMark: addMark,
+    removeMark: removeMark,
+    updateComment: updateComment,
+    clearMarks: clearMarks,
+    toCSV: toCSV,
+    segmentPrefixes: segmentPrefixes,
+    extractPath: extractPath,
+    rowRuntime: rowRuntime,
+    escapeHtml: escapeHtml,
+    csvFilename: csvFilename
+  };
+});

data/test/benchmarks/benchmark.rake

@@ -173,14 +173,20 @@ namespace :benchmarks do
     }.pretty_print
     data = $stdout.string
     $stdout = previous_out
-    unless data.match?("Total retained:  0 bytes")
-      puts data
-      raise "leaking memory!!!"
-    end
+    assert_no_coverband_leak(data)
   ensure
     $stdout = previous_out
   end
 
+  # Check only that coverband itself retains no objects.
+  # External gems (json, redis-client) may retain strings via internal
+  # deduplication caches in newer Ruby versions — that is not a coverband leak.
+  def assert_no_coverband_leak(data)
+    return unless data.match(/retained objects by gem(.*)retained objects by file/m)&.[](0)&.match?(/coverband/)
+    puts data
+    raise "leaking memory!!!"
+  end
+
   def measure_memory_report_coverage
     require "memory_profiler"
     require "stringio"
@@ -205,16 +211,18 @@ namespace :benchmarks do
         # we clear this as this one variable is expected to retain memory and is a false positive
         ###
         Coverband::Collectors::Delta.class_variable_set(:@@previous_coverage, nil)
-        # Clear the RelativeFileConverter cache to avoid retaining strings
-        Coverband::Utils::RelativeFileConverter.reset
       end
+      # Reset file converter caches INSIDE the block but AFTER the loop.
+      # This lets GC collect the instance (and any strings allocated in it during the loop)
+      # before MemoryProfiler measures retained objects, so those strings aren't flagged.
+      # The instance was created before the block (during warmup), so its Regexp objects
+      # are invisible to MemoryProfiler even if GC defers collecting them.
+      Coverband::Utils::RelativeFileConverter.reset
+      Coverband::Utils::AbsoluteFileConverter.reset
     }.pretty_print
     data = $stdout.string
     $stdout = previous_out
-    unless data.match?("Total retained:  0 bytes")
-      puts data
-      raise "leaking memory!!!"
-    end
+    assert_no_coverband_leak(data)
   ensure
     $stdout = previous_out
   end

data/test/coverband/benchmarks/benchmark_memory_leak_check_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+require "rake"
+
+load File.expand_path("../../benchmarks/benchmark.rake", File.dirname(__FILE__)) unless respond_to?(:assert_no_coverband_leak, true)
+
+class BenchmarkMemoryLeakCheckTest < Minitest::Test
+  def test_raises_when_coverband_retains_objects
+    data = <<~REPORT
+      retained objects by gem
+      -----------------------------------
+               1  coverband
+
+      retained objects by file
+      -----------------------------------
+    REPORT
+
+    error = assert_raises(RuntimeError) { send(:assert_no_coverband_leak, data) }
+    assert_equal "leaking memory!!!", error.message
+  end
+
+  # Regression test for https://github.com/danmayer/coverband/pull/647 CI failures:
+  # newer Ruby/json versions retain a small internal string-dedup cache that is not
+  # a Coverband leak, so it must not trip the check.
+  def test_does_not_raise_when_only_external_gems_retain_memory
+    data = <<~REPORT
+      retained objects by gem
+      -----------------------------------
+               7  json-2.21.2
+               1  redis-client-0.30.1
+
+      retained objects by file
+      -----------------------------------
+    REPORT
+
+    send(:assert_no_coverband_leak, data)
+  end
+
+  def test_does_not_raise_when_nothing_retained
+    send(:assert_no_coverband_leak, "Total retained:  0 bytes (0 objects)\n")
+  end
+end

data/test/coverband/collectors/delta_test.rb

@@ -92,6 +92,23 @@ class CollectorsDeltaTest < Minitest::Test
     assert_equal({"car.rb" => [nil, 0, 2, 0]}, results)
   end
 
+  test "Coverage with oneshot_lines payload works when coverband oneshot mode is disabled" do
+    current_coverage = {
+      "car.rb" => {oneshot_lines: [2, 3]}
+    }
+    ::Coverage.expects(:line_stub).with("car.rb").returns([nil, 0, 0, 0, nil])
+    ::Coverage.expects(:peek_result).returns(current_coverage)
+    results = Coverband::Collectors::Delta.results
+    assert_equal({"car.rb" => [nil, 1, 1, 0, nil]}, results)
+
+    current_coverage = {
+      "car.rb" => {oneshot_lines: [2, 3, 4]}
+    }
+    ::Coverage.expects(:peek_result).returns(current_coverage)
+    results = Coverband::Collectors::Delta.results
+    assert_equal({"car.rb" => [nil, 0, 0, 1, nil]}, results)
+  end
+
   test "oneshot coverage calls clear" do
     Coverband.configuration.stubs(:use_oneshot_lines_coverage).returns(true)
     current_coverage = {

data/test/coverband/collectors/query_burst_tracker_test.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+
+class QueryBurstTrackerTest < Minitest::Test
+  def tracker
+    Coverband::Collectors::QueryBurstTracker.expects(:supported_version?).at_least_once.returns(true)
+    Coverband::Collectors::QueryBurstTracker.new(store: fake_store)
+  end
+
+  def tracker_key
+    tracker.send(:tracker_key)
+  end
+
+  def tracker_time_key
+    tracker.send(:tracker_time_key)
+  end
+
+  def setup
+    super
+    fake_store.raw_store.del(tracker_key)
+    fake_store.raw_store.del(tracker_time_key)
+  end
+
+  test "track key aggregates request SQL stats and threshold hits" do
+    Coverband.configuration.query_burst_query_count_threshold = 30
+    Coverband.configuration.query_burst_sql_time_threshold_ms = 100.0
+
+    subject = tracker
+    key = "controller:users#index"
+
+    subject.track_key(key: key, queries: 40, sql_time_ms: 120.5)
+    subject.track_key(key: key, queries: 10, sql_time_ms: 20.0)
+    subject.save_report
+
+    assert_equal [key], subject.used_keys.keys
+
+    stats = subject.used_key_stats[key]
+    assert_equal 2, stats["requests"]
+    assert_equal 50, stats["total_queries"]
+    assert_equal 140.5, stats["total_sql_time_ms"]
+    assert_equal 40, stats["max_queries"]
+    assert_equal 120.5, stats["max_sql_time_ms"]
+    assert_equal 1, stats["threshold_hits"]
+  end
+
+  test "as_json includes thresholds and tracked keys" do
+    subject = tracker
+    key = "job:HardWorker queue:default"
+
+    subject.track_key(key: key, queries: 3, sql_time_ms: 12.0)
+    subject.save_report
+
+    parsed = JSON.parse(subject.as_json)
+    assert_equal Coverband.configuration.query_burst_query_count_threshold, parsed.dig("thresholds", "query_count")
+    assert_equal Coverband.configuration.query_burst_sql_time_threshold_ms, parsed.dig("thresholds", "sql_time_ms")
+    assert parsed["used_keys"].key?(key)
+  end
+
+  test "clear key removes tracked query burst stats" do
+    subject = tracker
+    key = "controller:orders#show"
+
+    subject.track_key(key: key, queries: 31, sql_time_ms: 55.0)
+    subject.save_report
+    assert_equal [key], subject.used_keys.keys
+
+    subject.clear_key!(key)
+    assert_equal [], subject.used_keys.keys
+  end
+
+  protected
+
+  def fake_store
+    @fake_store ||= Coverband::Adapters::RedisStore.new(Coverband::Test.redis, redis_namespace: "coverband_test")
+  end
+end