spigot 0.0.1

data/spec/fixtures/mappings/mappings.rb

@@ -0,0 +1,7 @@
+module Spigot
+  module Mapping
+    def self.multiple_resources
+      User.basic.merge(Post.basic)
+    end
+  end
+end

data/spec/fixtures/mappings/post_map.rb

@@ -0,0 +1,22 @@
+module Spigot
+  module Mapping
+
+    class Post
+
+      def self.basic
+        {'post' => base}
+      end
+
+      def self.namespaced
+        {'wrapper/post' => base}
+      end
+
+      private
+
+      def self.base
+        {'title' => 'title', 'body' => 'description'}
+      end
+    end
+
+  end
+end

data/spec/fixtures/mappings/user_map.rb

@@ -0,0 +1,33 @@
+module Spigot
+  module Mapping
+
+    class User
+      def self.basic
+        {'user' => base}
+      end
+
+      def self.with_options
+        {'user' => base.merge('spigot' => options)}
+      end
+
+      def self.with_conditions
+        {'user' => base.merge('spigot' => options.merge(conditions))}
+      end
+
+      private
+
+      def self.base
+        {'full_name' => 'name', 'login' => 'username'}
+      end
+
+      def self.options
+        {'primary_key' => 'username', 'foreign_key' => 'login'}
+      end
+
+      def self.conditions
+        {'conditions' => 'username, name'}
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'rspec'
+require 'spigot'
+require 'hashie'
+require 'active_record'
+require "test/unit"
+require "mocha/setup"
+
+%w(fixtures support).each do |dir|
+  Dir[File.join(Spigot.root, "spec/#{dir}/**/*.rb")].each {|f| require f}
+end
+
+# Mocked Classes
+User = Class.new(Hashie::Mash)
+
+class ActiveUser < ActiveRecord::Base
+  include Spigot::Base
+end
+
+module Wrapper
+  Post = Class.new(Hashie::Mash)
+end
+
+def with_mapping(name, map)
+  before do
+    instance_variable_set("@prior_#{name}".to_sym, Spigot.config.translations)
+    Spigot.configure{|c| c.translations = map }
+  end
+
+  after do
+    map_cache = instance_variable_get("@prior_#{name}".to_sym)
+    Spigot.configure{|c| c.translations = map_cache }
+  end
+end
+
+RSpec.configure do |config|
+  config.after(:each) do
+    ActiveUser.delete_all
+    Spigot.config.reset
+  end
+end

data/spec/spigot/active_record_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Spigot::ActiveRecord do
+  let(:subject){ActiveUser}
+  let(:service){:github}
+  let(:data){ Spigot::ApiData.user.merge(id: '987') }
+
+  context 'with invalid mapping' do
+    with_mapping(:basic_active_user, Spigot::Mapping::ActiveUser.with_invalid_options)
+
+    context '#find_by_api' do
+      it 'requires the primary key to be accurate' do
+        expect {
+          subject.find_by_api(service, {full_name: 'Dean Martin'}).should_not be_nil
+        }.to raise_error(Spigot::InvalidSchemaError)
+      end
+    end
+  end
+
+  context 'with valid mapping' do
+    with_mapping(:active_user_with_options, Spigot::Mapping::ActiveUser.with_options)
+    let(:user){ subject.create(name: 'Dean Martin', username: 'classyasfuck') }
+
+    context '#find_by_api' do
+      before{ user }
+
+      it 'queries by the specified primary_key' do
+        subject.find_by_api(service, data).should eq(user)
+      end
+    end
+
+    context '#find_all_by_api' do
+      with_mapping(:non_unique_key, Spigot::Mapping::ActiveUser.non_unique_key)
+      before do
+        user.update_attribute(:token, '123abc')
+        subject.create(name: 'Frank Sinatra', username: 'livetilidie', token: '123abc')
+      end
+
+      it 'returns all records matching primary key' do
+        subject.find_all_by_api(service, data).length.should eq(2)
+      end
+    end
+
+    context '#create_by_api' do
+      it 'creates a record' do
+        record = subject.create_by_api(service, data)
+        record.name.should eq('Dean Martin')
+        record.username.should eq('classyasfuck')
+        record.token.should be_nil
+      end
+    end
+
+    context '#update_by_api' do
+      before{ user }
+      it 'updates a record' do
+        record = subject.update_by_api(service, data.merge(full_name: 'Dino Baby'))
+        record.name.should eq('Dino Baby')
+      end
+    end
+
+    context '#find_or_create_by_api' do
+      before{ user }
+      it 'returns an existing record' do
+        record = subject.find_or_create_by_api(service, data)
+        record.id.should eq(user.id)
+      end
+
+      it 'creates a record when none exists' do
+        record = subject.find_or_create_by_api(service, Spigot::ApiData.updated_user)
+        record.id.should_not eq(user.id)
+        record.name.should eq('Frank Sinatra')
+        record.username.should eq('livetilidie')
+      end
+    end
+
+    context '#create_or_update_by_api' do
+      before{ user }
+
+      it 'updates an existing record' do
+        record = subject.create_or_update_by_api(service, data.merge(full_name: 'Dino Baby'))
+        record.id.should eq(user.id)
+        record.name.should eq('Dino Baby')
+        record.username.should eq('classyasfuck')
+      end
+
+      it 'creates a record when none exists' do
+        record = subject.create_or_update_by_api(service, Spigot::ApiData.updated_user)
+        record.id.should_not eq(user.id)
+        record.name.should eq('Frank Sinatra')
+        record.username.should eq('livetilidie')
+      end
+    end
+  end
+
+end

