rrod 0.0.1 → 1.0.0.alpha.1

data/lib/rrod/test_server/rspec.rb

@@ -0,0 +1,50 @@
+require 'rrod/test_server'
+
+module Rrod
+  class TestServer
+    module RSpec
+
+      def self.enable!
+        Rrod.configure do |config|
+          # We have to use http to set bucket props (to enable search index)
+          # https://github.com/basho/riak-ruby-client/blob/v1.4.2/lib/riak/client.rb#L500
+          config.http_port = Rrod::TestServer.http_port
+          config.pb_port   = Rrod::TestServer.pb_port
+        end
+
+        ::RSpec.configure do |config|
+          config.before(:each, :integration => true) do
+            if Rrod::TestServer.fatal
+              fail "Test server not working: #{Rrod::TestServer.fatal}" 
+            end
+
+            if example.metadata[:test_server] == false
+              Rrod::TestServer.stop
+            else
+              Rrod::TestServer.create unless Rrod::TestServer.exist?
+              unless Rrod::TestServer.started?
+                @rspec_started = true
+                Rrod::TestServer.start
+                Rrod::TestServer.wait_for_search
+              end
+            end
+          end
+
+          config.after(:each, :integration => true) do
+            # i really don't understand this...
+            if !Rrod::TestServer.fatal && 
+              Rrod::TestServer.started? && 
+              example.metadata[:test_server] != false
+              Rrod::TestServer.drop
+            end
+          end
+
+          config.after(:suite) do
+            Rrod::TestServer.stop if @rspec_started && Rrod::TestServer.started?
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rrod/test_server/runner.rb

@@ -0,0 +1,56 @@
+require 'rrod/test_server'
+
+module Rrod
+  class TestServer
+    class Runner
+
+      include Singleton
+
+      def self.run
+        instance.run
+      end
+
+      def self.signal_queue
+        @signal_queue ||= []
+      end
+
+      def run
+        define_signal_traps
+
+        Rrod::TestServer.tap { |server|
+          puts "starting rrod test server"
+          server.config[:root].tap { |root| FileUtils.rm_rf root if Dir.exists? root }
+          server.create unless server.exist?
+          server.start  unless server.started?
+          begin puts "waiting for search..." end until server.search_started?
+          puts "started."
+        }
+
+        setup_run_loop
+      end
+
+      private
+
+      def setup_run_loop
+        loop do
+          case self.class.signal_queue.shift
+          when nil
+            sleep 1 # not really sure what to do here
+          when :INT, :TERM, :QUIT
+            puts
+            puts "shutting down rrod test server"
+            Rrod::TestServer.stop
+            break
+          end
+        end
+      end
+
+      def define_signal_traps
+        [:INT, :TERM, :QUIT].each do |signal|
+          Signal.trap(signal) { self.class.signal_queue << signal }
+        end
+      end
+
+    end
+  end
+end

data/lib/rrod/test_server.rb

@@ -0,0 +1,77 @@
+# The test server was copied directly out of 
+# riak-ruby-client/spec/support/test_server.rb 
+# and refactored into a class that can be used
+# to control the server's lifecycle
+
+require 'yaml'
+require 'riak/test_server'
+
+module Rrod
+  class TestServer
+    attr_reader :fatal
+    
+    extend Forwardable
+    include Singleton
+
+    DELEGATES = %w[wait_for_search start stop create drop http_port pb_port config started? search_started? exist?]
+
+    class << self
+      extend Forwardable
+      def_delegators(:instance, * [:fatal] + DELEGATES)
+    end
+
+    def_delegators(:server, *DELEGATES)
+
+    def config
+      loaded = YAML.load_file(Rrod.configuration.test_server_yml)
+      { min_port: 15_000 }.merge loaded.symbolize_keys
+    rescue Errno::ENOENT => e
+      message = "Cannot find Rrod::TestServer configuration. #{e.message}"
+      raise MissingConfigurationError.new(message)
+    end
+
+    def server
+      @server ||= try_creating_riak_test_server!
+    end
+
+    def search_started?
+      wait_for_search.chomp.eql? "riak_search is up"
+    end
+    
+    def wait_for_search
+      Timeout.timeout(Rrod.configuration.test_server_search_startup_timeout) do
+        server.send :riak_admin, 'wait-for-service', 'riak_search', server.name
+      end
+    end
+
+    def warn_crash_log
+      if @server && crash_log = @server.log + 'crash.log'
+        warn crash_log.read if crash_log.exist?
+      end
+    end
+
+    protected 
+
+    attr_writer :fatal
+
+    private
+
+    # TODO refactor warnings
+    def try_creating_riak_test_server!
+      Riak::TestServer.create(config)
+    rescue SocketError => e
+      warn "Couldn't connect to Riak TestServer!"
+      warn "Skipping remaining integration tests."
+      warn_crash_log
+      self.fatal = e
+    rescue => e
+      warn "Can't run integration specs without the test server. Please create/verify spec/support/test_server.yml."
+      warn "Skipping remaining integration tests."
+      warn e.inspect
+      warn_crash_log
+      self.fatal = e
+    end
+
+    MissingConfigurationError = Class.new(StandardError)
+  end
+end

