hashy_db 0.0.3 → 0.0.4

data/README.md

@@ -1,6 +1,6 @@
 # What is this?
 
-Provides an inteface to store and retrieve data in a Hash.  
+Light weight ORM to persist data to a hash. 
 
 # Why would you want this?
 
@@ -13,18 +13,9 @@ Example in a rails app:
 
 initializers/datastore.rb
 
-`ruby
+`
 ::DB_HASH = {}
 `
-
-View the examples folder for an example implementation.
-
-# Todos
-
-- Make this into a gem
-- Rename *.get_one into *.find
-- Add a better readme
-
 # Contribute
 
 - fork into a topic branch, write specs, make a pull request.

data/hashy_db.gemspec

@@ -4,12 +4,12 @@ require 'hashy_db/version'
 
 Gem::Specification.new do |s|
   s.name        = "hashy_db"
-  s.version     = HashyDB::VERSION
+  s.version     = HashyDb::VERSION
   s.authors     = ["Matt Simpson", "Jason Mayer"]
   s.email       = ["matt@railsgrammer.com", "jason.mayer@gmail.com"]
-  s.homepage    = "https://github.com/coffeencoke/HashyDB"
-  s.summary     = %q{Provides an inteface to store and retrieve data in a Hash.}
-  s.description = %q{Provides an inteface to store and retrieve data in a Hash.}
+  s.homepage    = "https://github.com/asynchrony/HashyDb"
+  s.summary     = %q{Provides an interface to store and retrieve data in a Hash.}
+  s.description = %q{Provides an interface to store and retrieve data in a Hash.}
 
   s.rubyforge_project = "hashy_db"
 

data/lib/hashy_db.rb

@@ -1,2 +1 @@
-require 'hashy_db/data_store'
-require 'hashy_db/data_model'
+require 'hashy_db/data_store'

data/lib/hashy_db/data_store.rb

@@ -1,25 +1,32 @@
 # SRP: Model with implementation on how to store each collection in a data store
 require 'singleton'
 require 'active_support/core_ext/module/delegation'
+require 'digest'
 
-module HashyDB
+module HashyDb
   class DataStore
     include Singleton
 
-    attr_writer :data_store
+    def self.primary_key_identifier
+      :id
+    end
+
+    def self.generate_unique_id(salt)
+      Digest::SHA256.hexdigest("#{Time.current.utc}#{salt}")[0..6]
+    end
 
     def add(collection_name, hash)
-      get(collection_name) << hash
+      find_all(collection_name) << hash
     end
 
     def replace(collection_name, hash)
-      collection = get(collection_name)
+      collection = find_all(collection_name)
       index = collection.index{ |object| object[:id] == hash[:id] }
       collection[index] =  hash
     end
 
     def get_all_for_key_with_value(collection_name, key, value)
-      get(collection_name).select { |a| a[key] == value }
+      find_all(collection_name).select { |a| a[key] == value }
     end
 
     def get_for_key_with_value(collection_name, key, value)
@@ -27,21 +34,21 @@ module HashyDB
     end
 
     def get_by_params(collection_name, hash)
-      get(collection_name).select do |record|
+      find_all(collection_name).select do |record|
         hash.all?{|k,v| record[k] == v }
       end
     end
 
-    def get(collection_name)
+    def find_all(collection_name)
       data_store[collection_name] ||= []
     end
 
-    def get_one(collection_name, key, value)
-      get(collection_name).find { |x| x[key] == value }
+    def find(collection_name, key, value)
+      find_all(collection_name).find { |x| x[key] == value }
     end
 
     def push_to_array(collection_name, identifying_key, identifying_value, array_key, value_to_push)
-      record = get_one(collection_name, identifying_key, identifying_value)
+      record = find(collection_name, identifying_key, identifying_value)
       if (record[array_key])
         record[array_key] << value_to_push
       else
@@ -51,13 +58,13 @@ module HashyDB
     end
 
     def remove_from_array(collection_name, identifying_key, identifying_value, array_key, value_to_pop)
-      record = get_one(collection_name, identifying_key, identifying_value)
+      record = find(collection_name, identifying_key, identifying_value)
       record[array_key].reject! { |x| x == value_to_pop }
     end
 
     def containing_any(collection_name, key, values)
-      get(collection_name).select do |x|
-        result = if x[key].is_a?(Array)
+      find_all(collection_name).select do |x|
+        if x[key].is_a?(Array)
           (x[key] & values).any?
         else
           values.include?(x[key])
@@ -66,7 +73,7 @@ module HashyDB
     end
 
     def array_contains(collection_name, key, value)
-      get(collection_name).select do |x|
+      find_all(collection_name).select do |x|
         x[key] && x[key].include?(value)
       end
     end
@@ -79,6 +86,10 @@ module HashyDB
       data_store[collection_name] = data
     end
 
+    def set_data_store(hash)
+      @data_store = hash
+    end
+
     private
 
     def data_store

data/lib/hashy_db/version.rb

@@ -1,3 +1,3 @@
-module HashyDB
-  VERSION = '0.0.3'
+module HashyDb
+  VERSION = '0.0.4'
 end

data/spec/lib/data_store_spec.rb

@@ -1,40 +1,64 @@
 require_relative '../../lib/hashy_db/data_store'
 
-describe HashyDB::DataStore do
-  subject { HashyDB::DataStore.instance }
+describe HashyDb::DataStore do
+  subject { HashyDb::DataStore.instance }
 
-  let(:data1) { { id: 1, field_1: 'value 1', field_2: 3, field_3: [1,2,3], shared_between_1_and_2: 'awesome_value', :some_array => [1,2,3,4] } }
-  let(:data2) { { id: 2, field_1: 'value 1.2', field_2: 6, shared_between_1_and_2: 'awesome_value', :some_array => [4,5,6] } }
-  let(:data3) { { id: 3, field_1: 'value 3', field_2: 9, shared_between_1_and_2: 'not the same as 1 and 2', :some_array => [1,7] } }
+  let(:data1) { {id: 1, field_1: 'value 1', field_2: 3, field_3: [1, 2, 3], shared_between_1_and_2: 'awesome_value', :some_array => [1, 2, 3, 4]} }
+  let(:data2) { {id: 2, field_1: 'value 1.2', field_2: 6, shared_between_1_and_2: 'awesome_value', :some_array => [4, 5, 6]} }
+  let(:data3) { {id: 3, field_1: 'value 3', field_2: 9, shared_between_1_and_2: 'not the same as 1 and 2', :some_array => [1, 7]} }
 
   before do
-    subject.data_store = {}
+    subject.set_data_store({})
+
     subject.insert(:some_collection, [data1, data2, data3])
   end
 
+  it 'has a primary key identifier' do
+    described_class.primary_key_identifier.should == :id
+  end
+
+  describe "Generating a primary key" do
+    let(:data_model_id) { full_data_model_id[0..6] }
+    let(:full_data_model_id) { '1234567891423456789' }
+    let(:utc) { mock 'utc'}
+    let(:time) { mock 'time', :utc => utc}
+    let(:salt) { mock 'salt to ensure uniqeness' }
+
+    before do
+      Digest::SHA256.stub(:hexdigest => full_data_model_id)
+      Time.stub(:current => time)
+    end
+
+    it 'should create a reasonably unique id' do
+      Digest::SHA256.should_receive(:hexdigest).with("#{utc}#{salt}").and_return(full_data_model_id)
+
+      described_class.generate_unique_id(salt).should == data_model_id
+    end
+  end
+
   it 'can write and read data to and from a collection' do
-    data4 = { id: 3, field_1: 'value 3', field_2: 9, shared_between_1_and_2: 'not the same as 1 and 2', :some_array => [1,7] }
+    data4 = {id: 3, field_1: 'value 3', field_2: 9, shared_between_1_and_2: 'not the same as 1 and 2', :some_array => [1, 7]}
 
     subject.add(:some_collection, data4)
-    subject.get(:some_collection).should == [data1, data2, data3, data4]
+    subject.find_all(:some_collection).should == [data1, data2, data3, data4]
   end
 
   it 'can replace a record' do
     data2[:field_1] = 'value modified'
     subject.replace(:some_collection, data2)
 
-    subject.get_one(:some_collection, :id, 2)[:field_1].should == 'value modified'
+    subject.find(:some_collection, :id, 2)[:field_1].should == 'value modified'
   end
 
   it 'can get one document' do
-    subject.get_one(:some_collection, :field_1, 'value 1').should == data1
-    subject.get_one(:some_collection, :field_2, 6).should == data2
+    subject.find(:some_collection, :field_1, 'value 1').should == data1
+    subject.find(:some_collection, :field_2, 6).should == data2
   end
 
   it 'can clear the data store' do
     subject.clear
 
-    subject.get(:some_collection).should == []
+    subject.find_all(:some_collection).should == []
   end
 
   it 'can get all records of a specific key value' do
@@ -46,7 +70,7 @@ describe HashyDB::DataStore do
     subject.containing_any(:some_collection, :some_array, [7, 2, 3]).should == [data1, data3]
     subject.containing_any(:some_collection, :id, [1, 2, 5]).should == [data1, data2]
   end
-  
+
   it 'can get all records where the array includes a value' do
     subject.array_contains(:some_collection, :some_array, 1).should == [data1, data3]
     subject.array_contains(:some_collection, :some_array_2, 1).should == []
@@ -56,24 +80,24 @@ describe HashyDB::DataStore do
     subject.push_to_array(:some_collection, :id, 1, :field_3, 'add to existing array')
     subject.push_to_array(:some_collection, :id, 1, :new_field, 'add to new array')
 
-    subject.get_one(:some_collection, :id, 1)[:field_3].should include('add to existing array')
-    subject.get_one(:some_collection, :id, 1)[:new_field].should == ['add to new array']
+    subject.find(:some_collection, :id, 1)[:field_3].should include('add to existing array')
+    subject.find(:some_collection, :id, 1)[:new_field].should == ['add to new array']
   end
 
   it 'can remove a value from an array for a specific record' do
     subject.remove_from_array(:some_collection, :id, 1, :field_3, 2)
 
-    subject.get_one(:some_collection, :id, 1)[:field_3].should_not include(2)
+    subject.find(:some_collection, :id, 1)[:field_3].should_not include(2)
   end
 
   it 'can get all records that match a given set of keys and values' do
     records = subject.get_by_params(:some_collection, field_1: 'value 1', shared_between_1_and_2: 'awesome_value')
     records.size.should be(1)
     records.first[:id].should == 1
-    subject.get(:some_collection).size.should == 3
+    subject.find_all(:some_collection).size.should == 3
   end
 
   it 'can get a record for a specific key and value' do
     subject.get_for_key_with_value(:some_collection, :field_1, 'value 1').should == data1
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashy_db
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-02 00:00:00.000000000 Z
+date: 2012-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70143401652780 !ruby/object:Gem::Requirement
+  requirement: &6801620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: '3.1'
   type: :runtime
   prerelease: false
-  version_requirements: *70143401652780
+  version_requirements: *6801620
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70143401651840 !ruby/object:Gem::Requirement
+  requirement: &6800440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70143401651840
+  version_requirements: *6800440
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70143401650920 !ruby/object:Gem::Requirement
+  requirement: &6799580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,8 +44,8 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70143401650920
-description: Provides an inteface to store and retrieve data in a Hash.
+  version_requirements: *6799580
+description: Provides an interface to store and retrieve data in a Hash.
 email:
 - matt@railsgrammer.com
 - jason.mayer@gmail.com
@@ -60,19 +60,12 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- examples/guitar.rb
-- examples/guitar_document.rb
 - hashy_db.gemspec
 - lib/hashy_db.rb
-- lib/hashy_db/data_model.rb
 - lib/hashy_db/data_store.rb
 - lib/hashy_db/version.rb
-- spec/examples/guitar_document_spec.rb
-- spec/examples/guitar_spec.rb
 - spec/lib/data_store_spec.rb
-- spec/spec_helper.rb
-- spec/support/examples/data_model_examples.rb
-homepage: https://github.com/coffeencoke/HashyDB
+homepage: https://github.com/asynchrony/HashyDb
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -95,10 +88,5 @@ rubyforge_project: hashy_db
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Provides an inteface to store and retrieve data in a Hash.
-test_files:
-- spec/examples/guitar_document_spec.rb
-- spec/examples/guitar_spec.rb
-- spec/lib/data_store_spec.rb
-- spec/spec_helper.rb
-- spec/support/examples/data_model_examples.rb
+summary: Provides an interface to store and retrieve data in a Hash.
+test_files: []

data/examples/guitar.rb

@@ -1,16 +0,0 @@
-require_relative 'guitar_document'
-
-class Guitar
-  attr_reader :brand, :price, :type, :color, :id
-
-  def initialize(attrs)
-    @brand = attrs[:brand]
-    @price = attrs[:price]
-    @type = attrs[:type]
-    @color = attrs[:color]
-  end
-
-  def store
-    @id = GuitarDocument.store(self)
-  end
-end

data/examples/guitar_document.rb

@@ -1,8 +0,0 @@
-require_relative '../lib/hashy_db/data_model'
-
-class GuitarDocument
-  include HashyDB::DataModel
-
-  data_collection :guitars
-  data_fields :brand, :price, :type, :color
-end

data/lib/hashy_db/data_model.rb

@@ -1,151 +0,0 @@
-# SRP: Interface to read and write to and from the data store class for a specific collection
-
-require_relative '../hashy_db/data_store'
-
-require 'digest'
-require 'active_support/concern'
-
-module HashyDB
-  module DataModel
-    extend ActiveSupport::Concern
-
-    included do
-      attr_reader :id, :model
-    end
-
-    module ClassMethods
-      def data_fields(*fields)
-        create_data_fields(*fields) if fields.any?
-        @data_fields
-      end
-
-      def data_collection(collection_name = nil)
-        set_data_collection(collection_name) if collection_name
-        @data_collection
-      end
-
-      def store(model)
-        new(model).tap do |p|
-          p.add_to_data_store
-        end.id
-      end
-
-      def update(model)
-        new(model).tap do |p|
-          p.replace_in_data_store
-        end
-      end
-
-      def remove_from_array(id, field, value)
-        HashyDB::DataStore.instance.remove_from_array(data_collection, :id, id, field, value)
-      end
-
-      def push_to_array(id, field, value)
-        HashyDB::DataStore.instance.push_to_array(data_collection, :id, id, field, value)
-      end
-
-      def get_one(id)
-        HashyDB::DataStore.instance.get_one(data_collection, :id, id)
-      end
-
-      def by_field(field, value)
-        DataStore.instance.get_for_key_with_value(data_collection, field, value)
-      end
-
-      def all
-        HashyDB::DataStore.instance.get(data_collection)
-      end
-
-      def all_by_field(field, value)
-        HashyDB::DataStore.instance.get_all_for_key_with_value(data_collection, field, value)
-      end
-
-      def all_by_fields(hash)
-        HashyDB::DataStore.instance.get_by_params(data_collection, hash)
-      end
-
-      def find_by_fields(hash)
-        all_by_fields(hash).first
-      end
-
-      def containing_any(field, values)
-        HashyDB::DataStore.instance.containing_any(data_collection, field, values)
-      end
-
-      def array_contains(field, value)
-        HashyDB::DataStore.instance.array_contains(data_collection, field, value)
-      end
-
-      private
-
-      def set_data_collection(collection_name)
-        @data_collection = collection_name
-      end
-
-      def create_data_fields(*fields)
-        attr_accessor *fields
-        @data_fields = fields
-      end
-    end
-
-    def initialize(model)
-      @model = model
-      set_data_field_values
-      set_id
-    end
-
-    def data_fields
-      self.class.data_fields
-    end
-
-    def data_collection
-      self.class.data_collection
-    end
-
-    def add_to_data_store
-      HashyDB::DataStore.instance.add(data_collection, attributes)
-    end
-
-    def replace_in_data_store
-      HashyDB::DataStore.instance.replace(data_collection, attributes)
-    end
-
-    private
-
-    def attributes
-      { id: id }.merge(data_field_attributes)
-    end
-
-    def data_field_attributes
-      {}.tap do |hash|
-        data_fields.each do |field|
-          hash[field] = self.send(field)
-        end
-      end
-    end
-
-    def set_id
-      @id = if(model.respond_to?(:id) && model.id)
-        model.id
-      else
-        new_hash(Time.current)
-      end
-    end
-
-    def new_hash(salt)
-      Digest::SHA256.hexdigest("#{salt}#{model}")[0..6]
-    end
-
-    def set_data_field_values
-      data_fields.each { |field| set_data_field_value(field) }
-    end
-
-    def set_data_field_value(field)
-      self.send("#{field}=", model.send(field)) if field_exists?(field)
-    end
-
-    def field_exists?(field)
-      model.respond_to?(field) && !model.send(field).nil?
-    end
-  end
-end

data/spec/examples/guitar_document_spec.rb

@@ -1,17 +0,0 @@
-require_relative '../../examples/guitar_document'
-
-require_relative '../support/examples/data_model_examples'
-
-describe GuitarDocument do
-  let(:collection_name) { :guitars }
-  let(:data_field_attributes) do
-    {
-            brand: 'a brand everyone knows',
-            price: 'a price you save up for',
-            type: 'the kind you want',
-            color: 'should be your favorite'
-    }
-  end
-
-  it_behaves_like 'a data model'
-end

data/spec/examples/guitar_spec.rb

@@ -1,32 +0,0 @@
-require_relative '../../examples/guitar'
-
-describe Guitar do
-  let(:attrs) { { brand: 'Gibson', price: 3399.99, type: 'Les Paul', color: 'Mahogany' } }
-  
-  subject { described_class.new(attrs)}
-
-  its(:brand){ should == attrs[:brand] }
-  its(:price){ should == attrs[:price] }
-  its(:type){ should == attrs[:type] }
-  its(:color){ should == attrs[:color] }
-
-  describe "storing the guitar" do
-    let(:mock_id) { mock 'unique id for the guitar' }
-
-    before do
-      GuitarDocument.stub(store: mock_id)
-    end
-
-    it 'uses the guitar document to store it' do
-      GuitarDocument.should_receive(:store).with(subject).and_return(mock_id)
-
-      subject.store
-    end
-
-    it 'sets the id received from the document to the guitar so we can find it later' do
-      subject.store
-
-      subject.id.should == mock_id
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,7 +0,0 @@
-require 'rspec'
-require 'hashy_db'
-
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
-
-RSpec.configure do |config|
-end

data/spec/support/examples/data_model_examples.rb

@@ -1,157 +0,0 @@
-require 'digest'
-require_relative '../../../lib/hashy_db/data_store'
-
-shared_examples_for 'a data model' do
-  let(:mock_data_store) { mock 'data store data model' }
-
-  before do
-    HashyDB::DataStore.stub(:instance => mock_data_store)
-  end
-
-  describe "storing a data model" do
-    let(:current_time) { mock 'current time' }
-    let(:mock_data_model_string_rep) { mock 'data model string representation used for generating an id' }
-    let(:data_model_id) { full_data_model_id[0..6] }
-    let(:full_data_model_id) { '1234567891423456789' }
-    let(:mock_data_model) { mock 'a data model', data_field_attributes }
-
-    before do
-      Time.stub(:current => current_time)
-      Digest::SHA256.stub(:hexdigest => full_data_model_id)
-      mock_data_store.stub(:add)
-    end
-
-    it 'creates a unique hash for the id' do
-      Digest::SHA256.should_receive(:hexdigest).with("#{current_time}#{mock_data_model}").and_return(full_data_model_id)
-
-      described_class.store(mock_data_model)
-    end
-
-    it 'adds the data model to the db store' do
-      mock_data_store.should_receive(:add).with(collection_name, {id: data_model_id}.merge(data_field_attributes))
-
-      described_class.store(mock_data_model)
-    end
-  end
-
-  describe "updating a data model" do
-    let(:data_model_id) { '1234567' }
-    let(:mock_model) { mock 'a model', {:id => data_model_id}.merge(data_field_attributes) }
-
-    before do
-      mock_data_store.stub(:replace)
-    end
-
-    it 'replaces the data model in the db store' do
-      mock_data_store.should_receive(:replace).with(collection_name, {id: data_model_id}.merge(data_field_attributes))
-
-      described_class.update(mock_model)
-    end
-  end
-
-  describe "pushing a value to an array for a data model" do
-    let(:data_model_id) { '1234567' }
-
-    it 'replaces the data model in the db store' do
-      mock_data_store.should_receive(:push_to_array).with(collection_name, :id, data_model_id, :array_field, 'some value')
-
-      described_class.push_to_array(data_model_id, :array_field, 'some value')
-    end
-  end
-
-  describe "getting all data models with a specific value for a field" do
-    let(:mock_data_models) { mock 'data models in the data store' }
-    subject { described_class.array_contains(:some_field, 'some value') }
-
-    it 'returns the stored data models with the requested field / value' do
-      mock_data_store.should_receive(:array_contains).with(collection_name, :some_field, 'some value').and_return(mock_data_models)
-
-      subject.should == mock_data_models
-    end
-  end
-
-  describe "removing a value from an array for a data model" do
-    let(:data_model_id) { '1234567' }
-
-    it 'removes the value from the array' do
-      mock_data_store.should_receive(:remove_from_array).with(collection_name, :id, data_model_id, :array_field, 'some value')
-
-      described_class.remove_from_array(data_model_id, :array_field, 'some value')
-    end
-  end
-
-  describe 'getting all of the data models' do
-    let(:mock_data_models) { mock 'data models in the data store' }
-
-    it 'returns the stored data models' do
-      mock_data_store.should_receive(:get).with(collection_name).and_return(mock_data_models)
-
-      described_class.all.should == mock_data_models
-    end
-  end
-
-  describe "getting a data model by a specific field" do
-    let(:mock_data_model) { mock 'data model in the data store' }
-
-    it 'returns the stored data models' do
-      mock_data_store.should_receive(:get_for_key_with_value).with(collection_name, :field, 'some value').and_return(mock_data_model)
-
-      described_class.by_field(:field, 'some value').should == mock_data_model
-    end
-  end
-
-  describe "getting all the data fields by a parameter hash" do
-    let(:mock_data_models) { mock 'some data model'}
-    let(:sample_hash) { {field1: nil, field2: 'not nil' }}
-
-    it 'passes the hash to the DataStore' do
-      mock_data_store.should_receive(:get_by_params).with(collection_name, sample_hash).and_return(mock_data_models)
-      
-      described_class.all_by_fields(sample_hash).should == mock_data_models
-    end
-  end
-
-  describe "getting a record by a set of key values" do
-    let(:mock_data_model) { mock 'some data model' }
-    let(:mock_data_models) { [mock_data_model]}
-    let(:sample_hash) { {field1: nil, field2: 'not nil' }}
-
-    it 'passes the hash to the DataStore' do
-      mock_data_store.should_receive(:get_by_params).with(collection_name, sample_hash).and_return(mock_data_models)
-
-      described_class.find_by_fields(sample_hash).should == mock_data_model
-    end
-  end
-
-  describe "getting all of the data models for a where a field contains any value of a given array of values" do
-    let(:mock_data_models) { mock 'data models in the data store' }
-    subject { described_class.containing_any(:some_field, ['value 1', 'value 2']) }
-
-    it 'returns the stored data models' do
-      mock_data_store.should_receive(:containing_any).with(collection_name, :some_field, ['value 1', 'value 2']).and_return(mock_data_models)
-
-      subject.should == mock_data_models
-    end
-  end
-
-  describe "getting all data models with a specific value for a field" do
-    let(:mock_data_models) { mock 'data models in the data store' }
-    subject { described_class.all_by_field(:some_field, 'some value') }
-
-    it 'returns the stored data models with the requested field / value' do
-      mock_data_store.should_receive(:get_all_for_key_with_value).with(collection_name, :some_field, 'some value').and_return(mock_data_models)
-
-      subject.should == mock_data_models
-    end
-  end
-
-  describe 'getting a specific data model' do
-    let(:mock_data_model) { mock 'data_model', :id => 'id' }
-
-    it 'returns the data model from the data store' do
-      mock_data_store.should_receive(:get_one).with(collection_name, :id, mock_data_model.id).and_return(mock_data_model)
-
-      described_class.get_one(mock_data_model.id).should == mock_data_model
-    end
-  end
-end