remote_database_cleaner 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4dc2ebd291c95cbc8073a0e9ecd2c258a77fc153
-  data.tar.gz: f1c0cfe79c90fb2a7d0bec54f75b3d76bf6bc2f7
+  metadata.gz: de1f771cfcdd7098d50841e43189cb642ba8bb06
+  data.tar.gz: 1352128823b0cf802268747b7e2c73ccbc012963
 SHA512:
-  metadata.gz: a3f00aeac6f67d0e26402285cb462fa7ad1cec55bdf497bf6459f78cda948844044fdbf15ba6762121ae46dce6e3dc612bcd41239db4ebcbe97d84453408e68e
-  data.tar.gz: a87ece00e9ae1d237b3271ab5440aa0d6f12c16fc9bf26c418c86180c875269c3fe28ba3afc6919aeff4fd5f1cc20f5e369ddad0a3c9f3d854c46adf8e9a380d
+  metadata.gz: 2bd451b22867e08e94bf8b2b5494f6165d83575d61f4a9298b275aa6b32670994eb28e25ff4d8e87ede9263f54da1085ed76c38875094af9eb033351032c37ac
+  data.tar.gz: 7226194d185dfcd00890b54da40d390da63d6bf6d253d6c71dbeb95e4eb0af31c3c2adbaed846b55948fc43f6cb7204844f61687123c579eb0e002f1a2268e94

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+## 1.0.2 - Nov. 10, 2014
+
+1. Configure multiple "home"/"remote" applications
+2. Remove RemoteDatabaseCleaner.reset. Instead use, RemoteDatabaseCleaner.remotes_config.reset
+3. Adds option to configure remote_database_cleaner to use HTTPS
+4. Refactors how remote_database_cleaner implements configuration
+5. Removes trailing whitespaces
+6. Adds tests for RemoteDatabaseCleaner::Config#has_home?

data/Gemfile

@@ -1,7 +1,6 @@
 source 'https://rubygems.org'
 
 gem 'rest-client' # http
-gem 'virtus', '~> 1.0' # defining attributes on a model: strong typing like objects and defaults
 
 # Specify your gem's dependencies in remote_database_cleaner.gemspec
 gemspec

data/README.md

@@ -12,8 +12,13 @@ See [GETTING STARTED](https://github.com/tdouce/remote_database_cleaner/wiki/Get
 
 ## Contributing
 
-1. Fork it ( http://github.com/<my-github-username>/remote_database_cleaner/fork )
+1. Fork it ( http://github.com/tdouce/remote_database_cleaner/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
+
+## TODOS
+
+1. Allow remote_database_cleaner to configure multiple "homes" (external services) so that
+   remote_database_cleaner can clean test data in multiple "homes"s.

data/lib/remote_database_cleaner/config.rb

@@ -1,41 +1,32 @@
 require 'remote_database_cleaner/exceptions'
-require 'virtus'
 
 module RemoteDatabaseCleaner
   class Config
-    include Virtus.model
 
-    DEFAULT_HOME_CONFIG = { :host      => nil, 
-                            :port      => nil, 
-                            :end_point => '/remote_database_cleaner/home/clean' }
+    DEFAULT_END_POINT = '/remote_database_cleaner/home/clean'.freeze
 
-    attribute :home, Hash, :default => DEFAULT_HOME_CONFIG
+    attr_accessor :home, :https
 
-    def self.configure(configs)
-      new(configs)
-    end
-
-    def initialize(attrs = {})
-      attrs[:home] = update_home_config(attrs)
-      super(attrs)
+    def initialize
+      @home = default_home_config
+      @https = false
     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 }
     end
 
-    def raise_no_host_error
+    def raise_if_host_not_set
       raise RemoteDatabaseCleanerConfigError.new("RemoteDatabaseCleaner.config.home[:host] can not be nil") unless has_home?
     end
 
@@ -45,8 +36,14 @@ module RemoteDatabaseCleaner
 
     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 => DEFAULT_END_POINT }
     end
   end
 end

data/lib/remote_database_cleaner/http.rb

@@ -7,7 +7,7 @@ module RemoteDatabaseCleaner
     end
 
     def post(config, params, rest_client)
-      config.raise_no_host_error
+      config.raise_if_host_not_set
       rest_client.post config.home_url, params, content_type: :json, accept: :json
     end
   end

data/lib/remote_database_cleaner/remotes_config.rb

@@ -0,0 +1,30 @@
+require 'remote_database_cleaner/config'
+
+module RemoteDatabaseCleaner
+  class RemotesConfig
+
+    attr_writer :current_remote
+    attr_accessor :remotes
+
+    DEFAULT_REMOTE_NAME = :default
+
+    alias_method :to_hash, :remotes
+
+    def initialize
+      @remotes = {}
+    end
+
+    def current_remote
+      @current_remote || default_remote_name
+    end
+
+    def default_remote_name
+      DEFAULT_REMOTE_NAME
+    end
+
+    def reset(config = Config.new)
+      self.current_remote = default_remote_name
+      self.remotes        = { default_remote_name => config}
+    end
+  end
+end

data/lib/remote_database_cleaner/version.rb

@@ -1,3 +1,3 @@
 module RemoteDatabaseCleaner
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/remote_database_cleaner.rb

@@ -1,34 +1,37 @@
 require "remote_database_cleaner/version"
 require 'remote_database_cleaner/config'
 require 'remote_database_cleaner/http'
-require 'remote_database_cleaner/config_struct'
+require 'remote_database_cleaner/remotes_config'
 
 module RemoteDatabaseCleaner
   class RemoteDatabaseCleaner
-    def params 
+    def params
       { :database => :clean }
     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)