data/lib/rrod/version.rb

@@ -1,3 +1,2 @@
-module Rrod
-  VERSION = "0.0.1"
-end
+Rrod = Module.new unless defined? Rrod
+Rrod::VERSION = '1.0.0.alpha.1'

data/rrod.gemspec

@@ -18,11 +18,17 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "riak-client",   "~> 1.4.2"
+  spec.add_dependency "activemodel",   ">= 3.2"
+  spec.add_dependency "activesupport", ">= 3.2"
+  spec.add_dependency "american_date", ">= 1.1.0"
+
+  # cli deps
   spec.add_dependency "thor", "~> 0.18"
   spec.add_dependency "pry",  "~> 0.9"
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "rspec",   "~> 2.14"
 
   spec.add_development_dependency "rake"
 end

data/spec/rrod/caster_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Rrod::Caster do
+  let(:type)   { nil }
+  let(:caster) { "#{described_class}::#{type}".constantize }
+
+  describe "BigDecimal" do
+    let(:type) { 'BigDecimal' } 
+    it "converts to big decimal" do
+      expect(caster.rrod_cast("42")).to eq 42
+    end
+  end
+
+  describe "Boolean" do
+    let(:type) { 'Boolean' }
+    it "converts to true" do
+      expect(caster.rrod_cast(true)).to be true
+    end
+    it "converts 'true' to true" do
+      expect(caster.rrod_cast("true")).to be true
+    end
+    it "converts 1 to true" do
+      expect(caster.rrod_cast(1)).to be true
+    end
+    it "converts '1' to true" do
+      expect(caster.rrod_cast("1")).to be true
+    end    
+    it "converts to false" do
+      expect(caster.rrod_cast(false)).to be false
+    end
+    it "converts 'false' to false" do
+      expect(caster.rrod_cast("false")).to be false
+    end
+    it "converts 0 to false" do
+      expect(caster.rrod_cast(0)).to be false
+    end
+    it "converts '0' to false" do
+      expect(caster.rrod_cast("0")).to be false
+    end    
+    it "converts nil to false" do
+      expect(caster.rrod_cast(nil)).to be false
+    end    
+    it "converts everything else to true" do
+      expect(caster.rrod_cast(Object.new)).to be true
+    end
+
+  end
+
+  describe "Date" do
+    let(:type) { 'Date' }
+    let(:date) { Date.parse("2013-10-31") }
+    it "converts db format to date" do
+      expect(caster.rrod_cast("2013-10-31")).to eq date
+    end
+    it "converts standard format to date" do
+      expect(caster.rrod_cast("31-10-2013")).to eq date
+    end
+    it "converts american format to date" do
+      expect(caster.rrod_cast("10/31/2013")).to eq date
+    end
+  end
+
+  describe "DateTime" do
+    let(:type) { 'DateTime' }
+    let(:datetime) { "12:13:14".to_datetime }
+    it "converts time to datetime" do
+      expect(caster.rrod_cast("12:13:14")).to eq datetime
+    end
+  end
+
+  describe "Float" do
+    let(:type)    { 'Float' }
+    let(:floater) { 3.142 }
+    it "converts to floating point" do
+      expect(caster.rrod_cast("3.142")).to eq floater
+    end
+  end
+
+  describe "Integer" do
+    let(:type) { 'Integer' }
+    it "converts to integer" do
+      expect(caster.rrod_cast('4')).to eq 4
+    end
+  end
+
+  describe "Numeric" do
+    let(:type)    { 'Numeric' }
+    it "converts to floating point" do
+      expect(caster.rrod_cast("3.142")).to eq 3.142
+    end
+    it "converts to integer" do
+      expect(caster.rrod_cast("3")).to eq 3
+    end
+  end
+
+  describe "String" do
+    let(:type) { 'String' }
+    it "converts to string" do
+      expect(caster.rrod_cast(:string)).to eq 'string'
+    end
+  end
+
+  describe "Symbol" do
+    let(:type) { 'Symbol' }
+    it "converts to symbol" do
+      expect(caster.rrod_cast('symbol')).to eq :symbol
+    end
+  end
+
+  describe "Time" do
+    let(:type) { 'Time' }
+    let(:time) { "12:13:14".to_time }
+    it "converts to time" do
+      expect(caster.rrod_cast("12:13:14")).to eq time
+    end
+  end
+end

