mince 2.1.0 → 2.2.0

data/spec/integration/mince_model_spec.rb

@@ -1,5 +1,6 @@
 require 'mince'
 require 'hashy_db'
+require 'active_support/core_ext/numeric/time'
 
 describe 'A mince model integration spec' do
   subject { model_klass.new attributes }

data/spec/support/shared_examples/model_finders_example.rb

@@ -7,6 +7,34 @@ shared_examples_for 'a model using mince model finders' do
     end
   end
 
+  describe 'finding by one field' do
+    subject { klass.find_by_field(field, value) }
+
+    let(:field) { mock }
+    let(:value) { mock }
+
+    before do
+      klass.data_model.stub(:find_by_field).with(field, value).and_return(data)
+    end
+
+    context 'when a record exists' do
+      let(:data) { mock }
+      let(:model) { mock }
+
+      before do
+        klass.stub(:new).with(data).and_return(model)
+      end
+
+      it { should == model }
+    end
+
+    context 'when a record does not exist' do
+      let(:data) { nil }
+
+      it { should be_nil }
+    end
+  end
+
   describe 'getting all models' do
     subject { klass.all }
 
@@ -20,8 +48,115 @@ shared_examples_for 'a model using mince model finders' do
       klass.stub(:new).with(datum).and_return(model)
     end
 
-    it 'returns an array of all models' do
-      subject.should == models
+    it { should == models }
+  end
+
+  describe 'finding all by fields by a given hash' do
+    subject { klass.all_by_fields(hash) }
+
+    let(:hash) { mock }
+
+    before do
+      klass.data_model.stub(:all_by_fields).with(hash).and_return(data)
+    end
+
+    context 'when a record exists' do
+      let(:data) { [mock] }
+      let(:model) { mock }
+
+      before do
+        klass.stub(:new).with(data.first).and_return(model)
+      end
+
+      it { should == [model] }
+    end
+
+    context 'when a record does not exist' do
+      let(:data) { [] }
+
+      it { should be_empty }
+    end
+  end
+
+  describe 'finding all by fields by a given field value pair' do
+    subject { klass.all_by_field(field, value) }
+
+    let(:field) { mock }
+    let(:value) { mock }
+
+    before do
+      klass.data_model.stub(:all_by_field).with(field, value).and_return(data)
+    end
+
+    context 'when a record exists' do
+      let(:data) { [mock] }
+      let(:model) { mock }
+
+      before do
+        klass.stub(:new).with(data.first).and_return(model)
+      end
+
+      it { should == [model] }
+    end
+
+    context 'when a record does not exist' do
+      let(:data) { [] }
+
+      it { should be_empty }
+    end
+  end
+
+  describe 'finding by fields' do
+    subject { klass.find_by_fields(hash) }
+
+    let(:hash) { mock }
+
+    before do
+      klass.data_model.stub(:find_by_fields).with(hash).and_return(data)
+    end
+
+    context 'when a record exists' do
+      let(:data) { mock }
+      let(:model) { mock }
+
+      before do
+        klass.stub(:new).with(data).and_return(model)
+      end
+
+      it { should == model }
+    end
+
+    context 'when a record does not exist' do
+      let(:data) { nil }
+
+      it { should be_nil }
+    end
+  end
+
+  describe 'finding or initializing by fields' do
+    subject { klass.find_or_initialize_by(hash) }
+
+    let(:hash) { mock }
+
+    before do
+      klass.stub(:find_by_fields).with(hash).and_return(model)
+    end
+
+    context 'when a record exists' do
+      let(:model) { mock }
+
+      it { should == model }
+    end
+
+    context 'when a record does not exist' do
+      let(:model) { nil }
+      let(:new_model) { mock }
+
+      before do
+        klass.stub(:new).with(hash).and_return(new_model)
+      end
+
+      it { should == new_model }
     end
   end
 
@@ -42,17 +177,13 @@ shared_examples_for 'a model using mince model finders' do
         klass.stub(:new).with(data).and_return(model)
       end
 
-      it 'returns the model' do
-        subject.should == model
-      end
+      it { should == model }
     end
 
     context 'when it does not exist' do
       let(:data) { nil }
 
-      it 'returns nothing' do
-        subject.should be_nil
-      end
+      it { should be_nil }
     end
   end
 end

data/spec/units/mince/data_model/inferred_fields_spec.rb

@@ -0,0 +1,79 @@
+require_relative '../../../../lib/mince/data_model'
+
+module Mince  
+  describe DataModel do
+    subject { klass.new(model) }
+
+    let(:model) { mock fields: fields}
+    let(:fields) { [:username, :email] }
+    let(:klass) do
+      Class.new do
+        include Mince::DataModel
+
+        data_collection :users
+      end
+    end
+    let(:id) { mock }
+
+    before do
+      klass.stub(:generate_unique_id).with(model).and_return(id)
+    end
+
+    context 'when the data model is infering fields' do
+      let(:primary_key) { mock }
+      let(:interface) { mock }
+      let(:model_instance_values) { { username: 'coffeencoke' } }
+
+      before do
+        klass.stub(infer_fields?: true, interface: interface, primary_key: primary_key)
+        model.stub(instance_values: model_instance_values)
+      end
+
+      its(:infer_fields?) { should be_true }
+
+      it 'can store the model' do
+        expected_attributes = HashWithIndifferentAccess.new(model_instance_values.merge(primary_key => id))
+        interface.should_receive(:add).with(klass.data_collection, expected_attributes)
+
+        subject.create.should == id
+      end
+    end
+
+    context 'when the data model is not infering fields' do
+      before do
+        klass.stub(infer_fields?: false)
+      end
+
+      its(:infer_fields?) { should be_false }
+    end
+  end
+
+  describe DataModel, 'Class Methods:' do
+    subject { klass }
+
+    context 'when the data model is infering fields' do
+      let(:klass) do
+        Class.new do
+          include Mince::DataModel
+
+          data_collection :users
+          infer_fields_from_model
+        end
+      end
+
+      its(:infer_fields?) { should be_true }
+    end
+
+    context 'when the data model is not infering fields' do
+      let(:klass) do
+        Class.new do
+          include Mince::DataModel
+
+          data_collection :users
+        end
+      end
+
+      its(:infer_fields?) { should be_false }
+    end
+  end
+end

data/spec/units/mince/data_model/timestamps_spec.rb

