remote_factory_girl 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 013ff8da4195f0fdd96f42fed7e582768da3979f
+  data.tar.gz: b2604a88f6b432b72b50117f9206eff9a45fa0c4
+SHA512:
+  metadata.gz: 6224e0239b03dec31d06efa4835937c4539724057926e00c11e4d76070741e5000b1ad93aea9c5f6dd8feed895ea6b9cf6797fe6fa5aac080201bb83956aaf7d
+  data.tar.gz: ae06c058feccd7413e09d419a3f73222170d10c482ac9e212fde5daf63fbfd07b934274710ae510707aa899fca4e1bac2c6fd38018489fd4dd581b7a058aaac2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--default_path spec

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gem 'dish' # converts hash to objects with dot syntax
+gem 'virtus', '~> 1.0' # defining attributes on a model: strong typing like objects and defaults
+gem 'rest-client' # http
+
+
+# Specify your gem's dependencies in remote_factory_girl.gemspec
+gemspec
+
+gem 'rspec'
+gem 'pry'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 tdouce
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,21 @@
+# RemoteFactoryGirl
+
+[factory_girl](https://github.com/thoughtbot/factory_girl) for [Software Oriented Architecture](http://en.wikipedia.org/wiki/Service-oriented_architecture) (SOA). Create [factory_girl](https://github.com/thoughtbot/factory_girl) test data remotely when used in conjunction with [remote_factory_girl_home_rails](https://github.com/tdouce/remote_factory_girl_home_rails).
+
+## Getting Started
+
+See [GETTING_STARTED](https://github.com/tdouce/remote_factory_girl/wiki/Getting-Started) for information on installaton and configuration.
+
+## Run tests
+
+
+    $ rspec
+
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/remote_factory_girl/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/lib/remote_factory_girl/config.rb

@@ -0,0 +1,55 @@
+require 'remote_factory_girl/exceptions'
+require 'virtus'
+
+module RemoteFactoryGirl
+  class Config
+    include Virtus.model
+
+    DEFAULT_HOME_CONFIG = { :host      => nil, 
+                            :port      => nil, 
+                            :end_point => '/remote_factory_girl/home' }
+
+    attribute :home,                      Hash,    :default => DEFAULT_HOME_CONFIG
+    attribute :return_response_as,        Symbol,  :default => :as_hash 
+    attribute :return_with_root,          Boolean, :default => true 
+    attribute :return_as_active_resource, Boolean, :default => false 
+
+    def self.configure(configs)
+      new(configs)
+    end
+
+    def initialize(attrs = {})
+      attrs[:home] = update_home_config(attrs)
+      super(attrs)
+    end
+
+    def home_url
+      raise_no_host_error
+      http = 'http://'
+      if home[:port]
+        "#{ http }#{ home.fetch(:host) }:#{ home.fetch(:port) }#{ home.fetch(:end_point) }"
+      else
+        "#{ http }#{ home.fetch(:host) }#{ home.fetch(:end_point) }"
+      end
+    end
+
+    def to_hash
+      raise_no_host_error
+      super.merge(home_url: home_url)
+    end
+
+    def raise_no_host_error
+      raise RemoteFactoryGirlConfigError.new("RemoteFactoryGirl.config.home[:host] can not be nil") unless has_home?
+    end
+
+    def has_home?
+      !home[:host].nil? && !(home[:host] == '') && !home[:end_point].nil? && !(home[:end_point] == '')
+    end
+
+    private
+
+    def update_home_config(attrs)
+      attrs[:home] = DEFAULT_HOME_CONFIG.merge(attrs.fetch(:home, {}))
+    end
+  end
+end

data/lib/remote_factory_girl/config_applier.rb

@@ -0,0 +1,49 @@
+require 'remote_factory_girl/hash_to_dot'
+require 'remote_factory_girl/json_to_active_resource'
+require 'ostruct'
+require 'json'
+
+module  RemoteFactoryGirl
+  class ConfigApplier 
+
+    attr_reader :json, :config
+
+    def self.apply_config(json, config = {})
+      new(json, config).apply_config
+    end
+
+    def initialize(json, config = {})
+      @json   = json
+      @config = default_config.merge(config)
+    end
+
+    def apply_config
+      apply_config_options
+    end
+
+    def default_config
+      { :hash_to_dot_klass             => HashToDot, 
+        :json_to_active_resource_klass => JsonToActiveResource }
+    end
+
+    private
+
+    def apply_config_options
+      if config[:return_as_active_resource]
+        configured_json = config[:json_to_active_resource_klass].convert(json)
+      else
+        configured_json = return_with_root(json)   
+        configured_json = return_response_as(configured_json)
+      end
+      configured_json
+    end
+
+    def return_response_as(parsed_json) 
+      config[:return_response_as] == :dot_notation ? config[:hash_to_dot_klass].convert(parsed_json) : parsed_json
+    end
+
+    def return_with_root(parsed_json)
+      config[:return_with_root] == false ? Array(parsed_json).flatten.last : parsed_json
+    end
+  end
+end

data/lib/remote_factory_girl/config_struct.rb

@@ -0,0 +1,19 @@
+require 'ostruct'
+
+module RemoteFactoryGirl
+  class ConfigStruct < OpenStruct
+    def self.block_to_hash(block = nil)
+      config = self.new
+      if block
+        block.call(config)
+        config.to_hash
+      else
+        {}
+      end
+    end
+   
+    def to_hash
+      @table
+    end
+  end
+end

data/lib/remote_factory_girl/exceptions.rb

@@ -0,0 +1,3 @@
+module RemoteFactoryGirl
+  class RemoteFactoryGirlConfigError < StandardError; end
+end

data/lib/remote_factory_girl/hash_to_dot.rb

@@ -0,0 +1,9 @@
+require 'dish'
+
+module RemoteFactoryGirl
+  class HashToDot 
+    def self.convert(json)
+      Dish(json)
+    end
+  end
+end

data/lib/remote_factory_girl/http.rb

@@ -0,0 +1,31 @@
+require 'rest-client'
+
+module RemoteFactoryGirl
+  class Http
+    def self.post(config, params, http_lib = RestClient)
+      new(config, params, http_lib).response
+    end
+
+    attr_reader :config, :params, :http_lib
+
+    def initialize(config, params, http_lib = RestClient)
+      @config   = config
+      @params   = params
+      @http_lib = http_lib
+    end
+
+    def response
+      post
+      self
+    end
+
+    def post
+      config.raise_no_host_error
+      @post ||= http_lib.post config.home_url, params, content_type: :json, accept: :json
+    end
+
+    def json 
+      @json ||= JSON.parse(post)
+    end
+  end
+end

data/lib/remote_factory_girl/json_to_active_resource.rb

@@ -0,0 +1,33 @@
+module RemoteFactoryGirl
+  class JsonToActiveResource
+
+    def self.convert(json, config = {})
+      new(json, config)
+    end
+
+    attr_reader :config, :json
+
+    alias_method :to_hash, :json
+
+    def initialize(json, config = {})
+      raise 'ActiveResource not defined' if !defined?(ActiveResource)
+      @json   = json
+      @config = config
+    end
+
+    def resource(resource) 
+      resource.find(id)
+    end
+
+    private
+
+    def id
+      hash = to_array.flatten.last
+      (hash['id'] || hash[:id]).to_i
+    end
+
+    def to_array
+      @to_arry ||= Array(json)
+    end
+  end
+end

data/lib/remote_factory_girl/version.rb

@@ -0,0 +1,3 @@
+module RemoteFactoryGirl
+  VERSION = "0.0.1"
+end

data/lib/remote_factory_girl.rb

@@ -0,0 +1,55 @@
+require "remote_factory_girl/version"
+require 'remote_factory_girl/config'
+require 'remote_factory_girl/http'
+require 'remote_factory_girl/config_applier'
+require 'remote_factory_girl/config_struct'
+require 'remote_factory_girl/hash_to_dot'
+require 'remote_factory_girl/json_to_active_resource'
+
+module RemoteFactoryGirl
+  class RemoteFactoryGirl
+
+    attr_reader :name, :attributes, :config
+
+    def initialize(name, attributes, config)
+      @name       = name
+      @attributes = attributes
+      @config     = config 
+    end
+
+    def apply_config(config_applier = ConfigApplier)
+      config_applier.apply_config(post.json, config.to_hash)
+    end
+
+    def post(http = Http)
+      @post ||= http.post(config, params)
+    end
+
+    def params 
+      { factory: name, attributes: attributes }
+    end
+  end
+
+  def self.configure(opts = { :config_struct => ConfigStruct, :config => Config }, &block)
+    config      = opts.fetch(:config_struct).block_to_hash(block)
+    self.config = opts.fetch(:config).configure(config)
+  end
+
+  def self.create(factory, attributes = {}, config_applier = ConfigApplier, http = Http)
+    factory = RemoteFactoryGirl.new(factory, attributes, config)
+    factory.post(http)
+    factory.apply_config(config_applier)
+  end
+
+  def self.config
+    @config
+  end
+
+  def self.config=(config)
+    @config = config
+  end
+
+  def self.reset(config = Config.new)
+    self.config = config
+  end
+end

data/remote_factory_girl.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'remote_factory_girl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "remote_factory_girl"
+  spec.version       = RemoteFactoryGirl::VERSION
+  spec.authors       = ["tdouce"]
+  spec.email         = ["travisdouce@gmail.com"]
+  spec.summary       = %q{}
+  spec.description   = %q{}
+  spec.homepage      = "https://github.com/tdouce/remote_factory_girl"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency 'virtus', '~> 1.0'
+  spec.add_dependency 'dish'
+  spec.add_dependency 'rest-client'
+end

data/spec/integration/remote_factory_girl_spec.rb

@@ -0,0 +1,127 @@
+require 'remote_factory_girl'
+
+describe RemoteFactoryGirl do
+
+  before { RemoteFactoryGirl.reset }
+
+  describe 'configuration' do
+    it 'should be configured with correct defaults' do
+      expect(RemoteFactoryGirl.config.home).to eq({ :host      => nil, 
+                                                    :port      => nil, 
+                                                    :end_point => '/remote_factory_girl/home'})
+      expect(RemoteFactoryGirl.config.return_response_as).to eq(:as_hash) 
+      expect(RemoteFactoryGirl.config.return_with_root).to be_true 
+      expect(RemoteFactoryGirl.config.return_as_active_resource).to be_false
+    end
+
+    it 'should be able to configure with a block' do
+      RemoteFactoryGirl.configure do |config|
+        config.home = { host: 'tifton' }
+      end
+      expect(RemoteFactoryGirl.config.home[:host]).to eq('tifton')
+    end
+
+    it 'should be able to configure .home' do
+      RemoteFactoryGirl.config.home[:host] = 'fun_guy'
+      RemoteFactoryGirl.config.home[:port] = 3333 
+      RemoteFactoryGirl.config.home[:end_point] = '/down_home' 
+      expect(RemoteFactoryGirl.config.home[:host]).to eq('fun_guy')
+      expect(RemoteFactoryGirl.config.home[:port]).to eq(3333)
+      expect(RemoteFactoryGirl.config.home[:end_point]).to eq('/down_home')
+    end
+
+    it 'should be able to configure .return_response_as' do
+      expect(RemoteFactoryGirl.config.return_response_as).to eq(:as_hash)
+    end
+
+    it 'should be able to configure .return_with_root' do
+      RemoteFactoryGirl.config.return_with_root = false
+      expect(RemoteFactoryGirl.config.return_with_root).to be_false 
+    end
+
+    it 'should be able to configure .return_as_active_resource' do
+      RemoteFactoryGirl.config.return_with_root = true 
+      expect(RemoteFactoryGirl.config.return_with_root).to be_true
+    end
+  end
+
+  describe 'errors' do
+    it 'should raise RemoteFactoryGirlConfigError if .config.home[:host] is nil' do
+      RemoteFactoryGirl.config.home[:host] = nil
+      expect { RemoteFactoryGirl.create(:site) }.to raise_error(RemoteFactoryGirl::RemoteFactoryGirlConfigError)
+    end
+
+    it 'should raise RemoteFactoryGirlConfigError if .config.home[:end_point] is nil' do
+      RemoteFactoryGirl.config.home[:end_point] = nil
+      expect { RemoteFactoryGirl.create(:site) }.to raise_error(RemoteFactoryGirl::RemoteFactoryGirlConfigError)
+    end
+  end
+
+  describe 'creating a remote factory' do
+
+    before do
+      RestClient.stub(:post).and_return('{"user": {"id": "1", "first_name": "Sam", "last_name": "Iam"}}')
+    end
+
+    describe '.create' do
+
+      describe 'default .home' do
+
+        before { RemoteFactoryGirl.config.home[:host] = 'localhost' }
+
+        it 'should be able to create a factory' do
+          user = RemoteFactoryGirl.create(:site)
+          expect(user).to have_key('user') 
+        end
+
+        it 'should not return root hash key when .return_with_root is false' do
+          RemoteFactoryGirl.config.return_with_root = false
+          user = RemoteFactoryGirl.create(:user)
+          expect(user).to_not have_key('user') 
+        end
+
+        it 'should not return an object that responds to dot notation' do
+          RemoteFactoryGirl.config.return_response_as = :dot_notation
+          user = RemoteFactoryGirl.create(:user)
+          expect(user.first_name).to_not eq('Sam') 
+        end
+
+        it 'should send a post request to home' do
+          expect(RestClient).to receive(:post)
+          RemoteFactoryGirl.create(:user, :first_name => 'Sam', :last_name => 'Iam')
+        end
+      end
+
+      it 'should not return root hash key and should return an object that responds to dot notation' do
+        RemoteFactoryGirl.configure do |config|
+          config.home               = { :host => 'localhost' }
+          config.return_response_as = :dot_notation
+          config.return_with_root   = false
+        end
+        user = RemoteFactoryGirl.create(:user)
+        expect(user.first_name).to eq('Sam') 
+      end
+
+      describe 'when configured to return active_resource object' do
+
+        class ActiveResource
+          def self.find(id); end;
+        end
+
+        class User < ActiveResource; end
+
+        before do 
+          RemoteFactoryGirl.configure do |config|
+            config.home = { :host => 'localhost' }
+            config.return_as_active_resource = true 
+          end
+        end
+
+        it 'should return an active resource object' do
+          expect(ActiveResource).to receive(:find).with(1)
+          RemoteFactoryGirl.create(:user).resource(User)
+        end
+      end
+    end
+  end
+end

data/spec/models/remote_factory_girl/config_applier_spec.rb

@@ -0,0 +1,54 @@
+require 'remote_factory_girl/config_applier'
+require 'remote_factory_girl/json_to_active_resource'
+
+describe RemoteFactoryGirl::ConfigApplier do
+
+  describe '.post' do
+
+    let(:unparsed_json) {
+      '{ "user": {"first_name": "Sam", "last_name": "Iam"}}'
+      }
+    let(:json) {  
+      { :user => { :first_name => "Sam", :last_name => "Iam"}}
+    }
+    let(:hash_to_dot_klass)      { double('RemoteFactoryGirl::HashToDot') }
+    let(:dish_json_with_user)    { OpenStruct.new(:user => OpenStruct.new(:first_name => 'Sam', :last_name => 'Iam')) }
+    let(:dish_json_without_user) { OpenStruct.new(:first_name => 'Sam', :last_name => 'Iam') }
+
+    describe '.apply_config' do
+      it 'should not return root hash key when .return_with_root is false' do
+        response = RemoteFactoryGirl::ConfigApplier.apply_config(json, :return_with_root => false)
+        expect(response).to_not have_key(:user) 
+      end
+
+      it 'should not return root hash key when .return_with_root is false' do
+        response = RemoteFactoryGirl::ConfigApplier.apply_config(json, :with_root => true)
+        expect(response).to have_key(:user)
+      end
+
+      it 'should return an object that responds to dot notation' do
+        hash_to_dot_klass.stub(:convert).and_return(dish_json_with_user)
+        response = RemoteFactoryGirl::ConfigApplier.apply_config(json, :return_response_as  => :dot_notation,
+                                                                       :hash_to_dot_klass   => hash_to_dot_klass)
+        expect(response.user.first_name).to eq('Sam') 
+      end
+
+      it 'should not return root hash key and should return an object that responds to dot notation' do
+        hash_to_dot_klass.stub(:convert).and_return(dish_json_without_user)
+        response = RemoteFactoryGirl::ConfigApplier.apply_config(json, :return_response_as => :dot_notation, 
+                                                                       :return_with_root   => false,
+                                                                       :hash_to_dot_klass  => hash_to_dot_klass)
+        expect(response.first_name).to eq('Sam') 
+      end
+    end
+
+    describe 'when configured to return active resource objects' do
+      it 'should return an active resource object' do
+        json_to_active_resource_klass = double('RemoteFactoryGirl::JsonToActiveResource')
+        expect(json_to_active_resource_klass).to receive(:convert).with(json)
+        RemoteFactoryGirl::ConfigApplier.apply_config(json, :return_as_active_resource     => true, 
+                                                            :json_to_active_resource_klass => json_to_active_resource_klass)
+      end
+    end
+  end
+end

data/spec/models/remote_factory_girl/config_spec.rb

@@ -0,0 +1,53 @@
+require 'virtus'
+require 'remote_factory_girl/config.rb'
+require 'remote_factory_girl/http.rb'
+require 'remote_factory_girl/config_applier'
+require 'remote_factory_girl/config_struct'
+require 'remote_factory_girl/hash_to_dot'
+
+describe RemoteFactoryGirl::Config do
+
+  describe 'initialize' do
+
+    describe '.configure' do
+      it 'should be able to set configurations' do
+        config  = RemoteFactoryGirl::Config.configure({ :home => { :host => 'tifton', :port => 9999, :end_point => '/somewhere' },
+                                                        :return_response_as => :as_dot_notation,
+                                                        :return_with_root => false })
+        expect(config.home).to eq({ :host      => 'tifton', 
+                                    :port      => 9999, 
+                                    :end_point => '/somewhere'})
+        expect(config.return_response_as).to eq(:as_dot_notation) 
+        expect(config.return_with_root).to be_false
+      end
+    end
+
+    describe 'default configuration' do
+      it 'should be configured with correct defaults' do
+        config = RemoteFactoryGirl::Config.new
+        expect(config.home).to eq({ :host      => nil, 
+                                    :port      => nil, 
+                                    :end_point => '/remote_factory_girl/home'})
+        expect(config.return_response_as).to eq(:as_hash) 
+        expect(config.return_with_root).to be_true 
+      end
+    end
+
+    describe '#home_url' do
+
+      let(:config) { RemoteFactoryGirl::Config.new }
+
+      it 'should return a url with port if port is configured' do
+        config.home[:host] = 'localhost'
+        config.home[:port] = 5555
+        expect(config.home_url).to eq('http://localhost:5555/remote_factory_girl/home')
+      end
+
+      it 'should return a url without a port if port is not configured' do
+        config.home[:host] = 'localhost_no_port'
+        config.home[:port] = nil 
+        expect(config.home_url).to eq('http://localhost_no_port/remote_factory_girl/home')
+      end
+    end
+  end
+end

data/spec/models/remote_factory_girl/config_struct_spec.rb

@@ -0,0 +1,21 @@
+require 'remote_factory_girl/config_struct.rb'
+
+describe RemoteFactoryGirl::ConfigStruct do
+
+  describe '.block_to_hash' do
+    it 'should be able to configure with a block' do
+      class Thing
+        def self.configure(&block)
+          RemoteFactoryGirl::ConfigStruct.block_to_hash(block)
+        end
+      end
+
+      thing = Thing.configure do |config|
+        config.first_name = 'Sam' 
+        config.last_name  = 'Iam' 
+      end
+
+      expect(thing.to_hash).to eq({:first_name => 'Sam', :last_name => 'Iam'})
+    end
+  end
+end

data/spec/models/remote_factory_girl/http_spec.rb

@@ -0,0 +1,23 @@
+require 'remote_factory_girl/http.rb'
+
+describe RemoteFactoryGirl::Http do
+
+  describe '.post' do
+
+    let(:config) { double(:home_url => 'http://somewhere') }
+    let(:params) { double(:first_name => 'Sam', :last_name => 'Iam') }
+    let(:rest_client) { double('RestClient') }
+
+    it 'should raise no host config errors' do
+      rest_client.stub(:post).with(config.home_url, params, content_type: :json, accept: :json).and_return(true)
+      expect(config).to receive(:raise_no_host_error) 
+      RemoteFactoryGirl::Http.post(config, params, rest_client)
+    end
+
+    it 'should send http request to home_url with params' do
+      config.stub(:raise_no_host_error)
+      expect(rest_client).to receive(:post).with(config.home_url, params, content_type: :json, accept: :json) 
+      RemoteFactoryGirl::Http.post(config, params, rest_client)
+    end
+  end
+end

data/spec/models/remote_factory_girl/json_to_active_resource_spec.rb

@@ -0,0 +1,18 @@
+require 'remote_factory_girl/json_to_active_resource'
+
+describe RemoteFactoryGirl::JsonToActiveResource do
+
+  describe 'when configured to return active_resource object' do
+
+    class ActiveResource
+      def self.find(id); end;
+    end
+
+    class User < ActiveResource; end
+
+    it 'should return an active resource object' do
+      expect(ActiveResource).to receive(:find).with(1)
+      RemoteFactoryGirl::JsonToActiveResource.new({:user => {:id => 1}}).resource(User)
+    end
+  end
+end

data/spec/models/remote_factory_girl_spec.rb

@@ -0,0 +1,64 @@
+require 'remote_factory_girl'
+
+describe RemoteFactoryGirl do
+
+  let(:config) { double('config', :to_hash => {}) }
+
+  it 'should return params for http request' do
+    rfg = RemoteFactoryGirl::RemoteFactoryGirl.new('user', { :first_name => 'Sam' }, config)
+    expect(rfg.params).to eq(
+      { :factory => 'user', :attributes => { :first_name => 'Sam'}}
+    )
+  end
+
+  describe '#post' do
+    it 'should send a post request' do
+      http       = double('RemoteFactoryGirl::Http')
+      attributes = { :first_name => 'Sam' }
+      expect(http).to receive(:post).with(config, {:factory => 'user', :attributes => { :first_name => 'Sam'}})
+      RemoteFactoryGirl::RemoteFactoryGirl.new('user', attributes, config).post(http)
+    end
+  end
+
+  describe '#apply_config' do
+    it 'should apply config options to json with supplied configuration' do
+      attributes     = { :first_name => 'Sam' }
+      config_applier = double('RemoteFactoryGirl::ConfigApplier')
+      post           = double('RemoteFactoryGirl::Http', :json => {})
+      RemoteFactoryGirl::Http.stub(:post).and_return(post)
+      expect(config_applier).to receive(:apply_config).with(post.json, config.to_hash)
+      RemoteFactoryGirl::RemoteFactoryGirl.new('user', attributes, config).apply_config(config_applier)
+    end
+  end
+
+  it 'should be able to configure with a block' do
+    pending
+  end
+
+  describe '.config' do
+    it 'should be able to set and get config' do
+      config = double('config')
+      RemoteFactoryGirl.config = config
+      expect(RemoteFactoryGirl.config).to equal(config)
+    end
+  end
+
+  describe '.reset' do
+    it 'should be able to reset the configuration' do
+      config = double('config')
+      RemoteFactoryGirl.config = config
+      RemoteFactoryGirl.reset(double('config'))
+      expect(RemoteFactoryGirl.config).to_not equal(config)
+    end
+  end
+
+  describe '.create' do
+    describe 'when not returning active resource object' do
+      pending
+    end
+
+    describe 'when returning active resource object' do
+      pending
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+# our gem
+require 'remote_factory_girl'
+
+RSpec.configure do |config|
+
+end

data/wiki.md

@@ -0,0 +1,179 @@
+# RemoteFactoryGirl and RemoteFactoryGirlHomeRails
+
+Create [factory_girl](https://github.com/thoughtbot/factory_girl) factories
+remotely using [remote_factory_girl](https://github.com/tdouce/remote_factory_girl) in conjuction with [remote_factory_girl_home_rails](https://github.com/tdouce/remote_factory_girl_home_rails).
+
+# Why RemoteFactoryGirl and RemoteFactoryGirlHomeRails?
+
+Integration testing SOA (Software Oriented Architecture) apps is an inherently
+difficult problem (Rails apps included :). SOA is comprised of multiple applications,
+and while individual apps can be tested (and presumably passing) in isolation (usually by
+mocking http requests), it does not guarantee the apps will work in unison. Testing
+interactions between apps is more difficult.
+
+One problem with integration testing SOA apps is that it is difficult to write
+integration tests in the client. Due to the nature of SOA you can not
+create the data you need because the database that is needed to create the data
+resides in another application.  Consider the following architecture:
+
+- image of 
+  - *home* (with database) 
+    - with user model
+  - *client*
+  - communicate over http (via json)
+
+The *home* application contains the database, and the *client* application does
+not have a database.  If the *client* application wants a list of all the
+users, it has to make an http json request to *home*, *home* requests all the users
+from the database, and *home* sends the response back to the *client*.
+
+In traditional applications (apps that contain a database), it is possible to create 
+test data  with tools such as [FactoryGirl](https://github.com/thoughtbot/factory_girl).
+However, in SOA apps factory_girl alone does not suffice.  remote_factory_girl when used in 
+conjunction with [remote_factory_girl_home_rails](https://github.com/tdouce/remote_factory_girl_home_rails), builds on top of [factory_girl](https://github.com/thoughtbot/factory_girl) (because we all work on the backs of giants) 
+and provides a mechanism to create the data you need from the *client* app in the *home* app.
+
+
+## Installation
+
+[remote_factory_girl](https://github.com/tdouce/remote_factory_girl) should live in the *client* application and [remote_factory_girl_home_rails](https://github.com/tdouce/remote_factory_girl_home_rails) should live in the *home* app (the app with factory_girl factories).
+
+## Client
+
+Add this line to the *client* application's Gemfile:
+
+```ruby
+group :test do
+  gem 'remote_factory_girl'
+end
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install remote_factory_girl
+
+### Basic
+
+Configure in `spec/spec_helper.rb`
+```ruby
+RemoteFactoryGirl.configure do |config|
+  config.home = { host: 'localhost', port: 5000, end_point: "/over_the_rainbow" }
+  config.return_with_root = false
+  config.return_response_as = :dot_notation
+end
+```
+
+Use in specs
+
+```ruby
+require 'spec_helper'
+
+describe User do
+  it 'should create a user factory in RemoteFactoryGirlHome' do
+    user = RemoteFactoryGirl.create(:user, first_name: 'Sam', last_name: 'Iam')
+    expect(user.first_name).to eq('Sam')
+  end
+end
+```
+
+### ActiveResource 
+
+Configure in `spec/spec_helper.rb`
+```ruby
+RemoteFactoryGirl.configure do |config|
+  config.home = { host: 'localhost', port: 5000, end_point: '/remote_factory_girl' }
+  config.return_as_active_resource = true 
+end
+```
+
+Use in specs
+
+```ruby
+require 'spec_helper'
+
+describe User do
+  it 'should create a user factory in RemoteFactoryGirlHome' do
+    user = RemoteFactoryGirl.create(:user_with_friends, first_name: 'Sam', last_name: 'Iam').resource(User)
+    expect(user.first_name).to eq('Sam')
+  end
+end
+```
+
+## Home
+
+Add this line to *home* application's Gemfile:
+
+```ruby
+group :test do
+  gem 'remote_factory_girl_home_rails'
+end
+```
+
+And then execute:
+
+    $ bundle
+
+
+## Usage
+
+Configure in `config/environments/*.rb`
+
+Activate [remote_factory_girl_home_rails](https://github.com/tdouce/remote_factory_girl_home_rails) to run in the environments in which it is intended to
+run. For example, if remote_factory_girl_home_rails is included in `group
+:test` (most common), then activate it in `config/environments/test.rb`
+
+```ruby
+YourApplication::Application.configure do
+  ...
+  config.remote_factory_girl_home_rails.enable = true
+  ...
+end
+```
+
+Configure in `config/routes.rb`
+
+```ruby
+YourApplication::Application.routes.draw do
+  if defined?(RemoteFactoryGirlHomeRails::Engine)
+    mount RemoteFactoryGirlHomeRails::Engine, at: '/remote_factory_girl' 
+  end
+end
+```
+
+Configure in `config/initializers/remote_factory_girl_home_rails.rb` 
+
+Specify any methods that should be skipped for incoming http requests.  The most
+common methods to skip are authentication related methods that live in
+`ApplicationController`.
+
+
+```ruby
+RemoteFactoryGirlHomeRails.configure do |config|
+  config.skip_before_filter = [:authenticate, :some_other_method]
+end if defined?(RemoteFactoryGirlHomeRails)
+```
+
+
+## Usage
+
+### Home
+
+1. Run any outstanding migrations. 
+2. Start the *home* application's server at the port and end point specified in the *client*
+application's configuration. Given the above example:
+
+```bash
+rails server --environment=test --pid=/Users/your_app/tmp/pids/test.pid --port=5000
+```
+
+### Client
+
+Run your test suite.
+
+
+
+

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: remote_factory_girl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- tdouce
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dish
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- travisdouce@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/remote_factory_girl.rb
+- lib/remote_factory_girl/config.rb
+- lib/remote_factory_girl/config_applier.rb
+- lib/remote_factory_girl/config_struct.rb
+- lib/remote_factory_girl/exceptions.rb
+- lib/remote_factory_girl/hash_to_dot.rb
+- lib/remote_factory_girl/http.rb
+- lib/remote_factory_girl/json_to_active_resource.rb
+- lib/remote_factory_girl/version.rb
+- remote_factory_girl.gemspec
+- spec/integration/remote_factory_girl_spec.rb
+- spec/models/remote_factory_girl/config_applier_spec.rb
+- spec/models/remote_factory_girl/config_spec.rb
+- spec/models/remote_factory_girl/config_struct_spec.rb
+- spec/models/remote_factory_girl/http_spec.rb
+- spec/models/remote_factory_girl/json_to_active_resource_spec.rb
+- spec/models/remote_factory_girl_spec.rb
+- spec/spec_helper.rb
+- wiki.md
+homepage: https://github.com/tdouce/remote_factory_girl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- spec/integration/remote_factory_girl_spec.rb
+- spec/models/remote_factory_girl/config_applier_spec.rb
+- spec/models/remote_factory_girl/config_spec.rb
+- spec/models/remote_factory_girl/config_struct_spec.rb
+- spec/models/remote_factory_girl/http_spec.rb
+- spec/models/remote_factory_girl/json_to_active_resource_spec.rb
+- spec/models/remote_factory_girl_spec.rb
+- spec/spec_helper.rb
+has_rdoc: