active_record_openid_store 0.1.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp
+.bundle
+*.swo

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@active_record_openid_store

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in active_record_openid_store.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,49 @@
+=ActiveRecord Based OpenID Store
+
+A store is required by an OpenID server and optionally by the consumer to store associations, nonces, and auth key information across requests and processes.  If rails is distributed across several machines, they must must all have access to the same OpenID store data, so the FilesystemStore won't do. 
+
+This directory contains a plugin for connecting your OpenID enabled rails app to an ActiveRecord based OpenID store. <b>The code here is copied from the {openid-ruby library}[https://github.com/openid/ruby-openid] examples (https://github.com/openid/ruby-openid/tree/master/examples/active_record_openid_store)</b>. All I did was move some things around, add a namespace and package it all up as a rails engine/plugin, with some conveniences, for use with Rails 3.
+
+==Usage
+
+Just add it as a gem in your Gemfile
+
+<tt>gem 'active_record_openid_store'</tt>
+
+You will now have access to a rails generator to create the necessary migrations. Simply run:
+
+<tt>rails g active_record_openid_store</tt>
+
+Now that we have the migration we can create the necessary tables:
+
+<tt>rake db:migrate</tt>
+
+You should now have two extra tables, +open_id_associations+ and +open_id_nonces+.
+
+At this stage you're essentially good to go, you can create a new store like this:
+
+<tt>ActiveRecordOpenidStore::ActiveRecordStore.new</tt>
+
+You can do this anywhere in your Rails app.
+
+==What about garbage collection? 
+
+Adding the +active_record_openid_store+ gem to your Gemfile also gives you access to the <tt>openid:gc</tt> rake task. You may use this task at any time to clean up any expired nonces and associations.
+
+<tt>rake openid:gc</tt>
+
+This task isn't doing anything fancy under the hood, it simply calls the cleanup method of the active record store (i.e.: <tt>ActiveRecordOpenidStore::ActiveRecordStore.new.cleanup</tt>)
+
+==Example With Omniauth
+
+Let's say you're using omniauth[https://github.com/intridea/omniauth] and you're also using Google OpenID to authenticate your users. You want to configure Google OpenID to use the ActiveRecord OpenID store. Given that you've followed the instructions above to add the gem and create the tables, you would configure Google OpenID like this.
+
+In your <tt>config/initializers/omniauth.rb</tt>:
+
+
+  Rails.application.config.middleware.use OmniAuth::Builder do
+    provider :openid, ActiveRecordOpenidStore::ActiveRecordStore.new, :name => 'google', :identifier => 'https://www.google.com/accounts/o8/id'
+  end
+
+
+Having done this, if you go to +/auth/google+ (as per how omniauth works) you will find that your associations and nonces are being stored in the database. Sweet!

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/active_record_openid_store.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_record_openid_store/version"
+
+Gem::Specification.new do |s|
+  s.name        = "active_record_openid_store"
+  s.version     = ActiveRecordOpenidStore::VERSION
+  s.authors     = ["Alan Skorkin"]
+  s.email       = ["alan@skorks.com"]
+  s.homepage    = "https://github.com/skorks/active_record_openid_store"
+  s.summary     = %q{An Active Record-based OpenID store}
+  s.description = %q{A store is required by an OpenID server and optionally by the consumer to store associations, nonces, and auth key information across requests and processes. If rails is distributed across several machines, they must must all have access to the same OpenID store data, so the FilesystemStore won't do. The code here is copied from the openid-ruby library examples. All I did was move some things around, add a namespace and package it all up as a rails engine/plugin, with some conveniences, for use with Rails 3.}
+
+  s.rubyforge_project = "active_record_openid_store"
+
+  s.add_dependency 'ruby-openid', '~> 2.1.0'
+
+  s.add_development_dependency  'rake'
+  s.add_development_dependency  'rspec', '~> 2.5.0'
+  s.add_development_dependency  'json', '~> 1.4.3' # multi_json implementation
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/app/models/active_record_openid_store/association.rb

@@ -0,0 +1,10 @@
+require 'openid/association'
+require 'time'
+
+class ActiveRecordOpenidStore::Association < ActiveRecord::Base
+  set_table_name 'open_id_associations'
+  def from_record
+    OpenID::Association.new(handle, secret, Time.at(issued), lifetime, assoc_type)
+  end
+end
+

data/app/models/active_record_openid_store/nonce.rb

@@ -0,0 +1,3 @@
+class ActiveRecordOpenidStore::Nonce < ActiveRecord::Base
+  set_table_name 'open_id_nonces'
+end

data/lib/active_record_openid_store.rb

@@ -0,0 +1,14 @@
+require "active_record_openid_store/version"
+
+module ActiveRecordOpenidStore
+  if defined?(Rails)
+    require 'active_record_openid_store/engine' 
+  else
+    models_dir = Pathname.new(File.expand_path(File.dirname(__FILE__))).join("../app/models").to_s
+    lib_dir = File.expand_path(File.dirname(__FILE__))
+    $:.unshift(models_dir) unless $:.include?(models_dir)
+    $:.unshift(lib_dir) unless $:.include?(lib_dir)
+    require 'active_record_openid_store/active_record_store'
+  end
+end
+

data/lib/active_record_openid_store/active_record_store.rb

@@ -0,0 +1,58 @@
+require 'openid'
+require 'openid/store/interface'
+require 'active_record_openid_store/association'
+require 'active_record_openid_store/nonce'
+
+module ActiveRecordOpenidStore
+  class ActiveRecordStore < OpenID::Store::Interface
+    def store_association(server_url, assoc)
+      remove_association(server_url, assoc.handle)    
+      ActiveRecordOpenidStore::Association.create!(:server_url => server_url,
+                          :handle     => assoc.handle,
+                          :secret     => assoc.secret,
+                          :issued     => assoc.issued.to_i,
+                          :lifetime   => assoc.lifetime,
+                          :assoc_type => assoc.assoc_type)
+    end
+
+    def get_association(server_url, handle=nil)
+      assocs = if handle.blank?
+                 ActiveRecordOpenidStore::Association.find_all_by_server_url(server_url)
+               else
+                 ActiveRecordOpenidStore::Association.find_all_by_server_url_and_handle(server_url, handle)
+               end
+
+      assocs.reverse.each do |assoc|
+        a = assoc.from_record    
+        if a.expires_in == 0
+          assoc.destroy
+        else
+          return a
+        end
+      end if assocs.any?
+
+      return nil
+    end
+
+    def remove_association(server_url, handle)
+      ActiveRecordOpenidStore::Association.delete_all(['server_url = ? AND handle = ?', server_url, handle]) > 0
+    end
+
+    def use_nonce(server_url, timestamp, salt)
+      return false if ActiveRecordOpenidStore::Nonce.find_by_server_url_and_timestamp_and_salt(server_url, timestamp, salt)
+      return false if (timestamp - Time.now.to_i).abs > OpenID::Nonce.skew
+      ActiveRecordOpenidStore::Nonce.create!(:server_url => server_url, :timestamp => timestamp, :salt => salt)
+      return true
+    end
+
+    def cleanup_nonces
+      now = Time.now.to_i
+      ActiveRecordOpenidStore::Nonce.delete_all(["timestamp > ? OR timestamp < ?", now + OpenID::Nonce.skew, now - OpenID::Nonce.skew])
+    end
+
+    def cleanup_associations
+      now = Time.now.to_i
+      ActiveRecordOpenidStore::Association.delete_all(['issued + lifetime > ?',now])
+    end
+  end
+end

data/lib/active_record_openid_store/engine.rb

@@ -0,0 +1,14 @@
+require "active_record_openid_store"
+require "rails"
+
+module ActiveRecordOpenidStore
+  class Engine < Rails::Engine
+    #engine_name :active_record_openid_store
+    initializer "active_record_openid_store init" do |app|
+      require 'active_record_openid_store/active_record_store'
+    end
+    rake_tasks do
+      load "active_record_openid_store/railties/tasks.rake"
+    end
+  end
+end

data/lib/active_record_openid_store/railties/tasks.rake

@@ -0,0 +1,7 @@
+namespace :openid do
+  desc 'Garbage Collect ActiveRecord OpenID store'
+  task :gc => :environment do
+    ActiveRecordOpenidStore::ActiveRecordStore.new.cleanup
+  end
+end
+

data/lib/active_record_openid_store/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordOpenidStore
+  VERSION = "0.1.1"
+end

data/lib/generators/active_record_openid_store/USAGE

@@ -0,0 +1,6 @@
+Description:
+  Creates the two tables that are needed for an ActiveRecord based OpenID
+  store. The tables are open_id_associations, and open_id_nonces.
+
+Example:
+  rails g active_record_openid_store

data/lib/generators/active_record_openid_store/active_record_openid_store_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators'
+require 'rails/generators/migration' 
+
+class ActiveRecordOpenidStoreGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  desc "Create the tables necessary for an ActiveRecord OpenID store"
+
+  def self.source_root
+    @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+  end
+
+  def self.next_migration_number(dirname)
+    if ActiveRecord::Base.timestamped_migrations
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    else
+      "%.3d" % (current_migration_number(dirname) + 1)
+    end
+  end
+
+  def create_migration_file
+    migration_template 'migration.rb', 'db/migrate/create_active_record_openid_store_tables.rb'
+  end
+end

data/lib/generators/active_record_openid_store/templates/migration.rb

@@ -0,0 +1,27 @@
+class CreateActiveRecordOpenidStoreTables < ActiveRecord::Migration
+  def self.up
+    create_table :open_id_associations do |t|
+      t.binary :server_url, :null => false
+      t.string :handle, :null => false
+      t.binary :secret, :null => false
+      t.integer :issued, :null => false
+      t.integer :lifetime, :null => false
+      t.string :assoc_type, :null => false
+
+      t.timestamps
+    end
+
+    create_table :open_id_nonces do |t|
+      t.string :server_url, :null => false
+      t.integer :timestamp, :null => false
+      t.string :salt, :null => false
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :open_id_associations
+    drop_table :open_id_nonces
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+begin
+  require 'rubygems'
+rescue LoadError
+  nil
+end
+require 'bundler'
+Bundler.setup
+require 'rspec'
+require 'active_record_openid_store'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/test/store_test.rb

@@ -0,0 +1,212 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'test/unit'
+RAILS_ENV = "test"
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment.rb'))
+
+module StoreTestCase
+  @@allowed_handle = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
+  @@allowed_nonce = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  
+  def _gen_nonce
+    OpenID::CryptUtil.random_string(8, @@allowed_nonce)
+  end
+
+  def _gen_handle(n)
+    OpenID::CryptUtil.random_string(n, @@allowed_handle)
+  end
+
+  def _gen_secret(n, chars=nil)
+    OpenID::CryptUtil.random_string(n, chars)
+  end
+
+  def _gen_assoc(issued, lifetime=600)
+    secret = _gen_secret(20)
+    handle = _gen_handle(128)
+    OpenID::Association.new(handle, secret, Time.now + issued, lifetime,
+                            'HMAC-SHA1') 
+  end
+  
+  def _check_retrieve(url, handle=nil, expected=nil)
+    ret_assoc = @store.get_association(url, handle)
+
+    if expected.nil?
+      assert_nil(ret_assoc)
+    else
+      assert_equal(expected, ret_assoc)
+      assert_equal(expected.handle, ret_assoc.handle)
+      assert_equal(expected.secret, ret_assoc.secret)
+    end
+  end
+
+  def _check_remove(url, handle, expected)
+    present = @store.remove_association(url, handle)
+    assert_equal(expected, present)
+  end
+
+  def test_store
+    server_url = "http://www.myopenid.com/openid"
+    assoc = _gen_assoc(issued=0)
+
+    # Make sure that a missing association returns no result
+    _check_retrieve(server_url)
+
+    # Check that after storage, getting returns the same result
+    @store.store_association(server_url, assoc)
+    _check_retrieve(server_url, nil, assoc)
+
+    # more than once
+    _check_retrieve(server_url, nil, assoc)
+
+    # Storing more than once has no ill effect
+    @store.store_association(server_url, assoc)
+    _check_retrieve(server_url, nil, assoc)
+
+    # Removing an association that does not exist returns not present
+    _check_remove(server_url, assoc.handle + 'x', false)
+
+    # Removing an association that does not exist returns not present
+    _check_remove(server_url + 'x', assoc.handle, false)
+
+    # Removing an association that is present returns present
+    _check_remove(server_url, assoc.handle, true)
+
+    # but not present on subsequent calls
+    _check_remove(server_url, assoc.handle, false)
+
+    # Put assoc back in the store
+    @store.store_association(server_url, assoc)
+
+    # More recent and expires after assoc
+    assoc2 = _gen_assoc(issued=1)
+    @store.store_association(server_url, assoc2)
+
+    # After storing an association with a different handle, but the
+    # same server_url, the handle with the later expiration is returned.
+    _check_retrieve(server_url, nil, assoc2)
+
+    # We can still retrieve the older association
+    _check_retrieve(server_url, assoc.handle, assoc)
+
+    # Plus we can retrieve the association with the later expiration
+    # explicitly
+    _check_retrieve(server_url, assoc2.handle, assoc2)
+
+    # More recent, and expires earlier than assoc2 or assoc. Make sure
+    # that we're picking the one with the latest issued date and not
+    # taking into account the expiration.
+    assoc3 = _gen_assoc(issued=2, lifetime=100)
+    @store.store_association(server_url, assoc3)
+
+    _check_retrieve(server_url, nil, assoc3)
+    _check_retrieve(server_url, assoc.handle, assoc)
+    _check_retrieve(server_url, assoc2.handle, assoc2)
+    _check_retrieve(server_url, assoc3.handle, assoc3)
+
+    _check_remove(server_url, assoc2.handle, true)
+
+    _check_retrieve(server_url, nil, assoc3)
+    _check_retrieve(server_url, assoc.handle, assoc)
+    _check_retrieve(server_url, assoc2.handle, nil)
+    _check_retrieve(server_url, assoc3.handle, assoc3)
+
+    _check_remove(server_url, assoc2.handle, false)
+    _check_remove(server_url, assoc3.handle, true)
+
+    _check_retrieve(server_url, nil, assoc)
+    _check_retrieve(server_url, assoc.handle, assoc)
+    _check_retrieve(server_url, assoc2.handle, nil)
+    _check_retrieve(server_url, assoc3.handle, nil)
+
+    _check_remove(server_url, assoc2.handle, false)
+    _check_remove(server_url, assoc.handle, true)
+    _check_remove(server_url, assoc3.handle, false)
+
+    _check_retrieve(server_url, nil, nil)
+    _check_retrieve(server_url, assoc.handle, nil)
+    _check_retrieve(server_url, assoc2.handle, nil)
+    _check_retrieve(server_url, assoc3.handle, nil)
+
+    _check_remove(server_url, assoc2.handle, false)
+    _check_remove(server_url, assoc.handle, false)
+    _check_remove(server_url, assoc3.handle, false)
+
+    assocValid1 = _gen_assoc(-3600, 7200)
+    assocValid2 = _gen_assoc(-5)
+    assocExpired1 = _gen_assoc(-7200, 3600)
+    assocExpired2 = _gen_assoc(-7200, 3600)
+
+    @store.cleanup_associations
+    @store.store_association(server_url + '1', assocValid1)
+    @store.store_association(server_url + '1', assocExpired1)
+    @store.store_association(server_url + '2', assocExpired2)
+    @store.store_association(server_url + '3', assocValid2)
+
+    cleaned = @store.cleanup_associations()
+    assert_equal(2, cleaned, "cleaned up associations")
+  end
+
+  def _check_use_nonce(nonce, expected, server_url, msg='')
+    stamp, salt = OpenID::Nonce::split_nonce(nonce)
+    actual = @store.use_nonce(server_url, stamp, salt)
+    assert_equal(expected, actual, msg)
+  end
+
+  def test_nonce
+    server_url = "http://www.myopenid.com/openid"
+    [server_url, ''].each{|url|
+      nonce1 = OpenID::Nonce::mk_nonce
+
+      _check_use_nonce(nonce1, true, url, "#{url}: nonce allowed by default") 
+      _check_use_nonce(nonce1, false, url, "#{url}: nonce not allowed twice") 
+      _check_use_nonce(nonce1, false, url, "#{url}: nonce not allowed third time")
+      
+      # old nonces shouldn't pass
+      old_nonce = OpenID::Nonce::mk_nonce(3600)
+      _check_use_nonce(old_nonce, false, url, "Old nonce #{old_nonce.inspect} passed")
+
+    }
+
+    now = Time.now.to_i
+    old_nonce1 = OpenID::Nonce::mk_nonce(now - 20000)
+    old_nonce2 = OpenID::Nonce::mk_nonce(now - 10000)
+    recent_nonce = OpenID::Nonce::mk_nonce(now - 600)
+
+    orig_skew = OpenID::Nonce.skew
+    OpenID::Nonce.skew = 0
+    count = @store.cleanup_nonces
+    OpenID::Nonce.skew = 1000000
+    ts, salt = OpenID::Nonce::split_nonce(old_nonce1)
+    assert(@store.use_nonce(server_url, ts, salt), "oldnonce1")
+    ts, salt = OpenID::Nonce::split_nonce(old_nonce2)
+    assert(@store.use_nonce(server_url, ts, salt), "oldnonce2")
+    ts, salt = OpenID::Nonce::split_nonce(recent_nonce)
+    assert(@store.use_nonce(server_url, ts, salt), "recent_nonce")
+
+    
+    OpenID::Nonce.skew = 1000
+    cleaned = @store.cleanup_nonces
+    assert_equal(2, cleaned, "Cleaned #{cleaned} nonces")
+
+    OpenID::Nonce.skew = 100000
+    ts, salt = OpenID::Nonce::split_nonce(old_nonce1)
+    assert(@store.use_nonce(server_url, ts, salt), "oldnonce1 after cleanup")
+    ts, salt = OpenID::Nonce::split_nonce(old_nonce2)
+    assert(@store.use_nonce(server_url, ts, salt), "oldnonce2 after cleanup")
+    ts, salt = OpenID::Nonce::split_nonce(recent_nonce)
+    assert(!@store.use_nonce(server_url, ts, salt), "recent_nonce after cleanup")
+
+    OpenID::Nonce.skew = orig_skew
+
+  end
+end
+
+
+class TestARStore < Test::Unit::TestCase
+  include StoreTestCase
+  
+  def setup
+    @store = ActiveRecordStore.new
+  end
+
+end
+

data/todos.txt

@@ -0,0 +1,5 @@
+- make sure the store can be easily used outside of rails (e.g. try it out with sinatra)
+- do some rake tasks to create the database tables and stuff when using active record outside of rails (e.g. with sinatra)
+- make sure that requiring the active_record_openid_store outside or rails works properly
+- add some specs
+- fix up some of the code (after specs have been added)

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification 
+name: active_record_openid_store
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Alan Skorkin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-20 00:00:00 +10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-openid
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.4.3
+  type: :development
+  version_requirements: *id004
+description: A store is required by an OpenID server and optionally by the consumer to store associations, nonces, and auth key information across requests and processes. If rails is distributed across several machines, they must must all have access to the same OpenID store data, so the FilesystemStore won't do. The code here is copied from the openid-ruby library examples. All I did was move some things around, add a namespace and package it all up as a rails engine/plugin, with some conveniences, for use with Rails 3.
+email: 
+- alan@skorks.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- README.rdoc
+- Rakefile
+- active_record_openid_store.gemspec
+- app/models/active_record_openid_store/association.rb
+- app/models/active_record_openid_store/nonce.rb
+- lib/active_record_openid_store.rb
+- lib/active_record_openid_store/active_record_store.rb
+- lib/active_record_openid_store/engine.rb
+- lib/active_record_openid_store/railties/tasks.rake
+- lib/active_record_openid_store/version.rb
+- lib/generators/active_record_openid_store/USAGE
+- lib/generators/active_record_openid_store/active_record_openid_store_generator.rb
+- lib/generators/active_record_openid_store/templates/migration.rb
+- spec/spec_helper.rb
+- test/store_test.rb
+- todos.txt
+has_rdoc: true
+homepage: https://github.com/skorks/active_record_openid_store
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: active_record_openid_store
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: An Active Record-based OpenID store
+test_files: 
+- spec/spec_helper.rb
+- test/store_test.rb