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

click 0.1.2 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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: