RubyGems - click - Versions diffs - 0.1.2 → 0.2.0 - Mend

click 0.1.2 → 0.2.0

Files changed (17) hide show

data/.travis.yml +1 -0
data/README.md +10 -1
data/bin/click-console +3 -0
data/click.gemspec +3 -1
data/demo/app.rb +7 -0
data/lib/click/clicker.rb +2 -2
data/lib/click/database.rb +15 -5
data/lib/click/database/models/snapshot.rb +16 -1
data/lib/click/database/writer.rb +1 -5
data/lib/click/version.rb +1 -1
data/spec/clicker_spec.rb +55 -61
data/spec/database/models/object_count_spec.rb +12 -29
data/spec/database/models/session_spec.rb +11 -25
data/spec/database/models/snapshot_spec.rb +47 -69
data/spec/database/writer_spec.rb +46 -23
data/spec/spec_helper.rb +8 -9
metadata +35 -3

data/.travis.yml CHANGED

@@ -1,3 +1,4 @@
 language: ruby
 rvm:
   - 1.9.3
+script: "bundle exec rspec spec --order rand"

data/README.md CHANGED

@@ -1,6 +1,10 @@
 # Click
-TODO: Write a gem description
+[![Build Status](https://travis-ci.org/mark-rushakoff/click.png?branch=master)](https://travis-ci.org/mark-rushakoff/click)
+[![Gem Version](https://badge.fury.io/rb/click.png)](http://badge.fury.io/rb/click)
+[![Code Climate](https://codeclimate.com/github/mark-rushakoff/click.png)](https://codeclimate.com/github/mark-rushakoff/click)
+A tool to track down object leaks in a Ruby process.
 ## Installation
@@ -20,6 +24,11 @@ Or install it yourself as:
 TODO: Write usage instructions here
+## Example
+See [the demo app](demo/app.rb) for an example of a simple Sinatra app that uses an existing Sequel database and that leaks objects when connecting to a certain endpoint.
+Try running the app and then running `click-console /tmp/click_demo_memory.sqlite` to inspect the live database.
 ## Contributing
 1. Fork it

data/bin/click-console CHANGED

@@ -8,6 +8,9 @@ module Click::Database
   module Models
     default_connection_string = 'sqlite:/'
     connection_string = "#{ARGV.fetch(0, default_connection_string)}"
+    if File.file?(connection_string)
+      connection_string = [default_connection_string, File.expand_path(connection_string)].join('/')
+    end
     puts "Using connection string: #{connection_string}"
     Click.clicker_with_database('click-console', connection_string) do |clicker|

data/click.gemspec CHANGED

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = Click::VERSION
   spec.authors       = ["Mark Rushakoff"]
   spec.email         = ["mark.rushakoff@gmail.com"]
-  spec.description   = %q{A tool to help track down the source of a memory leak in a Ruby process}
+  spec.description   = %q{A tool to help track down the source of an object leak in a Ruby process}
   spec.summary       = %q{Track the changes in counts of live objects in your Ruby process.}
   spec.homepage      = "https://github.com/mark-rushakoff/click"
   spec.license       = "MIT"
@@ -21,6 +21,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "rspec-given", "~> 3.1"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "pry"

data/demo/app.rb CHANGED

@@ -42,6 +42,13 @@ get '/' do
 <html><body>
   <h1>Click demo app</h1>
   <br/>
+  <ul>
+    <li><a href="/make_objects/1">Leak 1 object</a></li>
+    <li><a href="/make_objects/10">Leak 10 objects</a></li>
+    <li><a href="/make_objects/100">Leak 100 objects</a></li>
+    <li><a href="/make_objects/1000">Leak 1000 objects</a></li>
+    <li><a href="/make_objects/10000">Leak 10000 objects</a></li>
+  </ul>
   Visited #{Visit.count} time(s) by #{Visit.group_by(:ip_address).count} IP address(es).
 </body></html>
 HTML

data/lib/click/clicker.rb CHANGED

@@ -52,9 +52,9 @@ module Click
   class << self
     def clicker_with_database(session_name, connection_string)
       require 'click/database'
-      Click::Database.with_database(connection_string) do |db|
+      Click::Database.with_database(connection_string) do
         require 'click/database/writer'
-        writer = Click::Database::Writer.new(db)
+        writer = Click::Database::Writer.new
         clicker = Click::Clicker.new(session_name)
         clicker.add_observer(writer)
         yield clicker

data/lib/click/database.rb CHANGED

@@ -16,18 +16,28 @@ module Click
         end
       end
+      def prepare(sequel_db)
+        ensure_tables!(sequel_db)
+        assign_db_to_models(sequel_db)
+        sequel_db
+      end
       private
       def _with_db(db)
-        ensure_tables!(db)
-        assign_db_to_models(db)
+        prepare(db)
         yield db
       end
       def assign_db_to_models(db)
         require 'click/database/models'
-        Click::Database::Models::Session.db = db
-        Click::Database::Models::Snapshot.db = db
-        Click::Database::Models::ObjectCount.db = db
+        assign_db(db, Click::Database::Models::Session)
+        assign_db(db, Click::Database::Models::Snapshot)
+        assign_db(db, Click::Database::Models::ObjectCount)
+      end
+      def assign_db(db, model_class)
+        # Repeatedly reassigning the DB seems to cause problems, so only assign if we need it.
+        model_class.db = db unless model_class.db == db
       end
       def ensure_tables!(db)

data/lib/click/database/models/snapshot.rb CHANGED

@@ -1,4 +1,5 @@
 require 'sequel'
+require 'set'
 module Click
   module Database
@@ -7,13 +8,27 @@ module Click
         many_to_one :session
         one_to_many :object_counts
+        def difference(earlier)
+          earlier_object_count_hash = Hash[earlier.object_counts_dataset.map([:class_name, :count])]
+          later_object_count_hash = Hash[object_counts_dataset.map([:class_name, :count])]
+          keys = Set.new(earlier_object_count_hash.keys + later_object_count_hash.keys)
+          diff = {}
+          keys.each do |key|
+            diff[key] = later_object_count_hash.fetch(key, 0) - earlier_object_count_hash.fetch(key, 0)
+          end
+          diff
+        end
         dataset_module do
           def after(time)
             filter { timestamp > time }
           end
           def before(time)
-            filter { timestamp < time}
+            filter { timestamp < time }
           end
           def by_session_name(session_name)

data/lib/click/database/writer.rb CHANGED

@@ -6,10 +6,6 @@ module Click
     class Writer
       include Click::Observer
-      def initialize(db)
-        @db = db
-      end
       def on_add(clicker)
         @session = Models::Session.create(name: clicker.session_name, started_at: Time.now)
       end
@@ -24,7 +20,7 @@ module Click
       end
       private
-      attr_reader :db, :session
+      attr_reader :session
     end
   end
 end

data/lib/click/version.rb CHANGED

@@ -1,3 +1,3 @@
 module Click
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/spec/clicker_spec.rb CHANGED

@@ -1,99 +1,93 @@
 require 'spec_helper'
 describe Click::Clicker do
-  subject(:clicker) { described_class.new('test') }
+  Given(:session_name) { SecureRandom.uuid }
+  Given(:clicker) { described_class.new(session_name) }
   describe '#session_name' do
-    it 'is the string given to the constructor' do
-      expect(clicker.session_name).to eq('test')
-    end
+    Then { clicker.session_name == session_name }
   end
   describe '#instance_count' do
-    it 'counts instances of a single class' do
-      klass = Class.new
+    Given(:klass) { Class.new }
-      clicker.click!
-      expect(clicker.instance_count(klass)).to eq(0)
+    describe 'with no instances' do
+      When { clicker.click! }
-      obj = klass.new
+      Then { clicker.instance_count(klass) == 0 }
+    end
-      clicker.click!
-      expect(clicker.instance_count(klass)).to eq(1)
+    describe 'with instances' do
+      Given!(:object) { klass.new }
-      obj = nil
+      When { clicker.click! }
-      clicker.click!
-      expect(clicker.instance_count(klass)).to eq(0)
+      Then { clicker.instance_count(klass) == 1 }
     end
-    it 'tracks differences in symbols' do
-      difference = 100
+    describe 'symbols' do
+      Given { clicker.click! }
+      Given!(:original_symbol_count) { clicker.instance_count(Symbol) }
-      expect {
-        difference.times { |i| [Time.now.to_i, i].join('_-_-_').to_sym }
-      }.to change {
-        clicker.click!
-        clicker.instance_count(Symbol)
-      }.by_at_least(difference)
+      When { 100.times { |i| [Time.now.to_i, i].join('_-_').to_sym }; clicker.click! }
+      Then { clicker.instance_count(Symbol) >= original_symbol_count + 100 }
     end
-    it 'counts BasicObjects as indeterminable' do
-      difference = 100
-      stuff = []
+    describe 'BasicObject' do
+      Given { clicker.click! }
+      Given!(:original_count) { clicker.instance_count(Click::Indeterminable) }
-      expect {
-        difference.times { |i| stuff << BasicObject.new }
-      }.to change {
-        clicker.click!
-        clicker.instance_count(Click::Indeterminable)
-      }.by_at_least(difference)
+      When { stuff = 25.times.map { BasicObject.new }; clicker.click! }
+      Then { clicker.instance_count(Click::Indeterminable) >= original_count + 25 }
     end
-    it 'counts objects that have overridden #class as indeterminable' do
-      difference = 100
-      stuff = []
-      klass = Class.new do
-        def class
-          nil
+    describe 'objects that poorly override #class' do
+      # This test was flaking out with the Given setup. *shrug*
+      before do
+        klass = Class.new do
+          def class
+            nil
+          end
         end
+        clicker.click!
+        @original_count = clicker.instance_count(Click::Indeterminable)
+        @stuff = 33.times.map { klass.new }
       end
-      expect {
-        difference.times { |i| stuff << klass.new }
-      }.to change {
-        clicker.click!
-        clicker.instance_count(Click::Indeterminable)
-      }.by_at_least(difference)
+      When { clicker.click! }
+      Then { clicker.instance_count(Click::Indeterminable) >= @original_count + 33 }
     end
   end
   describe '#object_counts' do
-    it "groups objects by their class" do
-      ObjectSpace.should_receive(:each_object).and_yield(Object.new).and_yield(":)").and_yield(":(")
-      Symbol.should_receive(:all_symbols).and_return([:foo, :bar, :baz])
-      clicker.click!
-      expect(clicker.object_counts).to be_a(Hash)
-      expect(clicker.object_counts.to_a).to eq([[Object, 1], [String, 2], [Symbol, 3]])
+    Given do
+      ObjectSpace.stub(:each_object).and_yield(Object.new).and_yield(":)").and_yield(":(")
+      Symbol.stub(:all_symbols).and_return([:foo, :bar, :baz])
     end
+    When { clicker.click! }
+    Then { clicker.object_counts == {Object => 1, String => 2, Symbol => 3} }
+    And { expect(ObjectSpace).to have_received(:each_object).with(no_args) }
+    And { expect(Symbol).to have_received(:all_symbols).with(no_args) }
   end
   describe 'observers' do
-    it 'calls #on_add' do
-      observer = double(on_add: nil)
-      observer.should_receive(:on_add).with(clicker)
+    Given(:observer) { double(on_add: nil, before_click: nil, after_click: nil) }
-      clicker.add_observer(observer)
-    end
+    When { clicker.add_observer(observer) }
+    Then { expect(observer).to have_received(:on_add).with(clicker) }
-    it 'calls #before_click and #after_click' do
-      observer = double(on_add: nil, before_click: nil, after_click: nil)
-      observer.should_receive(:before_click).with(clicker).ordered
-      observer.should_receive(:after_click).with(clicker).ordered
+    describe 'after click!' do
+      When { clicker.click! }
-      clicker.add_observer(observer)
-      clicker.click!
+      Then { expect(observer).to have_received(:before_click).with(clicker) }
+      Then { expect(observer).to have_received(:after_click).with(clicker) }
     end
   end
 end

data/spec/database/models/object_count_spec.rb CHANGED

@@ -5,40 +5,23 @@ initialize_models
 module Click::Database::Models
   describe ObjectCount do
-    describe '.scopes' do
-      describe '.by_session_name' do
-        it 'returns only object counts belonging to the session with that name' do
-          with_in_memory_db do
-            ignored_session = Session.create(name: 'ignored', started_at: Time.now)
-            ignored_snapshot = Snapshot.create(timestamp: Time.now, session_id: ignored_session.id)
-            50.times { ObjectCount.create(class_name: "Foo", count: 1, snapshot_id: ignored_snapshot.id) }
+    Given(:parent_session) { Session.create(name: SecureRandom.uuid, started_at: Time.now) }
+    Given(:parent_snapshot) { parent_session.add_snapshot(Snapshot.new(timestamp: Time.now)) }
+    Given(:object_count) { parent_snapshot.add_object_count(ObjectCount.new(class_name: SecureRandom.uuid, count: 1)) }
-            important_session = Session.create(name: 'important', started_at: Time.now)
-            important_snapshot = Snapshot.create(timestamp: Time.now, session_id: important_session.id)
-            important_object_count = ObjectCount.create(class_name: "Bar", count: 2, snapshot_id: important_snapshot.id)
+    describe 'the .by_session_name scope' do
+      Given(:dataset) { ObjectCount.by_session_name(parent_session.name) }
-            dataset = ObjectCount.by_session_name('important')
-            expect(dataset.count).to eq(1)
-            expect(dataset.map([:id, :class_name, :count])).to eq([[important_object_count.id, "Bar", 2]])
-          end
-        end
-      end
+      Then { [object_count] == dataset.all }
+    end
-      describe '.sessions' do
-        it 'returns the sessions owning the object counts' do
-          with_in_memory_db do
-            ignored_session = Session.create(name: 'ignored', started_at: Time.now)
-            ignored_snapshot = Snapshot.create(timestamp: Time.now, session_id: ignored_session.id)
-            50.times { ObjectCount.create(class_name: "Foo", count: 1, snapshot_id: ignored_snapshot.id) }
+    describe '.snapshots' do
+      Given(:other_snapshot) { parent_session.add_snapshot(Snapshot.new(timestamp: Time.now)) }
+      Given(:other_object_count) { other_snapshot.add_object_count(ObjectCount.new(class_name: SecureRandom.uuid, count: 1)) }
-            important_session = Session.create(name: 'important', started_at: Time.now)
-            important_snapshot = Snapshot.create(timestamp: Time.now, session_id: important_session.id)
-            important_object_count = ObjectCount.create(class_name: "Bar", count: 2, snapshot_id: important_snapshot.id)
+      Given(:dataset) { ObjectCount.where(id: [object_count.id, other_object_count.id]).snapshots }
-            expect(ObjectCount.where(class_name: 'Bar').snapshots.all).to eq([important_snapshot])
-          end
-        end
-      end
+      Then { expect(dataset.all).to match_array([parent_snapshot, other_snapshot])}
     end
   end
 end

data/spec/database/models/session_spec.rb CHANGED

@@ -5,36 +5,22 @@ initialize_models
 module Click::Database::Models
   describe Session do
-    describe '.scopes' do
-      describe '.by_name' do
-        it 'returns only object counts belonging to the session with that name' do
-          with_in_memory_db do
-            Session.create(name: 'ignored', started_at: Time.now)
+    Given(:session_name) { SecureRandom.uuid }
-            important_session = Session.create(name: 'important', started_at: Time.now)
+    describe 'the .by_name dataset' do
+      Given(:session) { Session.create(name: session_name, started_at: Time.now) }
-            dataset = Session.by_name('important')
-            expect(dataset.all).to eq([important_session])
-          end
-        end
-      end
-      describe '.snapshots' do
-        it 'returns all the snapshots belonging to the set of sessions' do
-          with_in_memory_db do
-            ignored_session = Session.create(name: 'ignored', started_at: Time.now)
-            50.times { ignored_session.add_snapshot(Snapshot.new(timestamp: Time.now))}
+      Then { [session] == Session.by_name(session_name).all }
+    end
-            session = Session.create(name: 'important', started_at: Time.now)
-            snapshot = session.add_snapshot(Snapshot.new(timestamp: Time.now))
+    describe 'the .snapshots dataset' do
+      Given!(:first_session) { Session.create(name: session_name, started_at: Time.now) }
+      Given!(:first_snapshot) { first_session.add_snapshot(Snapshot.new(timestamp: Time.now)) }
-            other_session = Session.create(name: 'important', started_at: Time.now)
-            other_snapshot = other_session.add_snapshot(Snapshot.new(timestamp: Time.now))
+      Given!(:other_session) { Session.create(name: session_name, started_at: Time.now) }
+      Given!(:other_snapshot) { other_session.add_snapshot(Snapshot.new(timestamp: Time.now)) }
-            expect(Session.by_name('important').snapshots.map(:id)).to match_array([snapshot.id, other_snapshot.id])
-          end
-        end
-      end
+      Then { expect(Session.by_name(session_name).snapshots.all).to match_array([first_snapshot, other_snapshot]) }
     end
   end
 end

data/spec/database/models/snapshot_spec.rb CHANGED

@@ -5,85 +5,63 @@ initialize_models
 module Click::Database::Models
   describe Snapshot do
-    let(:session_id) { Click::Database::Models::Session.create(name: "test", started_at: Time.now).id }
-    describe 'scopes' do
-      describe '.after' do
-        it 'excludes records prior to the given time' do
-          with_in_memory_db do
-            described_class.create(timestamp: Date.new(2000), session_id: session_id)
-            later = described_class.create(timestamp: Date.new(2006), session_id: session_id)
-            expect(described_class.after(Date.new(2003)).all).to eq([later])
-          end
-        end
-      end
-      describe '.before' do
-        it 'excludes records after the given time' do
-          with_in_memory_db do
-            earlier = described_class.create(timestamp: Date.new(2000), session_id: session_id)
-            described_class.create(timestamp: Date.new(2006), session_id: session_id)
-            expect(described_class.before(Date.new(2003)).all).to eq([earlier])
-          end
-        end
-      end
-      describe '.by_session_name' do
-        it 'returns only snapshots belonging to the session with that name' do
-          with_in_memory_db do
-            ignored_session = Session.create(name: 'ignored', started_at: Time.now)
-            50.times { Snapshot.create(timestamp: Time.now, session_id: ignored_session.id) }
+    Given!(:parent_session) { Session.create(name: SecureRandom.uuid, started_at: Time.now) }
+    describe 'the .before, .after scopes' do
+      Given!(:earlier) { Snapshot.create(timestamp: Date.new(2000), session_id: parent_session.id) }
+      Given!(:later) { Snapshot.create(timestamp: Date.new(2006), session_id: parent_session.id) }
+      Given(:dataset) { parent_session.snapshots_dataset }
+      Then { dataset.before(Date.new(2003)).all == [earlier] }
+      And { dataset.after(Date.new(2003)).all == [later] }
+    end
-            important_session = Session.create(name: 'important', started_at: Time.now)
-            important_snapshot = Snapshot.create(timestamp: Time.now, session_id: important_session.id)
+    describe 'the .by_session_name dataset' do
+      Given!(:snapshot) { Snapshot.create(timestamp: Time.now, session_id: parent_session.id) }
+      Given(:dataset) { Snapshot.by_session_name(parent_session.name) }
-            dataset = Snapshot.by_session_name('important')
-            expect(dataset.count).to eq(1)
-            expect(dataset.map([:id, :timestamp, :session_id])).to eq([[important_snapshot.id, important_snapshot.timestamp, important_session.id]])
-          end
-        end
-      end
+      Then { dataset.all == [snapshot] }
+    end
-      describe '.sessions' do
-        it 'returns sessions owning the current snapshots' do
-          with_in_memory_db do
-            Session.create(name: 'ignored', started_at: Time.now)
+    describe 'the .sessions dataset' do
+      Given(:other_parent_session) { Session.create(name: SecureRandom.uuid, started_at: Time.now) }
+      Given(:other_snapshot) { other_parent_session.add_snapshot(Snapshot.new(timestamp: Time.now)) }
-            important_session = Session.create(name: 'important', started_at: Time.now)
-            Snapshot.create(timestamp: Time.now, session_id: important_session.id)
+      Given(:snapshot) { parent_session.add_snapshot(Snapshot.new(timestamp: Time.now)) }
+      Given(:dataset) { Snapshot.where(id: [snapshot.id, other_snapshot.id]) }
-            expect(Snapshot.dataset.sessions.all).to eq([important_session])
-          end
-        end
-      end
+      Then { expect(dataset.sessions.all).to match_array([parent_session, other_parent_session]) }
+    end
-      describe '.object_counts' do
-        it 'returns object counts owned by the current snapshots' do
-          with_in_memory_db do
-            Session.create(name: 'ignored', started_at: Time.now).
-              add_snapshot(Snapshot.new(timestamp: Time.now)).
-              add_object_count(ObjectCount.new(class_name: 'Bar', count: 1))
+    describe '.object_counts' do
+      Given(:snapshot) { parent_session.add_snapshot(Snapshot.new(timestamp: Time.now)) }
+      Given(:class_name) { SecureRandom.uuid }
+      Given(:object_count) { snapshot.add_object_count(ObjectCount.new(class_name: class_name, count: 5)) }
+      Given(:dataset) { Snapshot.where(id: snapshot.id) }
-            session = Session.create(name: 'important', started_at: Time.now)
-            snapshot = Snapshot.create(timestamp: Time.now, session_id: session.id)
-            object_count = snapshot.add_object_count(ObjectCount.new(class_name: 'Foo', count: 5))
+      Then { [object_count] == dataset.object_counts.all }
+    end
-            expect(Snapshot.where(session_id: session.id).object_counts.all).to eq([object_count])
-          end
-        end
+    describe '#difference' do
+      Given(:first_snapshot) { Snapshot.create(timestamp: Time.now, session_id: parent_session.id) }
+      Given { first_snapshot.add_object_count(ObjectCount.new(class_name: "first_only", count: 10)) }
+      Given { first_snapshot.add_object_count(ObjectCount.new(class_name: "both", count: 1)) }
+      Given { first_snapshot.add_object_count(ObjectCount.new(class_name: "both_same", count: 2)) }
+      Given(:second_snapshot) { Snapshot.create(timestamp: Time.now, session_id: parent_session.id) }
+      Given { second_snapshot.add_object_count(ObjectCount.new(class_name: "both", count: 5)) }
+      Given { second_snapshot.add_object_count(ObjectCount.new(class_name: "both_same", count: 2)) }
+      Given { second_snapshot.add_object_count(ObjectCount.new(class_name: "second_only", count: 9)) }
+      Given(:expected_hash) do
+        {
+          "both" => 4,
+          "both_same" => 0,
+          "second_only" => 9,
+          "first_only" => -10,
+        }
       end
-      it 'can combine scopes' do
-        with_in_memory_db do
-          described_class.create(timestamp: Date.new(2000), session_id: session_id)
-          middle = described_class.create(timestamp: Date.new(2003), session_id: session_id)
-          described_class.create(timestamp: Date.new(2006), session_id: session_id)
-          expect(described_class.after(Date.new(2001)).before(Date.new(2005)).all).to eq([middle])
-        end
-      end
+      Then { second_snapshot.difference(first_snapshot) == expected_hash }
     end
   end
 end

data/spec/database/writer_spec.rb CHANGED

@@ -1,33 +1,56 @@
 require 'spec_helper'
 require 'click/database'
+require 'securerandom'
 initialize_models
 require 'click/database/writer'
-describe Click::Database::Writer do
-  it 'writes records to the database' do
-    with_in_memory_db do |db|
-      writer = Click::Database::Writer.new(db)
-      clicker = Click::Clicker.new("test")
-      expect {
-        clicker.add_observer(writer)
-      }.to change { Click::Database::Models::Session.count }.from(0).to(1)
-      expect(Click::Database::Models::Snapshot.count).to eq(0)
-      expect(Click::Database::Models::ObjectCount.count).to eq(0)
-      before_time = Time.now
-      clicker.click!
-      after_time = Time.now
-      expect(Click::Database::Models::Snapshot.count).to eq(1)
-      expect(Click::Database::Models::ObjectCount.count).to be > 0
-      snapshot = Click::Database::Models::Snapshot.first
-      expect(snapshot.object_counts.count).to eq(Click::Database::Models::ObjectCount.count)
-      expect(snapshot.timestamp).to be >= before_time
-      expect(snapshot.timestamp).to be <= after_time
+module Click::Database
+  describe Writer do
+    Given(:writer) { Writer.new }
+    Given(:session_name) { SecureRandom.uuid }
+    Given(:clicker) { Click::Clicker.new(session_name) }
+    describe 'when added to the clicker' do
+      When { clicker.add_observer(writer) }
+      Then { Models::Session.where(name: session_name).count == 1 }
+      describe 'the session' do
+        Given(:session) { Models::Session[name: session_name] }
+        Then { session.snapshots_dataset.count == 0 }
+        context 'when a click happens' do
+          Given!(:before_click_time) { Time.now }
+          When { clicker.click! }
+          Then { session.snapshots_dataset.count == 1 }
+          describe 'the created snapshot' do
+            Given(:snapshot) { session.snapshots.first }
+            Then { snapshot.object_counts_dataset.count > 0 }
+            And { snapshot.timestamp >= before_click_time }
+            And { snapshot.timestamp <= Time.now }
+          end
+          context 'and another click happens' do
+            When { clicker.click! }
+            Then { session.snapshots_dataset.count == 2 }
+            describe 'the created snapshot' do
+              Given(:snapshot) { session.snapshots.last }
+              Then { snapshot.object_counts_dataset.count > 0 }
+              And { snapshot.timestamp >= before_click_time }
+              And { snapshot.timestamp <= Time.now }
+            end
+          end
+        end
+      end
     end
   end
 end

data/spec/spec_helper.rb CHANGED

@@ -1,15 +1,14 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'click'
-def with_in_memory_db
-  Click::Database.with_in_memory_database do |db|
-    Click::Database::Models::ObjectCount.dataset.delete
-    Click::Database::Models::Snapshot.dataset.delete
-    yield db
-  end
-end
+require 'securerandom'
+require 'rspec/given'
 def initialize_models
   Click::Database.with_in_memory_database { }
 end
+RSpec.configure do |c|
+  c.before(:suite) do
+    Click::Database.prepare(Sequel.sqlite)
+  end
+end

metadata CHANGED

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: click
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
   prerelease:
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-12-04 00:00:00.000000000 Z
+date: 2013-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -59,6 +59,38 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: rspec-given
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -107,7 +139,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: A tool to help track down the source of a memory leak in a Ruby process
+description: A tool to help track down the source of an object leak in a Ruby process
 email:
 - mark.rushakoff@gmail.com
 executables: