remote_factory_girl 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 013ff8da4195f0fdd96f42fed7e582768da3979f
-  data.tar.gz: b2604a88f6b432b72b50117f9206eff9a45fa0c4
+  metadata.gz: fc49d97c232bfdba862ab52c9eabe313d7a3012f
+  data.tar.gz: 644c676dc15e1da5935d545e5341e48a11773a56
 SHA512:
-  metadata.gz: 6224e0239b03dec31d06efa4835937c4539724057926e00c11e4d76070741e5000b1ad93aea9c5f6dd8feed895ea6b9cf6797fe6fa5aac080201bb83956aaf7d
-  data.tar.gz: ae06c058feccd7413e09d419a3f73222170d10c482ac9e212fde5daf63fbfd07b934274710ae510707aa899fca4e1bac2c6fd38018489fd4dd581b7a058aaac2
+  metadata.gz: 6e964470880d4c8fd4d091ccd92922deddd53bd0e0a21b65c2065fb25fa60c07ae3344806fe880d882586d71abb53d1bbf6f6b5e4707c2e9a082ef989ea4c13d
+  data.tar.gz: d3dfbb436a42441ede4fe8b745c8b3f29a27eb34a2914c91bf89ee16253d62778f906b5a161b70523cd7b2e43cfa31b0c582313b9e040226d0e2005287939c7a

data/Gemfile

@@ -1,7 +1,6 @@
 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
 
 

data/README.md

@@ -1,6 +1,6 @@
 # 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).
+[factory_girl](https://github.com/thoughtbot/factory_girl) for [Service 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
 

data/lib/remote_factory_girl/config.rb

@@ -1,45 +1,41 @@
 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' }
+    attr_accessor :home, :return_response_as, :return_with_root, :return_as_active_resource, :https
 
-    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)
+    def initialize
+      @return_response_as        = :as_hash
+      @return_with_root          = true
+      @return_as_active_resource = false
+      @home                      = default_home_config
+      @https                     = false
     end
 
-    def initialize(attrs = {})
-      attrs[:home] = update_home_config(attrs)
-      super(attrs)
+    def home=(home_config)
+      @home = home.merge(home_config)
     end
 
     def home_url
-      raise_no_host_error
-      http = 'http://'
+      raise_if_host_not_set
       if home[:port]
-        "#{ http }#{ home.fetch(:host) }:#{ home.fetch(:port) }#{ home.fetch(:end_point) }"
+        "#{ hyper_text_transfer_protocal }://#{ home.fetch(:host) }:#{ home.fetch(:port) }#{ home.fetch(:end_point) }"
       else
-        "#{ http }#{ home.fetch(:host) }#{ home.fetch(:end_point) }"
+        "#{ hyper_text_transfer_protocal }://#{ home.fetch(:host) }#{ home.fetch(:end_point) }"
       end
     end
 
     def to_hash
-      raise_no_host_error
-      super.merge(home_url: home_url)
+      { home:                      home,
+        home_url:                  home_url,
+        return_response_as:        return_response_as,
+        return_with_root:          return_with_root,
+        return_as_active_resource: return_as_active_resource }
     end
 
-    def raise_no_host_error
-      raise RemoteFactoryGirlConfigError.new("RemoteFactoryGirl.config.home[:host] can not be nil") unless has_home?
+    def raise_if_host_not_set
+      raise RemoteFactoryGirlConfigError.new('RemoteFactoryGirl.config.home[:host] and RemoteFactoryGirl.config.home[:end_point] can not be nil') unless has_home?
     end
 
     def has_home?
@@ -48,8 +44,14 @@ module RemoteFactoryGirl
 
     private
 
-    def update_home_config(attrs)
-      attrs[:home] = DEFAULT_HOME_CONFIG.merge(attrs.fetch(:home, {}))
+    def hyper_text_transfer_protocal 
+      https == true ? 'https' : 'http'
+    end
+
+    def default_home_config
+      { :host      => nil,
+        :port      => nil,
+        :end_point => '/remote_factory_girl/home' }
     end
   end
 end

data/lib/remote_factory_girl/http.rb

@@ -3,29 +3,34 @@ require 'rest-client'
 module RemoteFactoryGirl
   class Http
     def self.post(config, params, http_lib = RestClient)
-      new(config, params, http_lib).response
+      new(config, params, http_lib).post
     end
 
-    attr_reader :config, :params, :http_lib
+    def self.get(config, params, http_lib = RestClient)
+      new(config, params, http_lib).get
+    end
+
+    attr_reader :config, :params, :http_lib, :response_json
 
     def initialize(config, params, http_lib = RestClient)
+      config.raise_if_host_not_set
       @config   = config
       @params   = params
       @http_lib = http_lib
     end
 
-    def response
-      post
+    def get
+      @response_json = http_lib.get config.home_url, params.merge!(content_type: :json, accept: :json)
       self
     end
 
     def post
-      config.raise_no_host_error
-      @post ||= http_lib.post config.home_url, params, content_type: :json, accept: :json
+      @response_json = http_lib.post config.home_url, params, content_type: :json, accept: :json
+      self
     end
 
-    def json 
-      @json ||= JSON.parse(post)
+    def to_hash
+      JSON.parse(response_json)
     end
   end
 end

data/lib/remote_factory_girl/version.rb

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

data/lib/remote_factory_girl.rb

@@ -2,43 +2,42 @@ 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
+    attr_reader :config, :response
 
-    def initialize(name, attributes, config)
-      @name       = name
-      @attributes = attributes
-      @config     = config 
+    def initialize(config)
+      @config = config
     end
 
-    def apply_config(config_applier = ConfigApplier)
-      config_applier.apply_config(post.json, config.to_hash)
+    def create(factory, attributes = {}, http = Http)
+      @response ||= http.post(config, { factory: factory, attributes: attributes })
     end
 
-    def post(http = Http)
-      @post ||= http.post(config, params)
+    def factories(attributes = {}, http = Http)
+      @response ||= http.get(config, attributes)
     end
+  end
 
-    def params 
-      { factory: name, attributes: attributes }
-    end
+  def self.configure(config = Config, &block)
+    configuration = Config.new
+    yield(configuration)
+    self.config = configuration
   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)
+  def self.factories(params = {}, http = Http)
+    factory = RemoteFactoryGirl.new(config)
+    factory.factories(params, http).to_hash
   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)
+  def self.create(factory_name, attributes = {}, config_applier = ConfigApplier, http = Http)
+    factory = RemoteFactoryGirl.new(config)
+    factory.create(factory_name, attributes, http)
+    config_applier.apply_config(factory.response.to_hash, config.to_hash)
   end
 
   def self.config

data/remote_factory_girl.gemspec

@@ -21,7 +21,6 @@ Gem::Specification.new do |spec|
   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

@@ -6,12 +6,13 @@ describe RemoteFactoryGirl do
 
   describe 'configuration' do
     it 'should be configured with correct defaults' do