@@ -0,0 +1,149 @@
+require_relative '../../../../lib/mince/data_model/timestamps'
+
+module Mince::DataModel
+  describe Timestamps, 'Mixin' do
+    let(:klass) do
+      Class.new do
+        include Mince::DataModel
+        include Timestamps
+
+        data_collection :users
+        data_fields :username, :emails
+      end
+    end
+    let(:utc_now) { mock 'now' }
+    let(:interface) { mock 'interface' }
+    let(:data_collection) { mock 'collection name' }
+    let(:id) { '1' }
+    let(:primary_key) { :id }
+
+    before do
+      Time.stub_chain('now.utc' => utc_now)
+      klass.stub(
+        interface: interface,
+        data_collection: data_collection,
+        primary_key: primary_key,
+        generate_unique_id: id
+      ) # because it's mixed in
+    end
+
+    describe 'adding a record from a hash' do
+      let(:hash_to_add) { { username: 'joe' } }
+      let(:expected_hash) do
+        HashWithIndifferentAccess.new(
+          hash_to_add.merge(
+            primary_key => id,
+            created_at: utc_now,
+            updated_at: utc_now
+          )
+        )
+      end
+
+      before do
+        interface.stub(:add).with(data_collection, expected_hash).and_return([expected_hash])
+      end
+
+      it 'sets the created and updated values' do
+        klass.add(hash_to_add).should == expected_hash
+      end
+    end
+
+    describe 'adding a record from a model' do
+      subject { klass.new(model) }
+      let(:model) { mock 'model', instance_values: instance_values }
+      let(:instance_values) { HashWithIndifferentAccess.new username: "joe", emails: ["joedawg@test.com"] }
+      let(:attributes_plus_timestamps) { instance_values.merge(created_at: utc_now, updated_at: utc_now, primary_key => id) }
+
+      before do
+        interface.stub(:add)
+      end
+
+      it 'sets the created value' do
+        subject.create
+
+        subject.attributes.should == attributes_plus_timestamps
+      end
+    end
+
+    describe 'updating a record' do
+      subject { klass.new(model) }
+      let(:model) { mock 'model', instance_values.merge(instance_values: instance_values) }
+      let(:instance_values) { HashWithIndifferentAccess.new username: "joe", emails: ["joedawg@test.com"], updated_at: 'old value', created_at: 'created time', primary_key => id }
+      let(:attributes_plus_timestamp) { instance_values.merge(updated_at: utc_now) }
+
+      before do
+        interface.stub(:replace)
+      end
+
+      it 'sets the updated value' do
+        subject.update
+
+        subject.attributes.should == attributes_plus_timestamp
+      end
+    end
+
+    describe 'updating a single field' do
+      subject { klass.new(model) }
+      let(:field_to_update) { :username }
+      let(:new_value) { mock 'new value' }
+
+      before do
+        interface.stub(:update_field_with_value).with(data_collection, id, field_to_update, new_value)
+      end
+
+      it 'sets the updated value' do
+        interface.should_receive(:update_field_with_value).with(data_collection, id, :updated_at, utc_now)
+
+        klass.update_field_with_value(id, field_to_update, new_value)
+      end
+    end
+
+    describe 'incrementing a single field' do
+      subject { klass.new(model) }
+      let(:field_to_update) { :username }
+      let(:amount) { mock :amount }
+
+      before do
+        interface.stub(:increment_field_by_amount).with(data_collection, id, field_to_update, amount)
+      end
+
+      it 'sets the updated value' do
+        interface.should_receive(:update_field_with_value).with(data_collection, id, :updated_at, utc_now)
+
+        klass.increment_field_by_amount(id, field_to_update, amount)
+      end
+    end
+
+    describe 'adding a value to an array field' do
+      subject { klass.new(model) }
+      let(:field_to_update) { :username }
+      let(:value) { mock :value }
+
+      before do
+        interface.stub(:push_to_array).with(data_collection, id, field_to_update, value)
+      end
+
+      it 'sets the updated value' do
+        interface.should_receive(:update_field_with_value).with(data_collection, id, :updated_at, utc_now)
+
+        klass.push_to_array(id, field_to_update, value)
+      end
+    end
+
+    describe 'removing a value from an array field' do
+      subject { klass.new(model) }
+      let(:field_to_update) { :username }
+      let(:value) { mock :value }
+
+      before do
+        interface.stub(:remove_from_array).with(data_collection, id, field_to_update, value)
+      end
+
+      it 'sets the updated value' do
+        interface.should_receive(:update_field_with_value).with(data_collection, id, :updated_at, utc_now)
+
+        klass.remove_from_array(id, field_to_update, value)
+      end
+    end
+  end
+end

data/spec/units/mince/data_model_spec.rb

@@ -1,7 +1,80 @@
 require_relative '../../../lib/mince/data_model'
 require 'digest'
 
-describe Mince::DataModel, 'Mixin' do
+describe Mince::DataModel do
+  let(:klass_object){ described_class.new(model) }
+
+  let(:described_class) { klass }
+  let(:klass) do
+    Class.new do
+      include Mince::DataModel
+
+      data_collection :guitars
+      data_fields :brand, :price
+      data_fields :type, :color
+    end
+  end
+
+  let(:data_collection) { :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
+  let(:model) { mock instance_values: data_field_attributes }
+
+  let(:interface) { mock 'mince data interface class', generate_unique_id: unique_id, primary_key: primary_key }
+  let(:unique_id) { mock 'id' }
+  let(:primary_key) { "custom_id" }
+
+  before do
+    Mince::Config.stub(:interface => interface)
+  end
+
+  describe 'creating' do
+    let(:attributes_with_id) { attributes.merge(primary_key => unique_id) }
+    let(:attributes) { HashWithIndifferentAccess.new data_field_attributes }
+
+    before do
+      interface.stub(:add)
+    end
+
+    it 'adds the data model to the db store' do
+      interface.should_receive(:add).with(data_collection, attributes_with_id)
+
+      klass_object.create
+    end
+
+    it 'generates a unique id' do
+      interface.should_receive(:generate_unique_id).with(model).and_return(unique_id)
+
+      klass_object.create
+    end
+
+    it 'returns the id' do
+      klass_object.create.should == unique_id
+    end
+  end
+
+  describe 'updating' do
+    let(:attributes) { HashWithIndifferentAccess.new data_field_attributes }
+
+    before do
+      data_field_attributes.merge!(primary_key => unique_id)
+    end
+
+    it 'replaces all data in the data collection with the current state of the model' do
+      interface.should_receive(:replace).with(data_collection, attributes)
+
+      klass_object.update
+    end
+  end
+end
+
+describe Mince::DataModel, 'Class Methods' do
   let(:described_class) { klass }
 
   let(:collection_name) { :guitars }
@@ -19,50 +92,67 @@ describe Mince::DataModel, 'Mixin' do
       include Mince::DataModel
 
       data_collection :guitars
-      data_fields :brand, :price, :type, :color
+      data_fields :brand, :price
+      data_fields :type, :color
     end
   end
 
   let(:interface) { mock 'mince data interface class', generate_unique_id: unique_id, primary_key: primary_key }
   let(:unique_id) { mock 'id' }
   let(:primary_key) { "custom_id" }
+  let(:fields) { [:brand, :type, :color, :price] }
 
   before do
     Mince::Config.stub(:interface => interface)
   end
 
+  it 'knows when timestamps are not included' do
+    klass.timestamps?.should be_false
+  end
+
+  it 'knows when timestamps are included' do
+    klass.send(:include, Mince::DataModel::Timestamps)
+
+    klass.timestamps?.should be_true
+  end
+
+  it 'knows the fields it has' do
+    klass.data_fields.should =~ fields
+  end
+
+  it 'does not duplicate data fields' do
+    pending
+    klass.data_fields(:brand)
+
+    klass.data_fields.should =~ fields
+  end
+
   describe "inserting data" do
-    let(:expected_hash) { data_field_attributes.merge(primary_key => unique_id) }
+    let(:expected_hash) { HashWithIndifferentAccess.new(data_field_attributes.merge(primary_key => unique_id)) }
 
     before do
-      interface.stub(:add).and_return([expected_hash])
+      interface.stub(:add).with(collection_name, expected_hash).and_return([expected_hash])
       interface.stub(:generate_unique_id).with(data_field_attributes).and_return(unique_id)
     end
 
     it 'adds the data to the db store with the generated id' do
-      interface.should_receive(:add).with(collection_name, HashWithIndifferentAccess.new(expected_hash)).and_return([expected_hash])
-
       described_class.add(data_field_attributes).should == expected_hash
     end
   end
 
   describe "storing a data model" do
-    let(:model) { mock 'a model', instance_values: data_field_attributes }
+    let(:klass_object) { mock }
+    let(:model) { mock 'a model' }
+    let(:return_value) { mock }
 
     before do
-      interface.stub(:add)
+      described_class.stub(:new).with(model).and_return(klass_object)
     end
 
-    it 'generates a unique id using the model as a salt' do
-      interface.should_receive(:generate_unique_id).with(model).and_return(unique_id)
+    it 'can create a record from a model' do
+      klass_object.should_receive(:create).and_return(return_value)
 
-      described_class.store(model)
-    end
-
-    it 'adds the data model to the db store' do
-      interface.should_receive(:add).with(collection_name, HashWithIndifferentAccess.new({primary_key => unique_id}).merge(data_field_attributes))
-
-      described_class.store(model)
+      described_class.store(model).should == return_value
     end
   end
 
@@ -89,17 +179,18 @@ describe Mince::DataModel, 'Mixin' do
   end
 
   describe "updating a data model" do
-    let(:data_model_id) { '1234567' }
-    let(:model) { mock 'a model', id: data_model_id, instance_values: data_field_attributes }
+    let(:klass_object) { mock }
+    let(:model) { mock 'a model' }
+    let(:return_value) { mock }
 
     before do
-      interface.stub(:replace)
+      described_class.stub(:new).with(model).and_return(klass_object)
     end
 
-    it 'replaces the data model in the db store' do
-      interface.should_receive(:replace).with(collection_name, HashWithIndifferentAccess.new({primary_key => data_model_id}).merge(data_field_attributes))
+    it 'can update a record for a model' do
+      klass_object.should_receive(:update).and_return(return_value)
 
-      described_class.update(model)
+      described_class.update(model).should == return_value
     end
   end
 
@@ -241,3 +332,5 @@ describe Mince::DataModel, 'Mixin' do
     end
   end
 end
+
+