+  def self.configure(remote_name = remotes_config.default_remote_name, opts = {:config => Config }, &block)
+    configuration = opts.fetch(:config).new
+    yield(configuration)
+    remotes_config.remotes[remote_name] = configuration
   end
 
   def self.clean(http = Http)
     database_cleaner = RemoteDatabaseCleaner.new
-    http.post(config, database_cleaner.params)
+    config_for_remote = config(remotes_config.current_remote)
+    http.post(config_for_remote, database_cleaner.params)
   end
 
-  def self.config
-    @config
+  def self.with_remote(remote_name = remotes_config.default_remote_name)
+    remotes_config.current_remote = remote_name
+    self
   end
 
-  def self.config=(config)
-    @config = config
+  def self.remotes_config
+    @remotes_config ||= RemotesConfig.new
   end
 
-  def self.reset(config = Config.new)
-    self.config = config
+  def self.config(remote_name = remotes_config.default_remote_name)
+    remotes_config.remotes[remote_name]
   end
 end

data/spec/integration/remote_database_cleaner_spec.rb

@@ -1,14 +1,17 @@
 require 'remote_database_cleaner'
+require 'spec_helper'
 
 describe RemoteDatabaseCleaner do
 
-  before { RemoteDatabaseCleaner.reset }
+  before { RemoteDatabaseCleaner.remotes_config.reset }
 
   describe 'configuration' do
     it 'should be configured with correct defaults' do
