spigot 0.2.2 → 0.3.0

data/spec/spigot/map/definition_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Spigot::Map::Definition do
-  let(:resource){Spigot::Map::Resource.new(:user)}
+  let(:resource) { Spigot::Map::Resource.new(:user) }
 
   context '#initialize' do
     it 'assigns variables' do
@@ -12,14 +12,51 @@ describe Spigot::Map::Definition do
 
     context '#with a block' do
       it 'assigns parse' do
-        subject = Spigot::Map::Definition.new(:foo, 'bar'){'baz'}
+        subject = Spigot::Map::Definition.new(:foo, 'bar') { 'baz' }
         subject.instance_variable_get(:@parse).should_not be_nil
       end
     end
   end
 
-  context '#define' do
+  context '#parse' do
+    before do
+      Spigot.define do
+        resource :active_user do
+          name :name
+        end
+      end
+    end
 
+    it 'raises invalid schema if parsing data is not a hash' do
+      subject = Spigot::Map::Definition.define(resource, :foo, ActiveUser)
+      expect {
+        subject.parse(foo: 'b')
+      }.to raise_error(Spigot::InvalidSchemaError)
+    end
+
+    it 'does not attach the sub resource' do
+      subject = Spigot::Map::Definition.define(resource, :foo, ActiveUser)
+      subject.parse(foo: { name: 'Dean' }).should eq(active_user: { name: 'Dean' })
+      subject.instance_variable_get(:@parse).should be_nil
+      subject.instance_variable_get(:@children).length.should eq(0)
+    end
+
+    context 'with children' do
+      it 'does not attach the sub resource' do
+        subject = Spigot::Map::Definition.define(resource, :foo) do
+          bar :baz
+          qux ActiveUser
+        end
+        subject.parse({
+          foo: {
+            bar: 'a', qux: { name: 'Frank' }
+          }
+        }).should eq(baz: 'a', active_user: { name: 'Frank' })
+      end
+    end
+  end
+
+  context '#define' do
     it 'returns a definition with the given key and value' do
       subject = Spigot::Map::Definition.define(resource, :foo, 'bar')
       subject.instance_variable_get(:@name).should eq(:foo)
@@ -36,10 +73,20 @@ describe Spigot::Map::Definition do
     end
 
     it 'assigns a parse block' do
-      subject = Spigot::Map::Definition.define(resource, :foo){|val| "formatted-#{val}" }
+      subject = Spigot::Map::Definition.define(resource, :foo) { |val| "formatted-#{val}" }
       subject.instance_variable_get(:@parse).should_not be_nil
       subject.instance_variable_get(:@children).length.should eq(0)
     end
   end
 
+  context '#to_hash' do
+    it 'returns a hash of values' do
+      subject = Spigot::Map::Definition.define(resource, :foo) do
+        bar :baz
+        qux :mjw
+      end
+      subject.to_hash.should eq(foo: { bar: :baz, qux: :mjw })
+    end
+  end
+
 end

data/spec/spigot/map/resource_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Spigot::Map::Resource do
-  let(:subject){Spigot::Map::Resource.new(:user){ username :login }}
+  let(:subject) { Spigot::Map::Resource.new(:user) { username :login } }
 
   context '#initialize' do
     it 'assigns a name' do
@@ -9,14 +9,14 @@ describe Spigot::Map::Resource do
     end
 
     it 'does not require a block' do
-      expect{
+      expect {
         Spigot::Map::Resource.new(:user)
       }.to_not raise_error(ArgumentError)
     end
 
     it 'builds definitions included in block' do
       Spigot::Map::Definition.should_receive(:define)
-      subject #=> Evaluate the let statement
+      subject # Evaluate the let statement
     end
   end
 
@@ -36,7 +36,7 @@ describe Spigot::Map::Resource do
   end
 
   context '.options' do
-    let(:subject){Spigot::Map::Resource.new(:user){ options{ primary_key :foo } }}
+    let(:subject) { Spigot::Map::Resource.new(:user) { options { primary_key :foo } } }
 
     it 'sets the options' do
       options = subject.instance_variable_get(:@options)

data/spec/spigot/map/service_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe Spigot::Map::Service do
-  let(:klass){ Spigot::Map::Service }
-  let(:subject){ klass.new(:github) }
+  let(:klass) { Spigot::Map::Service }
+  let(:subject) { klass.new(:github) }
 
-  before{ Spigot::Map::Base.new }
+  before { Spigot::Map::Base.new }
 
   context '#initialize' do
     it 'assigns a name' do
@@ -20,12 +20,12 @@ describe Spigot::Map::Service do
     it 'works with a block' do
       Spigot::Map::Service.should_receive(:new).with(:github)
 
-      klass.service(:github){'foo'}
+      klass.service(:github) { 'foo' }
     end
 
     it 'works without a block' do
       Spigot::Map::Service.should_receive(:new).with(:github)
-      expect{
+      expect {
         klass.service(:github)
       }.to_not raise_error(ArgumentError)
     end
@@ -36,7 +36,7 @@ describe Spigot::Map::Service do
     end
 
     context 'duplicate services' do
-      let(:service){Spigot::Map::Service.new(:github)}
+      let(:service) { Spigot::Map::Service.new(:github) }
       before do
         Spigot.config.map.update(:github, service)
       end
@@ -44,7 +44,7 @@ describe Spigot::Map::Service do
       it 'uses an existing service if already defined' do
         service.should_receive(:instance_eval)
         Spigot.config.map.should_receive(:update).with(:github, service)
-        klass.service(:github){'foo'}
+        klass.service(:github) { 'foo' }
       end
 
       it 'does not duplicate services' do
@@ -55,9 +55,9 @@ describe Spigot::Map::Service do
   end
 
   context '#extract' do
-    let(:data){{a: 1}}
+    let(:data) { { a: 1 } }
     context 'with no map defined' do
-      before{ Spigot.config.reset }
+      before { Spigot.config.reset }
       it 'returns passed params' do
         klass.extract(data).should eq(data)
       end
@@ -80,7 +80,12 @@ describe Spigot::Map::Service do
 
       it 'does not return an unmatched service' do
         Spigot::Mapping::ActiveUser.stub
-        klass.extract(twitter: data).should eq([nil, {twitter: data}])
+        klass.extract(twitter: data).should eq([nil, { twitter: data }])
+      end
+
+      it 'assumes no service when it receives an array' do
+        Spigot::Mapping::ActiveUser.stub
+        klass.extract([data, data]).should eq([nil, [data, data]])
       end
     end
   end
@@ -88,11 +93,11 @@ describe Spigot::Map::Service do
   context '.resource' do
     it 'builds a resource' do
       Spigot::Map::Resource.should_receive(:new).with(:user)
-      subject.resource(:user){'foo'}
+      subject.resource(:user) { 'foo' }
     end
 
     it 'does not require a block' do
-      expect{
+      expect {
         subject.resource(:user)
       }.to_not raise_error(ArgumentError)
     end
@@ -101,9 +106,9 @@ describe Spigot::Map::Service do
   context '.reset' do
     it 'resets the resources' do
       subject.resource(:user)
-      expect{
+      expect {
         subject.reset
-      }.to change{subject.resources.length}.by(-1)
+      }.to change { subject.resources.length }.by(-1)
     end
   end
 

data/spec/spigot/patch_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe String do
+
+  context '#underscore' do
+    let(:subject) { 'FooBar' }
+    it 'converts to underscore' do
+      subject.underscore.should eq('foo_bar')
+    end
+  end
+
+end

data/spec/spigot/proxy_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Spigot::Proxy do
 
   context '#initialize' do
-    let(:subject){Spigot::Proxy}
+    let(:subject) { Spigot::Proxy }
     it 'accepts a service and a resource' do
       proxy = subject.new(User, :github)
       proxy.resource.should eq(User)
@@ -18,61 +18,61 @@ describe Spigot::Proxy do
   end
 
   context 'Active Record aliases' do
-    let(:subject){Spigot::Proxy.new(ActiveUser)}
+    let(:subject) { Spigot::Proxy.new(ActiveUser) }
     it 'aliases find' do
       ActiveUser.should_receive(:find_by_api)
-      subject.find({a: 1})
+      subject.find(a: 1)
     end
 
     it 'aliases find_all' do
       ActiveUser.should_receive(:find_all_by_api)
-      subject.find_all({a: 1})
+      subject.find_all(a: 1)
     end
 
     it 'aliases create' do
       ActiveUser.should_receive(:create_by_api)
-      subject.create({a: 1})
+      subject.create(a: 1)
     end
 
     it 'aliases update' do
       ActiveUser.should_receive(:update_by_api)
-      subject.update({a: 1})
+      subject.update(a: 1)
     end
 
     it 'aliases find_or_create' do
       ActiveUser.should_receive(:find_or_create_by_api)
-      subject.find_or_create({a: 1})
+      subject.find_or_create(a: 1)
     end
 
     it 'aliases create_or_update' do
       ActiveUser.should_receive(:create_or_update_by_api)
-      subject.create_or_update({a: 1})
+      subject.create_or_update(a: 1)
     end
 
     context 'with a specified service' do
-      let(:subject){Spigot::Proxy.new(ActiveUser, :github)}
-      before{ Spigot::Mapping::ActiveUser.stub }
+      let(:subject) { Spigot::Proxy.new(ActiveUser, :github) }
+      before { Spigot::Mapping::ActiveUser.stub }
       it 'uses the current service' do
-        ActiveUser.should_receive(:create_by_api).with({github: {a: 1}})
-        subject.create({a: 1})
+        ActiveUser.should_receive(:create_by_api).with(github: { a: 1 })
+        subject.create(a: 1)
       end
 
       it 'checks for conflicting services' do
         Spigot::Mapping::ActiveUser.twitter
-        expect{
-          subject.create(twitter: {a: 1})
+        expect {
+          subject.create(twitter: { a: 1 })
         }.to raise_error(Spigot::InvalidServiceError)
       end
 
       it 'only scopes by one service if both are defined' do
-        ActiveUser.should_receive(:create_by_api).with({github: {a: 1}})
-        subject.create(github: {a: 1})
+        ActiveUser.should_receive(:create_by_api).with(github: { a: 1 })
+        subject.create(github: { a: 1 })
       end
     end
   end
 
   context 'instance methods' do
-    let(:subject){Spigot::Proxy.new(User, :github)}
+    let(:subject) { Spigot::Proxy.new(User, :github) }
 
     context '.translator' do
       it 'returns a translator object' do

data/spec/spigot/record_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe Spigot::Record do
-  let(:resource){User}
-  let(:data){ { a: 1 } }
-  let(:subject){ Spigot::Record.new(resource, data) }
+  let(:resource) { ActiveUser }
+  let(:data) { { username: 'dino', name: 'Dean Martin' } }
+  let(:subject) { Spigot::Record.new(:github, resource, data) }
 
   context '#instantiate' do
     it 'exectutes instantiate on an instance' do
       Spigot::Record.any_instance.should_receive(:instantiate)
-      Spigot::Record.instantiate(resource, data)
+      Spigot::Record.instantiate(:github, resource, data)
     end
   end
 
@@ -19,4 +19,75 @@ describe Spigot::Record do
     end
   end
 
+  context '#create' do
+    it 'handles an array of values' do
+      Spigot::Mapping::ActiveUser.stub
+      expect {
+        Spigot::Record.create(:github, resource, [data, data, data])
+      }.to change { ActiveUser.count }.by(3)
+    end
+
+    context 'with associations' do
+      before do
+        Spigot.define do
+          service :github do
+            resource :event do
+              id   :github_id
+              type :name
+              author ActiveUser
+            end
+          end
+        end
+      end
+
+      it 'handles an association' do
+        expect {
+          Spigot::Record.create(:github, Event, github_id: 123, name: 'Push', active_user: data)
+        }.to change { ActiveUser.count }.by(1)
+      end
+
+      it 'handles an array of associations' do
+        values = [
+          { github_id: 123, name: 'Push', active_user: data },
+          { github_id: 456, name: 'Comment', active_user: data },
+          { github_id: 789, name: 'Commit', active_user: data }]
+
+        expect {
+          Spigot::Record.create(:github, Event, values)
+        }.to change { ActiveUser.count }.by(3)
+      end
+
+      it 'handles nested associations' do
+        Spigot.config.reset
+        Spigot.define do
+          service :github do
+            resource :profile do
+              image image_url
+            end
+
+            resource :active_user do
+              full_name :name
+              login :username
+              profile Profile
+            end
+
+            resource :event do
+              id   :github_id
+              type :name
+              author ActiveUser
+            end
+          end
+        end
+
+        user_data = { username: 'dino', name: 'Dean Martin', profile: { image_url: 'abc' } }
+        event_data = { github_id: 123, name: 'Push', active_user: user_data }
+        expect {
+          Spigot::Record.create(:github, Event, event_data)
+        }.to change { Profile.count }.by(1)
+
+        Profile.last.image_url.should eq('abc')
+      end
+    end
+  end
+
 end

data/spec/spigot/spigot_spec.rb

@@ -1,24 +1,24 @@
 require 'spec_helper'
 
 describe Spigot do
-  let(:subject){Spigot}
+  let(:subject) { Spigot }
   context '#resource' do
     it 'defines a resource' do
       Spigot.should_receive(:define)
-      subject.resource(:user){'foo'}
+      subject.resource(:user) { 'foo' }
     end
   end
 
   context '#service' do
     it 'defines a service' do
       Spigot.should_receive(:define)
-      subject.service(:github){'foo'}
+      subject.service(:github) { 'foo' }
     end
 
     it 'continues a normal definition' do
       Spigot::Map::Service.any_instance.should_receive(:resource)
       subject.service(:github) do
-        resource(:user){ 'foo' }
+        resource(:user) { 'foo' }
       end
     end
   end
@@ -28,5 +28,10 @@ describe Spigot do
       Logger.should_receive(:new).with(STDOUT)
       Spigot.logger
     end
+
+    it 'sets level and formatter' do
+      Logger.should_receive(:new).and_return(mock(:level= => true, :formatter= => true))
+      Spigot.logger
+    end
   end
 end