data/spec/rrod/configuration_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Rrod do
+
+  it "adds a configure method to the Rrod module" do
+    expect(Rrod).to respond_to(:configure)
+  end
+
+  it "yields the configuration to the block given to config" do
+    Rrod.configure do |config|
+      config.pb_port = 123456
+    end
+  end
+
+  it "adds a configuration object to the Rrod module" do
+    expect(Rrod.configuration).to be_a Rrod::Configuration
+  end
+
+end
+
+describe Rrod::Configuration do
+
+  let(:config) { described_class.new }
+
+  describe "defaults" do
+    it "will use spec/support/test_server.yml for the test_server_yml" do
+      expect(config.test_server_yml).to match('spec/support/test_server.yml')
+    end
+  end
+
+  describe "client" do
+    it "creates a client based on its options" do
+      config.pb_port = 123456
+      expect(Riak::Client).to receive(:new).with(pb_port: 123456, protocol: 'pbc')
+      config.client
+    end
+
+    it "will not create a client if one exists" do
+      config.client = Riak::Client.new
+      expect(Riak::Client).not_to receive(:new)
+      config.client
+    end
+  end
+
+  describe "attributes" do
+    %w[http_port pb_port protocol client test_server_yml
+       test_server_search_startup_timeout nodes].each do |attribute|
+      it "allows configuration of #{attribute}" do
+        expect(config).to respond_to attribute
+        expect(config).to respond_to "#{attribute}="
+      end
+    end
+  end
+
+end

data/spec/rrod/model/attribute_methods_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'support/models/car'
+
+describe Rrod::Model do
+
+  let(:model) { Car }
+  let(:hash)  { {wheels: 4, color: :black, make: 'Jeep'} }
+  let(:instance) { model.new(hash) }
+
+  describe "instantiation" do
+    it "can create an object with an arbitrary hash" do
+      expect(instance.wheels).to eq 4
+      expect(instance.color).to eq :black
+      expect(instance.make).to eq 'Jeep'
+    end
+
+    it "always has an id property" do
+      expect(instance).to respond_to :id
+      expect(instance.id).to be_nil
+    end
+
+    it "manages attribute keys as strings" do
+      expect(instance.attributes).to eq hash.stringify_keys
+    end
+
+    it "ignores modifications to the attribute hash" do
+      instance.attributes[:model] = 'Wrangler'
+      expect(instance.attributes[:model]).to be_nil
+    end
+
+    it "will return nil for an attribute that exists in the hash but does not have a corresponding method" do
+      instance.instance_variable_get(:@attributes)['foo'] = 'bar'
+      expect(instance).not_to respond_to(:foo)
+      expect(instance.attributes).to include('foo' => nil)
+    end
+
+    describe "mass assignment" do
+      it "will merge attributes when mass assigning" do
+        instance.attributes = {wheels: 5}
+        expect(instance.wheels).to eq 5
+      end
+
+      it "will not add additional attribute methods after instantiation" do
+        expect { instance.attributes = {model: 'Wrangler'} }.to raise_error
+      end
+    end
+
+    describe "with schema" do
+      let(:model) { Class.new(Car) { attribute :wheels, Integer } }
+
+      it "does not allow creating with arbitrary attributes" do
+        expect { model.new(model: 'Jeep') }.to raise_error(NoMethodError, /model=/)
+      end
+
+      it "can be created with the specified attributes" do
+        expect(model.new(wheels: 5).wheels).to be 5
+      end
+    end
+
+    describe "query generation" do
+      it "lets you use strings with apostrophes in them" 
+    end
+  end
+end