data/spec/spigot/base_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Spigot::Base do
+
+  
+
+end

data/spec/spigot/configuration_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Spigot::Configuration do
+  before do
+    @prior_translations = Spigot.config.translations
+  end
+
+  after do
+    Spigot.configure{|c| c.translations = @prior_translations }
+  end
+
+  context 'defaults' do
+    it 'is a hash of default configuration' do
+      expect(Spigot::Configuration.defaults).to be_kind_of(Hash)
+    end
+  end
+
+  context 'access' do
+    before do
+      @previous_path = Spigot.config.path
+    end
+
+    after do
+      Spigot.configure{|config| config.path = @previous_path }
+    end
+
+    it "is callable from .configure" do
+      Spigot.configure do |c|
+        expect(c).to be_kind_of(Spigot::Configuration)
+      end
+    end
+
+    context 'options' do
+      let(:path){'/baller'}
+      let(:map){{'user' => {a: 1}}}
+      let(:options_key){'my_special_key'}
+
+      it "is able to set the path" do
+        Spigot.configure{|config| config.path = path }
+        expect(Spigot.config.path).to eq(path)
+      end
+
+      it "is able to set translations" do
+        Spigot.configure{|config| config.translations = map }
+        expect(Spigot.config.translations).to eq(map)
+      end
+
+      it "is able to set the options_key" do
+        Spigot.configure{|config| config.options_key = options_key }
+        expect(Spigot.config.options_key).to eq(options_key)
+      end
+
+      it "is able to set the logger" do
+        logger = Logger.new(STDOUT)
+        Spigot.configure{|config| config.logger = logger }
+        expect(Spigot.config.logger).to eq(logger)
+      end
+    end
+  end
+end

data/spec/spigot/factory_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Spigot::Record do
+
+end

data/spec/spigot/translator_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+describe Spigot::Translator do
+
+  context '#initialize' do
+    it 'requires a service' do
+      expect{
+        Spigot::Translator.new(nil, Struct)
+      }.to raise_error(Spigot::InvalidServiceError)
+    end
+
+    it 'requires a resource' do
+      expect{
+        Spigot::Translator.new(:github, nil)
+      }.to raise_error(Spigot::InvalidResourceError)
+    end
+
+    it 'accepts an instance or class resource' do
+      by_class    = Spigot::Translator.new(:github, User)
+      by_instance = Spigot::Translator.new(:github, User.new)
+      expect(by_class.resource).to eq(by_instance.resource)
+    end
+  end
+
+  context '#format' do
+    let(:subject){Spigot::Translator.new(:github, User.new, {a: '1'})}
+
+    context 'with a missing map' do
+      it 'raises error with a missing file' do
+        expect {
+          subject.format
+        }.to raise_error(Spigot::MissingServiceError)
+      end
+    end
+
+    context 'with a missing resource map' do
+      before do
+        subject.stubs(:translation_file).returns("missing:\n  foo: 'bar'")
+      end
+
+      it 'raises error with a missing resource map' do
+        expect{
+          subject.format
+        }.to raise_error(Spigot::MissingResourceError)
+      end
+    end
+
+    context 'and a valid resource map' do
+      with_mapping(:basic_user, Spigot::Mapping::User.basic)
+
+      it 'returns empty hash from nil data' do
+        expect(subject.format).to eq({})
+      end
+    end
+
+    context 'with basic user data' do
+      let(:subject){Spigot::Translator.new(:github, User.new, Spigot::ApiData.basic_user)}
+
+      context 'with a basic mapping' do
+        with_mapping(:basic_user, Spigot::Mapping::User.basic)
+
+        it 'reads one layer' do
+          expect(subject.format).to eq({'name' => 'Dean Martin', 'username' => 'classyasfuck'})
+        end
+      end
+
+      context 'with a mapping containing several resources' do
+        with_mapping(:multiple_resources, Spigot::Mapping.multiple_resources)
+
+        it 'selects the user map' do
+          expect(subject.format).to eq({'name' => 'Dean Martin', 'username' => 'classyasfuck'})
+        end
+      end
+    end
+
+    context 'with a namedspaced resource' do
+      let(:subject){Spigot::Translator.new(:github, Wrapper::Post.new, Spigot::ApiData.post)}
+      with_mapping(:namespaced_post, Spigot::Mapping::Post.namespaced)
+
+      it 'accesses the wrapper/post key' do
+        expect(subject.format).to eq({'title' => 'Regular Article', 'description' => 'dolor sit amet'})
+      end
+    end
+  end
+
+  context '#lookup' do
+    let(:subject){Spigot::Translator.new(:github, User.new, {a: '1'})}
+
+    it 'returns the value at a given key' do
+      subject.lookup(:a).should eq('1')
+    end
+  end
+
+  context '#id' do
+    let(:subject){Spigot::Translator.new(:github, User.new, {id: '123'})}
+
+    it 'returns the value at the foreign_key' do
+      subject.stubs(:foreign_key).returns('id')
+      subject.id.should eq('123')
+    end
+  end
+
+  context '#conditions' do
+    let(:subject){Spigot::Translator.new(:github, User.new, Spigot::ApiData.user)}
+    with_mapping(:user_with_conditions, Spigot::Mapping::User.with_options)
+
+    it 'should return a hash' do
+      previous_translations = Spigot.config.translations
+      Spigot.configure{|c| c.translations = Spigot::Mapping::User.with_options }
+      subject.conditions.should eq({"username"=>"classyasfuck"})
+      Spigot.configure{|c| c.translations = previous_translations }
+    end
+
+    context 'with conditions specified' do
+      with_mapping(:user_with_conditions, Spigot::Mapping::User.with_conditions)
+
+      it 'can specify the keys used in the map options' do
+        subject.conditions.should eq({"username"=>"classyasfuck", "name"=>"Dean Martin"})
+      end
+
+      it 'can specify only one key' do
+        subject.conditions.should eq({"username"=>"classyasfuck", "name"=>"Dean Martin"})
+      end
+    end
+  end
+
+  context '#options' do
+    let(:subject){Spigot::Translator.new(:github, User.new, {remote_id: '987'})}
+
+    context 'without options provided' do
+      with_mapping(:basic_user, Spigot::Mapping::User.basic)
+
+      context 'defaults' do
+        it '#primary_key is the name of the service _id' do
+          subject.primary_key.should eq('github_id')
+        end
+
+        it '#foreign_key is id' do
+          subject.foreign_key.should eq('id')
+        end
+      end
+    end
+
+    context 'with options provided' do
+      with_mapping(:user_with_options, Spigot::Mapping::User.with_options)
+
+      it 'reads the options from the spigot key' do
+        subject.options.should eq(Spigot::Mapping::User.with_options['user']['spigot'])
+      end
+
+      context '#primary_key' do
+        it 'reads a primary key from the mapping' do
+          subject.primary_key.should eq('username')
+        end
+      end
+
+      context '#foreign_key' do
+        it 'reads a foreign key from the mapping' do
+          subject.foreign_key.should eq('login')
+        end
+      end
+    end
+  end
+
+end

data/spec/support/active_record.rb

@@ -0,0 +1,15 @@
+ActiveRecord::Base.establish_connection({
+  :adapter => "sqlite3",
+  :database => ':memory:'
+})
+
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :active_users, :force => true do |t|
+    t.string :name
+    t.integer :github_id
+    t.string :username
+    t.string :token
+  end
+end