-      expect(RemoteDatabaseCleaner.config.home).to eq({:host      => nil, 
-                                                       :port      => nil, 
+      expect(RemoteDatabaseCleaner.config.home).to eq({:host      => nil,
+                                                       :port      => nil,
                                                        :end_point => '/remote_database_cleaner/home/clean'})
+
+      expect(RemoteDatabaseCleaner.config.https).to eq(false)
     end
 
     it 'should be able to configure with a block' do
@@ -20,12 +23,65 @@ describe RemoteDatabaseCleaner do
 
     it 'should be able to configure .home' do
       RemoteDatabaseCleaner.config.home[:host] = 'fun_guy'
-      RemoteDatabaseCleaner.config.home[:port] = 3333 
-      RemoteDatabaseCleaner.config.home[:end_point] = '/down_home' 
+      RemoteDatabaseCleaner.config.home[:port] = 3333
+      RemoteDatabaseCleaner.config.home[:end_point] = '/down_home'
       expect(RemoteDatabaseCleaner.config.home[:host]).to eq('fun_guy')
       expect(RemoteDatabaseCleaner.config.home[:port]).to eq(3333)
       expect(RemoteDatabaseCleaner.config.home[:end_point]).to eq('/down_home')
     end
+
+    describe '#home_url' do
+      context 'when configured to with http' do
+        before do
+          RemoteDatabaseCleaner.config.home[:host] = 'localhost'
+        end
+
+        it 'should use http' do
+          expect(
+            RemoteDatabaseCleaner.config.home_url
+          ).to eq('http://localhost/remote_database_cleaner/home/clean')
+        end
+      end
+
+      context 'when configured to with https' do
+        before do
+          RemoteDatabaseCleaner.config.https = true
+        end
+
+        it 'should use https' do
+          RemoteDatabaseCleaner.config.home[:host] = 'localhost'
+
+          expect(
+            RemoteDatabaseCleaner.config.home_url
+          ).to eq('https://localhost/remote_database_cleaner/home/clean')
+        end
+      end
+    end
+
+    context 'when configuring multiple remotes' do
+      before do
+        configure_remote_database_cleaner(remote_name: :travis,
+                                          host: 'localhost',
+                                          port: 3000,
+                                          end_point: '/remote_factory_girl/travis/home')
+        configure_remote_database_cleaner(remote_name: :casey,
+                                          host: 'over_the_rainbow',
+                                          port: 6000,
+                                          end_point: '/remote_factory_girl/casey/home')
+      end
+
+      it 'should return configuration for remote "travis"' do
+        expect(RemoteDatabaseCleaner.config(:travis).home).to eq({:host      => 'localhost',
+                                                                  :port      => 3000,
+                                                                  :end_point => '/remote_factory_girl/travis/home'})
+      end
+
+      it 'should return configuration for remote "casey"' do
+        expect(RemoteDatabaseCleaner.config(:casey).home).to eq({:host      => 'over_the_rainbow',
+                                                                 :port      => 6000,
+                                                                 :end_point => '/remote_factory_girl/casey/home'})
+      end
+    end
   end
 
   describe 'errors' do
@@ -41,13 +97,64 @@ describe RemoteDatabaseCleaner do
   end
 
   describe '.clean' do
-    it 'should send a post request to home' do
-      RemoteDatabaseCleaner::Http.stub(:post).and_return(true)
-      RemoteDatabaseCleaner.config.home[:host] = 'localhost'
-      config = RemoteDatabaseCleaner.config
-      params = { :database => :clean }
-      expect(RemoteDatabaseCleaner::Http).to receive(:post).with(config, params) 
-      RemoteDatabaseCleaner.clean
+    context 'when remote is not configured by name' do
+      before do
+        configure_remote_database_cleaner(host: 'localhost')
+      end
+
+      it 'should be configured to send http requests to default home' do
+        config = RemoteDatabaseCleaner.config
+        params = { :database => :clean }
+        expect(RemoteDatabaseCleaner::Http).to receive(:post).with(config, params)
+        RemoteDatabaseCleaner.clean
+      end
+
+      it 'should be configured to send HTTP requests to default home' do
+        http = double('http')
+
+        expect(http).to receive(:post) do |config, params, rest_client|
+          expect(config.home_url).to eq('http://localhost/remote_database_cleaner/home/clean')
+        end
+
+        RemoteDatabaseCleaner.clean(http)
+      end
+    end
+
+    context 'when remote is configured by name' do
+      before do
+        configure_remote_database_cleaner(remote_name: :travis,
+                                          host: 'localhost',
+                                          port: 3000,
+                                          end_point: '/remote_database_cleaner/travis/home/clean')
+        configure_remote_database_cleaner(remote_name: :casey,
+                                          host: 'over_the_rainbow',
+                                          port: 6000,
+                                          end_point: '/remote_database_cleaner/casey/home/clean')
+      end
+
+      context 'remote "travis"' do
+        it 'should send HTTP requests to remote named travis' do
+          http = double('http')
+
+          expect(http).to receive(:post) do |config, _, _|
+            expect(config.home_url).to eq('http://localhost:3000/remote_database_cleaner/travis/home/clean')
+          end
+
+          RemoteDatabaseCleaner.with_remote(:travis).clean(http)
+        end
+      end
+
+      context 'remote "travis"' do
+        it 'should send HTTP requests to remote named travis' do
+          http = double('http')
+
+          expect(http).to receive(:post) do |config, _, _|
+            expect(config.home_url).to eq('http://over_the_rainbow:6000/remote_database_cleaner/casey/home/clean')
+          end
+
+          RemoteDatabaseCleaner.with_remote(:casey).clean(http)
+        end
+      end
     end
   end
 end

data/spec/models/remote_database_cleaner/config_spec.rb

@@ -1,4 +1,3 @@
-require 'virtus'
 require 'remote_database_cleaner/config'
 require 'remote_database_cleaner/exceptions'
 
@@ -10,19 +9,10 @@ describe RemoteDatabaseCleaner::Config do
 
     describe 'default configuration' do
       it 'should be configured with correct defaults' do
-        default_config = RemoteDatabaseCleaner::Config.new
-        expect(default_config.home).to eq({ :host      => nil, 
-                                            :port      => nil, 
+        expect(default_config.home).to eq({ :host      => nil,
+                                            :port      => nil,
                                             :end_point => '/remote_database_cleaner/home/clean'})
-      end
-    end
-
-    describe '.configure' do
-      it 'should be able to set configurations' do
-        config  = RemoteDatabaseCleaner::Config.configure({ :home => { :host => 'tifton', :port => 9999, :end_point => '/somewhere' }})
-        expect(config.home).to eq({ :host      => 'tifton', 
-                                    :port      => 9999, 
-                                    :end_point => '/somewhere'})
+        expect(default_config.https).to eq(false)
       end
     end
 
@@ -35,9 +25,99 @@ describe RemoteDatabaseCleaner::Config do
 
       it 'should return a url without a port if port is not configured' do
         default_config.home[:host] = 'localhost_no_port'
-        default_config.home[:port] = nil 
+        default_config.home[:port] = nil
         expect(default_config.home_url).to eq('http://localhost_no_port/remote_database_cleaner/home/clean')
       end
+
+      context 'configure https' do
+        before do
+          default_config.home[:host] = 'localhost'
+          default_config.home[:port] = 5555
+          default_config.https = true
+        end
+
+        it 'should be able configure Hyper Text Transfer Protocal Secure' do
+          expect(default_config.https).to eq(true)
+        end
+      end
+    end
+
+    describe '#to_hash' do
+      before do
+        default_config.home[:host] = 'localhost'
+      end
+
+      it 'should return a hash representation' do
+        expect(default_config.to_hash).to eq( {:home => {:host      => 'localhost',
+                                                         :port      => nil,
+                                                         :end_point => '/remote_database_cleaner/home/clean'},
+                                               :home_url => 'http://localhost/remote_database_cleaner/home/clean' })
+      end
+    end
+
+    describe '#has_home?' do
+      context "when 'host' and 'end_point' are set" do
+        before do
+          default_config.home[:host] = 'localhost'
+          default_config.home[:end_point] = 'somewhere/over/the/rainbow'
+        end
+
+        it 'should return true' do
+          expect(default_config.has_home?).to eq(true)
+        end
+      end
+
+      context "when 'host' is not set" do
+        before do
+          default_config.home[:end_point] = 'somewhere/over/the/rainbow'
+        end
+
+        context "when 'host' is an empty string" do
+          before do
+            default_config.home[:host] = ''
+          end
+
+          it 'should return false' do
+            expect(default_config.has_home?).to eq(false)
+          end
+        end
+
+        context "when 'host' is nil" do
+          before do
+            default_config.home[:host] = nil
+          end
+
+          it 'should return false' do
+            expect(default_config.has_home?).to eq(false)
+          end
+        end
+      end
+
+      context "when 'end_point' is not set" do
+        before do
+          default_config.home[:host] = 'localhost'
+        end
+
+        context "when 'end_point' is an empty string" do
+          before do
+            default_config.home[:end_point] = ''
+          end
+
+          it 'should return false' do
+            expect(default_config.has_home?).to eq(false)
+          end
+        end
+
+        context "when 'end_point' is nil" do
+          before do
+            default_config.home[:end_point] = nil
+          end
+
+          it 'should return false' do
+            expect(default_config.has_home?).to eq(false)
+          end
+        end
+      end
     end
 
     describe 'errors' do

data/spec/models/remote_database_cleaner/http_spec.rb

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

data/spec/models/remote_database_cleaner_spec.rb

@@ -11,28 +11,12 @@ describe RemoteDatabaseCleaner do
   end
 
   describe '.config' do
-    it 'should be able to set and get config' do
-      config = double('config')
-      RemoteDatabaseCleaner.config = config
-      expect(RemoteDatabaseCleaner.config).to equal(config)
-    end
-  end
-
-  describe '.reset' do
-    it 'should be able to reset the configuration' do
-      config = double('config')
-      RemoteDatabaseCleaner.config = config
-      RemoteDatabaseCleaner.reset(double('config'))
-      expect(RemoteDatabaseCleaner.config).to_not equal(config)
-    end
   end
 
   describe '.clean' do
     it 'should send http request and parse request' do
-      config = double('config', :home_url => 'http://somewhere', :to_hash => {})
-      http   = double('RemoteDatabaseCleaner::Http', :post => {})
-      RemoteDatabaseCleaner.config = config
-      expect(http).to receive(:post).with(config, { :database => :clean })
+      http = double('RemoteDatabaseCleaner::Http')
+      expect(http).to receive(:post)
       RemoteDatabaseCleaner.clean(http)
     end
   end

data/spec/models/remotes_config_spec.rb

@@ -0,0 +1,42 @@
+require 'remote_database_cleaner/remotes_config.rb'
+
+describe RemoteDatabaseCleaner::Config do
+
+  let(:remotes_config) { RemoteDatabaseCleaner::RemotesConfig.new }
+  let(:home_1_config) { double('config') }
+  let(:home_2_config) { double('config') }
+  let(:default_remote_name) { RemoteDatabaseCleaner::RemotesConfig::DEFAULT_REMOTE_NAME }
+
+  describe '#initialize' do
+    context 'default configuration' do
+      it 'should be configured with correct defaults' do
+        expect(remotes_config.remotes).to eq({})
+      end
+    end
+  end
+
+  context 'adding a remote' do
+    before do
+      remotes_config.remotes[:home_1] = home_1_config
+    end
+
+    it 'should return configuration for home_1' do
+      expect(remotes_config.remotes[:home_1]).to eq(home_1_config)
+    end
+  end
+
+  describe '#reset' do
+
+    let(:reset_config) { double('config') }
+
+    before do
+      remotes_config.remotes[:home_1] = home_1_config
+      remotes_config.remotes[:home_2] = home_2_config
+      remotes_config.reset(reset_config)
+    end
+
+    it 'should return an empty hash' do
+      expect(remotes_config.to_hash).to eq({:default => reset_config })
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -6,3 +6,26 @@ require 'remote_database_cleaner'
 RSpec.configure do |config|
 
 end
+
+def configure_remote_database_cleaner(remote_name: nil,
+                                      host: nil,
+                                      port: nil,
+                                      end_point: RemoteDatabaseCleaner::Config::DEFAULT_END_POINT,
+                                      https: false)
+  if remote_name.nil?
+    RemoteDatabaseCleaner.configure do |config|
+      config.home  = {:host      => host,
+                      :port      => port,
+                      :end_point => end_point }
+      config.https = https
+    end
+
+  else
+    RemoteDatabaseCleaner.configure(remote_name) do |config|
+      config.home  = {:host      => host,
+                      :port      => port,
+                      :end_point => end_point }
+      config.https  = https
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: remote_database_cleaner
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - tdouce
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-28 00:00:00.000000000 Z
+date: 2014-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,22 +75,23 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/remote_database_cleaner.rb
 - lib/remote_database_cleaner/config.rb
-- lib/remote_database_cleaner/config_struct.rb
 - lib/remote_database_cleaner/exceptions.rb
 - lib/remote_database_cleaner/http.rb
+- lib/remote_database_cleaner/remotes_config.rb
 - lib/remote_database_cleaner/version.rb
 - remote_database_cleaner.gemspec
 - spec/integration/remote_database_cleaner_spec.rb
 - spec/models/remote_database_cleaner/config_spec.rb
-- spec/models/remote_database_cleaner/config_struct_spec.rb
 - spec/models/remote_database_cleaner/http_spec.rb
 - spec/models/remote_database_cleaner_spec.rb
+- spec/models/remotes_config_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/tdouce/remote_database_cleaner
 licenses:
@@ -119,7 +120,7 @@ summary: Initiate cleaning of test database in server from client
 test_files:
 - spec/integration/remote_database_cleaner_spec.rb
 - spec/models/remote_database_cleaner/config_spec.rb
-- spec/models/remote_database_cleaner/config_struct_spec.rb
 - spec/models/remote_database_cleaner/http_spec.rb
 - spec/models/remote_database_cleaner_spec.rb
+- spec/models/remotes_config_spec.rb
 - spec/spec_helper.rb

data/lib/remote_database_cleaner/config_struct.rb

@@ -1,19 +0,0 @@
-require 'ostruct'
-
-module RemoteDatabaseCleaner
-  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_database_cleaner/config_struct_spec.rb

@@ -1,21 +0,0 @@
-require 'remote_database_cleaner/config_struct.rb'
-
-describe RemoteDatabaseCleaner::ConfigStruct do
-
-  describe '.block_to_hash' do
-    it 'should be able to configure with a block' do
-      class Thing
-        def self.configure(&block)
-          RemoteDatabaseCleaner::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