-      expect(RemoteFactoryGirl.config.home).to eq({ :host      => nil, 
-                                                    :port      => nil, 
+      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_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
+      expect(RemoteFactoryGirl.config.https).to be_false
     end
 
     it 'should be able to configure with a block' do
@@ -23,8 +24,8 @@ describe RemoteFactoryGirl do
 
     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' 
+      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')
@@ -36,12 +37,17 @@ describe RemoteFactoryGirl do
 
     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 
+      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
+      RemoteFactoryGirl.config.return_as_active_resource = true
+      expect(RemoteFactoryGirl.config.return_as_active_resource).to be_true
+    end
+
+    it 'should be able to configure https' do
+      RemoteFactoryGirl.config.https = true
+      expect(RemoteFactoryGirl.config.https).to be_true
     end
   end
 
@@ -61,6 +67,16 @@ describe RemoteFactoryGirl do
 
     before do
       RestClient.stub(:post).and_return('{"user": {"id": "1", "first_name": "Sam", "last_name": "Iam"}}')
+      RestClient.stub(:get).and_return('["user", "user_admin"]')
+    end
+
+    describe '.factories' do
+
+      before { RemoteFactoryGirl.config.home[:host] = 'localhost' }
+
+      it 'should return all factories available' do
+        expect(RemoteFactoryGirl.factories).to match_array(['user', 'user_admin'])
+      end
     end
 
     describe '.create' do
@@ -71,19 +87,19 @@ describe RemoteFactoryGirl do
 
         it 'should be able to create a factory' do
           user = RemoteFactoryGirl.create(:site)
-          expect(user).to have_key('user') 
+          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') 
+          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') 
+          expect(user.first_name).to_not eq('Sam')
         end
 
         it 'should send a post request to home' do
@@ -99,7 +115,7 @@ describe RemoteFactoryGirl do
           config.return_with_root   = false
         end
         user = RemoteFactoryGirl.create(:user)
-        expect(user.first_name).to eq('Sam') 
+        expect(user.first_name).to eq('Sam')
       end
 
       describe 'when configured to return active_resource object' do
@@ -110,10 +126,10 @@ describe RemoteFactoryGirl do
 
         class User < ActiveResource; end
 
-        before do 
+        before do
           RemoteFactoryGirl.configure do |config|
             config.home = { :host => 'localhost' }
-            config.return_as_active_resource = true 
+            config.return_as_active_resource = true
           end
         end
 

data/spec/models/remote_factory_girl/config_spec.rb

@@ -1,53 +1,81 @@
-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
+  let(:config) { RemoteFactoryGirl::Config.new }
 
-    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 'initialize' do
 
     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 
+        expect(config.return_as_active_resource).to be_false
+        expect(config.https).to be_false
       end
     end
+  end
 
-    describe '#home_url' do
+  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 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
 
-      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
+    it 'should return a url that is configured with https' do
+      config.https       = true
+      config.home[:host] = 'localhost'
+      config.home[:port] = 5555
+
+      expect(config.home_url).to eq('https://localhost:5555/remote_factory_girl/home')
+    end
+  end
+
+  describe '#has_home?' do
+    it 'should return false when host and end_point are not set' do
+      config.home[:host]      = nil 
+      config.home[:end_point] = nil 
+      expect(config.has_home?).to be_false
+    end
+
+    it 'should return false when host is not set and end_point is set' do
+      expect(config.has_home?).to be_false
+    end
+
+    it 'should return true when host and end_point is set' do
+      config.home[:host]      = 'localhost'
+      config.home[:end_point] = 'some_where'
+      expect(config.has_home?).to be_true
+    end
+  end
+
+  describe '#to_hash' do
+    it 'should return a properly formatted hash' do
+      config.home[:port]      = '3000'
+      config.home[:host]      = 'localhost'
+      config.home[:end_point] = '/some_where'
+
+      expect(config.to_hash).to eq( { :home => { :host      => 'localhost', 
+                                                 :port      => '3000', 
+                                                 :end_point => '/some_where' },
+                                      :home_url                  => 'http://localhost:3000/some_where',
+                                      :return_response_as        => :as_hash,
+                                      :return_with_root          => true,
+                                      :return_as_active_resource => false })
     end
   end
 end

data/spec/models/remote_factory_girl/http_spec.rb

@@ -10,12 +10,12 @@ describe RemoteFactoryGirl::Http do
 
     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) 
+      expect(config).to receive(:raise_if_host_not_set) 
       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)
+      config.stub(:raise_if_host_not_set)
       expect(rest_client).to receive(:post).with(config.home_url, params, content_type: :json, accept: :json) 
       RemoteFactoryGirl::Http.post(config, params, rest_client)
     end

data/spec/models/remote_factory_girl_spec.rb

@@ -4,30 +4,12 @@ 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
+  describe '#create' 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)
+      RemoteFactoryGirl::RemoteFactoryGirl.new(config).create('user', attributes, http)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: remote_factory_girl
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - tdouce
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-09 00:00:00.000000000 Z
+date: 2014-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !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
@@ -96,7 +82,6 @@ files:
 - 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
@@ -106,7 +91,6 @@ 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
@@ -140,7 +124,6 @@ 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

data/lib/remote_factory_girl/config_struct.rb

@@ -1,19 +0,0 @@
-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/spec/models/remote_factory_girl/config_struct_spec.rb

@@ -1,21 +0,0 @@
-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