tabstabs 2.0.0

data/spec/lib/tabs_tabs/resolutions/year_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe TabsTabs::Resolutions::Year do
+  let(:timestamp){ Time.utc(2000, 2) }
+
+  context "#normalize" do
+    it "should normalize the date to year, month" do
+      expect(subject.normalize(timestamp)).to eq(timestamp.change(month: 1))
+    end
+  end
+
+  context "#serialize" do
+    it "should return YYYY" do
+      expect(subject.serialize(timestamp)).to eq("2000")
+    end
+  end
+
+  context "#deserialize" do
+    it "should convert string into date" do
+      expect(subject.deserialize("2000")).to eq(timestamp.change(month: 1))
+    end
+  end
+end

data/spec/lib/tabs_tabs/storage_spec.rb

@@ -0,0 +1,138 @@
+require "spec_helper"
+
+describe TabsTabs::Storage do
+  context "#redis" do
+    it "should return the configured Redis" do
+      expect(subject.redis).to eq(TabsTabs::Config.redis)
+    end
+  end
+
+  context "#tabs_key" do
+    after do
+      TabsTabs::Config.prefix = nil
+    end
+
+    it "should add prefix if configued" do
+      TabsTabs::Config.prefix = "myapp"
+      expect(subject.tabs_key("key")).to eq("tabstabs:myapp:key")
+    end
+
+    it "should not add prefix if not there" do
+      expect(subject.tabs_key("key")).to eq("tabstabs:key")
+    end
+  end
+
+  context "with stubbed redis" do
+
+    let(:stubbed_redis) { double("redis").as_null_object }
+
+    before do
+      allow(subject).to receive(:redis).and_return(stubbed_redis)
+      allow(subject).to receive(:tabs_key).at_least(:once).and_call_original
+    end
+
+    it "#exists calls exists with the expected key" do
+      subject.exists("foo")
+      expect(stubbed_redis).to have_received(:exists).with("tabstabs:foo")
+    end
+
+    it "#expireat calls expireat with expected key and timestamp" do
+      subject.expireat("foo", 1234)
+      expect(stubbed_redis).to have_received(:expireat).with("tabstabs:foo", 1234)
+    end
+
+    it "#ttl calls ttl with expected key" do
+      subject.ttl("foo")
+      expect(stubbed_redis).to have_received(:ttl).with("tabstabs:foo")
+    end
+
+    it "#get calls get with expected key" do
+      subject.get("foo")
+      expect(stubbed_redis).to have_received(:get).with("tabstabs:foo")
+    end
+
+    it "#mget receives prefixed keys" do
+      subject.mget("foo", "bar")
+      expect(stubbed_redis).to have_received(:mget).with("tabstabs:foo", "tabstabs:bar")
+    end
+
+    it "#set calls set with the expected key and arg" do
+      subject.set("foo", "bar")
+      expect(stubbed_redis).to have_received(:set).with("tabstabs:foo", "bar")
+    end
+
+    it "#del" do
+      subject.del("foo")
+      expect(stubbed_redis).to have_received(:del).with("tabstabs:foo")
+    end
+
+    it "#del_by_prefix" do
+      allow(stubbed_redis).to receive(:keys).and_return(["foo:a", "foo:b"])
+      subject.del_by_prefix("foo")
+      expect(stubbed_redis).to have_received(:del).with("foo:a", "foo:b")
+    end
+
+    it "#incr" do
+      subject.incr("foo")
+      expect(stubbed_redis).to have_received(:incr).with("tabstabs:foo")
+    end
+
+    it "#rpush" do
+      subject.rpush("foo", "bar")
+      expect(stubbed_redis).to have_received(:rpush).with("tabstabs:foo", "bar")
+    end
+
+    it "#sadd" do
+      subject.sadd("foo", "bar", "baz")
+      expect(stubbed_redis).to have_received(:sadd).with("tabstabs:foo", "bar", "baz")
+    end
+
+    it "#smembers" do
+      subject.smembers("foo")
+      expect(stubbed_redis).to have_received(:smembers).with("tabstabs:foo")
+    end
+
+    it "#smembers_all" do
+      allow(stubbed_redis).to receive(:pipelined).and_yield
+      subject.smembers_all("foo", "bar")
+      expect(stubbed_redis).to have_received(:smembers).with("tabstabs:foo")
+      expect(stubbed_redis).to have_received(:smembers).with("tabstabs:bar")
+    end
+
+    it "#sismember" do
+      subject.sismember("foo", "bar")
+      expect(stubbed_redis).to have_received(:sismember).with("tabstabs:foo", "bar")
+    end
+
+    it "#hget" do
+      subject.hget("foo", "bar")
+      expect(stubbed_redis).to have_received(:hget).with("tabstabs:foo", "bar")
+    end
+
+    it "#hset" do
+      subject.hset("foo", "bar", "baz")
+      expect(stubbed_redis).to have_received(:hset).with("tabstabs:foo", "bar", "baz")
+    end
+
+    it "#hdel" do
+      subject.hdel("foo", "bar")
+      expect(stubbed_redis).to have_received(:hdel).with("tabstabs:foo", "bar")
+    end
+
+    it "#hkeys" do
+      subject.hkeys("foo")
+      expect(stubbed_redis).to have_received(:hkeys).with("tabstabs:foo")
+    end
+
+    it "#hincrby" do
+      subject.hincrby("foo", "bar", 42)
+      expect(stubbed_redis).to have_received(:hincrby).with("tabstabs:foo", "bar", 42)
+    end
+
+    it "#hgetall" do
+      subject.hgetall("foo")
+      expect(stubbed_redis).to have_received(:hgetall).with("tabstabs:foo")
+    end
+
+  end
+end