data/spec/rrod/model/attribute_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Rrod::Model::Attribute do
+  let(:options)   { {presence: true} }
+  let(:model)     { Class.new { include Rrod::Model } }
+  let(:instance)  { model.new }
+  let(:name)      { :name }
+  let(:type)      { String }
+  let(:attribute) { described_class.new(model, name, type, options) }
+
+  it "has a model" do
+    expect(attribute.model).to be model
+  end
+
+  it "has a name" do
+    expect(attribute.name).to be name
+  end
+
+  it "typecasts name to a symbol when initializing" do
+    attribute = described_class.new(model, "unicorn_tears", Integer)
+    expect(attribute.name).to be :unicorn_tears
+  end
+
+  it "has a type" do
+    expect(attribute.type).to be type
+  end
+
+  it "has options" do
+    expect(attribute.options).to eq(options)
+  end
+
+  describe "defaults" do
+    context "when a value" do
+      let(:options) { {default: 'SOO fluffy!'} }
+      it "can provide a default value" do
+        expect(attribute.default).to eq 'SOO fluffy!'
+      end
+    end
+
+    context "when a proc" do
+      let(:options) { {default: -> { 'alligator' }} }
+
+      it "can provide a default value if a proc" do
+        expect(attribute.default).to eq 'alligator'
+      end
+    end
+  end
+
+  describe "defining attribute methods" do
+    before(:each) { attribute.define }
+
+    describe "getters" do
+      it "is defined on the declaring class" do
+        expect(instance).to respond_to(name)
+      end
+    end
+
+    describe "setters" do
+      it "is defined on the declaring class" do
+        expect(instance).to respond_to("#{name}=")
+      end
+    end
+  end
+
+  describe "casting" do
+    it "will use the types rrod_cast method if available" do
+      type = Class.new {
+        def self.rrod_cast(value)
+          value.to_s.upcase
+        end
+      }
+      model.attribute :example, type
+      instance.example = 'shorty'
+      expect(instance.example).to eq 'SHORTY'
+    end
+
+    it "will look for a register Rrod caster if the type cannot cast itself" do
+      model.attribute :example, String
+      instance.example = :whazzup
+      expect(instance.example).to eq('whazzup')
+    end
+
+    it "will simply return the value if all else fails" do
+      model.attribute :example, Class.new
+      instance.example = self
+      expect(instance.example).to be self
+    end
+
+    describe "nested rrod models" do
+      let(:type) { [Class.new { include Rrod::Model }] }
+
+      it "can detect if the type is a nested rrod model" do
+        expect(attribute.send :nested_model?).to be true
+      end
+
+      it "adds a rrod_cast method to the nested rrod model reference object" do
+        attribute
+        expect(type).to respond_to(:rrod_cast)
+      end
+    end
+  end
+end

data/spec/rrod/model/collection_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'support/models/person'
+
+describe Rrod::Model::Collection do
+  let(:array)      { [Pet.new] }
+  let(:collection) { described_class.new(array) }
+
+  describe "initialization" do
+    it "takes a collection" do
+      expect(collection.collection).to eq(array)
+    end
+
+    it "defaults to an empty collection" do
+      expect(described_class.new.collection).to be_an Array
+    end
+
+    describe "errors" do
+      describe "non enumerable" do
+        let(:array) { Object.new }
+        it "raises" do
+          expect { collection }.to raise_error(Rrod::Model::Collection::InvalidCollectionTypeError)
+        end
+      end
+
+      describe "not all Rrod::Model" do
+        let(:array) { [Pet.new, Object.new] }
+        it "raises if not all `Rrod::Model`s" do
+          expect { collection }.to raise_error(Rrod::Model::Collection::InvalidMemberTypeError)
+        end
+
+        it "clears the collection" do
+          collection = described_class.new
+          begin; collection.collection = array; rescue; end
+          expect(collection.collection).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rrod/model/finders_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'support/models/car'
+
+describe Rrod::Model::Finders, integration: true do
+
+  let(:model) { Car }
+  let(:hash)  { {wheels: 4, color: :black, make: 'Jeep'} }
+  let(:instance) { model.new(hash) }
+
+  before :each do
+    instance.save
+  end
+
+  it "can be found by id" do
+    found = model.find(instance.id)
+    expect(found).to be_a model
+  end
+
+  it "will raise an error if it can't be found" do
+    expect { model.find("id that is not there") }.to raise_error(Rrod::Model::NotFound)
+  end
+
+  it "is persisted" do
+    found = model.find(instance.id)
+    expect(found).to be_persisted
+  end
+
+  it "sets the robject on the found instance" do
+    found = model.find(instance.id)
+    expect(found.robject).to be_a Riak::RObject
+  end
+
+  describe "finding by attributes in the hash" do
+    describe "find_first_by" do
+      it "can find one" do
+        found = model.find_first_by(make: 'Jeep')
+        expect(found).to be_a model 
+        expect(found.make).to eq "Jeep"
+      end
+
+      it "will work properly when finding by id" do
+        found = model.find_first_by(id: instance.id)
+        expect(found).to be_a model
+      end
+
+      it "will return nil if one can't be found" do
+        found = model.find_first_by(id: "id that is not there")
+        expect(found).to be nil
+      end
+
+      it "will raise an exception if one can't be found with a !" do
+        expect { model.find_first_by! zombies: true }.to raise_error(Rrod::Model::NotFound)
+      end
+    end
+
+    describe "find_all_by" do
+      it "can find all" do
+        founds = model.find_all_by(make: 'Jeep', wheels: 4)
+        found = founds.first
+        expect(founds).to be_an Array
+        expect(found).to be_a model 
+        expect(found.make).to eq "Jeep"
+      end
+
+      it "will raise an exception if finding all by id" do
+        expect {model.find_all_by(id: instance.id)}.to raise_error(ArgumentError)
+      end
+
+      it "will return [] if none can be found" do
+        expect(model.find_all_by zombies: 'yes plz').to eq []
+      end
+
+      it "will raise an exception if none can be found with a !" do
+        expect { model.find_all_by! brains: :none }.to raise_error(Rrod::Model::NotFound)
+      end
+    end
+  end
+end