data/spec/lib/tabs_tabs_spec.rb

@@ -0,0 +1,223 @@
+require "spec_helper"
+
+describe TabsTabs do
+  include TabsTabs::Storage
+
+  describe ".create_metric" do
+
+    it "raises an error if the type is invalid" do
+      expect { TabsTabs.create_metric("foo", "foobar") }.to raise_error(TabsTabs::UnknownTypeError)
+    end
+
+    it "raises an error if the metric already exists" do
+      TabsTabs.create_metric("foo", "counter")
+      expect { TabsTabs.create_metric("foo", "counter") }.to raise_error(TabsTabs::DuplicateMetricError)
+    end
+
+    it "returns a Counter metric if 'counter' was the specified type" do
+      expect(TabsTabs.create_metric("foo", "counter")).to be_a_kind_of(TabsTabs::Metrics::Counter)
+    end
+
+    it "returns a Value metric if 'value' was the specified type" do
+      expect(TabsTabs.create_metric("foo", "value")).to be_a_kind_of(TabsTabs::Metrics::Value)
+    end
+
+    it "adds the metric's key to the list_metrics" do
+      TabsTabs.create_metric("foo", "value")
+      TabsTabs.create_metric("bar", "counter")
+      TabsTabs.create_metric("baz", "task")
+      expect(TabsTabs.list_metrics).to include("foo")
+      expect(TabsTabs.list_metrics).to include("bar")
+      expect(TabsTabs.list_metrics).to include("baz")
+    end
+
+  end
+
+  describe ".counter_total" do
+
+    it "returns the total for a counter metric" do
+      TabsTabs.increment_counter("foo")
+      expect(TabsTabs.counter_total("foo")).to eq 1
+    end
+
+    it "returns the value of the block if given and the metric doesn't exist" do
+      expect(TabsTabs.counter_total("foo") { 42 }).to eq 42
+    end
+
+    it "raises an UnknownMetricError if no block is given and the metric does not exist" do
+      expect { TabsTabs.counter_total("foo") }.to raise_error TabsTabs::UnknownMetricError
+    end
+
+  end
+
+  describe ".get_metric" do
+
+    it "returns the expected metric object" do
+      TabsTabs.create_metric("foo", "counter")
+      expect(TabsTabs.get_metric("foo")).to be_a_kind_of(TabsTabs::Metrics::Counter)
+    end
+
+  end
+
+  describe ".list_metrics" do
+
+    it "returns the list_metrics of metric names" do
+      TabsTabs.create_metric("foo", "counter")
+      TabsTabs.create_metric("bar", "value")
+      expect(TabsTabs.list_metrics).to eq(["foo", "bar"])
+    end
+
+  end
+
+  describe ".metric_exists?" do
+
+    it "returns true if the metric exists" do
+      TabsTabs.create_metric("foo", "counter")
+      expect(TabsTabs.metric_exists?("foo")).to be_truthy
+    end
+
+    it "returns false if the metric does not exist" do
+      expect(TabsTabs.metric_exists?("foo")).to be_falsey
+    end
+
+  end
+
+  describe ".drop_metric" do
+
+    before do
+      TabsTabs.create_metric("foo", "counter")
+    end
+
+    it "removes the metric from the list_metrics" do
+      TabsTabs.drop_metric!("foo")
+      expect(TabsTabs.list_metrics).to_not include("foo")
+    end
+
+    it "results in metric_exists? returning false" do
+      TabsTabs.drop_metric!("foo")
+      expect(TabsTabs.metric_exists?("foo")).to be_falsey
+    end
+
+    it "calls drop! on the metric" do
+      metric = double(:metric)
+      allow(TabsTabs).to receive(:get_metric).and_return(metric)
+      expect(metric).to receive(:drop!)
+      TabsTabs.drop_metric!("foo")
+    end
+
+  end
+
+  describe ".drop_all_metrics" do
+
+    it "drops all metrics" do
+      TabsTabs.create_metric("foo", "counter")
+      TabsTabs.create_metric("bar", "value")
+      TabsTabs.drop_all_metrics!
+      expect(TabsTabs.metric_exists?("foo")).to be_falsey
+      expect(TabsTabs.metric_exists?("bar")).to be_falsey
+    end
+
+  end
+
+  describe ".increment_counter" do
+
+    it "raises a Tabs::MetricTypeMismatchError if the metric is the wrong type" do
+      TabsTabs.create_metric("foo", "value")
+      expect { TabsTabs.increment_counter("foo") }.to raise_error(TabsTabs::MetricTypeMismatchError)
+    end
+
+    it "creates the metric if it doesn't exist" do
+      expect(TabsTabs.metric_exists?("foo")).to be_falsey
+      expect { TabsTabs.increment_counter("foo") }.to_not raise_error
+      expect(TabsTabs.metric_exists?("foo")).to be_truthy
+    end
+
+    it "calls increment on the metric" do
+      metric = TabsTabs.create_metric("foo", "counter")
+      allow(TabsTabs).to receive(:get_metric).and_return(metric)
+      expect(metric).to receive(:increment)
+      TabsTabs.increment_counter("foo")
+    end
+
+  end
+
+  describe ".record_value" do
+
+    it "creates the metric if it doesn't exist" do
+      expect(TabsTabs.metric_exists?("foo")).to be_falsey
+      expect { TabsTabs.record_value("foo", 38) }.not_to raise_error
+      expect(TabsTabs.metric_exists?("foo")).to be_truthy
+    end
+
+    it "raises a Tabs::MetricTypeMismatchError if the metric is the wrong type" do
+      TabsTabs.create_metric("foo", "counter")
+      expect { TabsTabs.record_value("foo", 27) }.to raise_error(TabsTabs::MetricTypeMismatchError)
+    end
+
+    it "calls record on the metric" do
+      Timecop.freeze(Time.now.utc)
+      metric = TabsTabs.create_metric("foo", "value")
+      allow(TabsTabs).to receive(:get_metric).and_return(metric)
+      allow(metric).to receive(:record).with(42, Time.now.utc)
+      TabsTabs.record_value("foo", 42)
+    end
+
+  end
+
+  describe ".list_metrics" do
+
+    it "lists all metrics that are defined" do
+      TabsTabs.create_metric("foo", "counter")
+      TabsTabs.create_metric("bar", "counter")
+      TabsTabs.create_metric("baz", "counter")
+      expect(TabsTabs.list_metrics).to eq(["foo", "bar", "baz"])
+    end
+
+  end
+
+  describe ".metric_type" do
+
+    it "returns the type of a counter metric" do
+      TabsTabs.create_metric("foo", "counter")
+      expect(TabsTabs.metric_type("foo")).to eq("counter")
+    end
+
+    it "returns the type of a value metric" do
+      TabsTabs.create_metric("bar", "value")
+      expect(TabsTabs.metric_type("bar")).to eq("value")
+    end
+
+    it "returns the type of a task metric" do
+      TabsTabs.create_metric("baz", "task")
+      expect(TabsTabs.metric_type("baz")).to eq("task")
+    end
+
+  end
+
+  describe ".drop_resolution_for_metric!" do
+    it "raises unknown metric error if metric does not exist" do
+      expect{ TabsTabs.drop_resolution_for_metric!(:invalid, :minute) }.to raise_error(TabsTabs::UnknownMetricError)
+    end
+
+    it "raises resolution missing error if resolution not registered" do
+      TabsTabs.create_metric("baz", "value")
+      expect{ TabsTabs.drop_resolution_for_metric!("baz", :invalid) }.to raise_error(TabsTabs::ResolutionMissingError)
+    end
+
+    it "does not allow you to call drop_by_resolution if task metric" do
+      metric = TabsTabs.create_metric("baz", "task")
+      expect(metric).not_to receive(:drop_by_resolution!)
+      TabsTabs.drop_resolution_for_metric!("baz", :minute)
+    end
+
+    it "drops the metric by resolution" do
+      now = Time.utc(2000,1,1)
+      metric = TabsTabs.create_metric("baz", "value")
+      metric.record(42, now)
+      TabsTabs.drop_resolution_for_metric!("baz", :minute)
+      minute_key = TabsTabs::Metrics::Value.new("baz").storage_key(:minute, now)
+      expect(TabsTabs::Storage.exists(minute_key)).to be_falsey
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require "rubygems"
+require "tabs_tabs"
+require "pry"
+require "timecop"
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.before(:each) do
+  	TabsTabs::Resolution.reset_default_resolutions
+    TabsTabs::Storage.del_by_prefix("")
+  end
+
+  config.after(:each) do
+    Timecop.return
+  end
+end

data/spec/support/custom_resolutions.rb

@@ -0,0 +1,40 @@
+module BadlyFormedResolution
+  include TabsTabs::Resolutionable
+  extend self
+end
+
+module WellFormedResolution
+  include TabsTabs::Resolutionable
+  extend self
+
+  PATTERN = "%Y-%m-%d-%H-%M-%S"
+
+  def name
+    :seconds
+  end
+
+  def serialize(timestamp)
+    timestamp.strftime(PATTERN)
+  end
+
+  def deserialize(str)
+    dt = DateTime.strptime(str, PATTERN)
+    self.normalize(dt)
+  end
+
+  def from_seconds(s)
+    s / 1
+  end
+
+  def to_seconds
+    1
+  end
+
+  def add(ts, num)
+    ts + num.seconds
+  end
+
+  def normalize(ts)
+    Time.utc(ts.year, ts.month, ts.day, ts.hour, ts.min, ts.sec)
+  end
+end

data/tabs_tabs.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tabs_tabs/version'
+
+Gem::Specification.new do |gem|
+
+  gem.name          = "tabstabs"
+  gem.version       = TabsTabs::VERSION
+  gem.authors       = ["Max Kießling", "Michael Prilop", "JC Grubbs"]
+  gem.email         = ['max@kopfueber.org', 'michael.prilop@imw.fraunhofer.de']
+  gem.description   = %q{A redis-backed metrics tracker for keeping tabstabs on pretty much anything. Fork of Tabs}
+  gem.summary       = %q{A redis-backed metrics tracker for keeping tabstabs on pretty much anything ;)}
+  gem.homepage      = "https://github.com/FHG-IMW/tabstabs"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "activesupport", ">= 3.2"
+  gem.add_dependency "redis", ">= 3.0.0"
+
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "pry-nav"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "timecop"
+
+end