dm-fluiddb-adapter 0.1.0

data/lib/loggable.rb

@@ -0,0 +1,27 @@
+require 'logger'
+
+module Loggable
+  def self.logger=(global)
+    @logger = global
+  end
+
+  def self.logger
+    @logger ||= Logger.new(STDERR)
+  end
+
+  def self.included(base)
+    base.class_eval do
+      def logger=(l)
+        @logger = l
+      end
+
+      def logger
+        @logger ||= Loggable.logger
+      end
+    end
+  end
+
+  def logger
+    self.class.logger
+  end
+end

data/spec/fluiddb_adapter_spec.rb

@@ -0,0 +1,189 @@
+require 'spec/spec_helper'
+
+describe DataMapper::Adapters::FluidDBAdapter do
+  before :all do
+    @adapter = DataMapper.setup(:default, DATABASE_URL)
+    @repository = DataMapper.repository(:default)
+
+    @http = mock('http client')
+    @adapter.instance_variable_set("@http", @http)
+
+    @cache = mock('memcache client')
+    DataMapper::Adapters::FluidDBAdapter.cache = @cache
+
+    class Flinstone
+      include DataMapper::Resource
+
+      property :id, String, :key => true
+      property :name, String
+      property :age, Integer
+    end
+  end
+
+  def tag(name)
+    prefix = @adapter.send(:tag_prefix) + '/flinstones'
+    name.nil? ? prefix : (prefix + '/' + name)
+  end
+
+  after :all do
+    DataMapper::Adapters::FluidDBAdapter.cache = CACHE
+  end
+
+  describe :create do
+
+  end
+
+  describe :read do
+
+  end
+
+  describe :delete do
+
+  end
+
+  describe :check_tag do
+
+  end
+
+  describe :check_namespace do
+
+  end
+
+  describe :paged_query do
+
+  end
+
+  describe :update do
+
+  end
+
+  describe :conditions_statement do
+    def test(c)
+      @adapter.send(:conditions_statement, c)
+    end
+
+    before(:all) do
+      @id = Flinstone.properties[:id]
+      @name = Flinstone.properties[:name]
+      @age = Flinstone.properties[:age]
+    end
+
+    it 'should extract ids' do
+      cond = DataMapper::Query::Conditions::EqualToComparison.new(@id, 'wilma')
+      test(cond).should == '|id:wilma|'
+    end
+
+    it 'should handle inclusion comparisons' do
+      andc = DataMapper::Query::Conditions::AndOperation.new
+      andc << DataMapper::Query::Conditions::InclusionComparison.new(@name, 1...6)
+
+      test(andc).should == "(#{tag('name')} >= 1 and #{tag('name')} < 6)"
+    end
+
+    it 'should handle negative operators' do
+      notc = DataMapper::Query::Conditions::NotOperation.new
+      notc << DataMapper::Query::Conditions::EqualToComparison.new(@age, 78)
+      andc = DataMapper::Query::Conditions::AndOperation.new
+      andc << "has #{tag(nil)}"
+      andc << notc
+
+      test(andc).should == "has #{tag(nil)} except #{tag('age')} = 78"
+    end
+  end
+
+  describe :query_ids do
+    it 'should parse extracted ids' do
+      #@adapter.stub(:blocking_request)
+
+      q = DataMapper::Query.new(@repository, Flinstone, :id => 'wilma')
+      @adapter.send(:query_ids, q, false).should == [ 'wilma' ]
+    end
+
+    it 'should add the identity query' do
+      @adapter.should_receive(:fluiddb_query).with("has #{tag(nil)}").and_yield(['list', 'of', 'ids'])
+
+      q = DataMapper::Query.new(@repository, Flinstone)
+      @adapter.send(:query_ids, q).should == [ 'list', 'of', 'ids' ]
+    end
+  end
+
+  describe :fetch_fields do
+    def mock_multi_get(keys, values=nil)
+      result = keys.map_hash do |k|
+        value =values.nil? ? nil : values[keys.index(k)]
+        [ k, value ]
+      end
+
+      @cache.should_receive(:get) {|args|
+        args.sort.should == keys.sort
+        result
+      }
+    end
+
+    before(:each) do
+      @ids = [ 'id1', 'id2' ]
+      @fields = [ 'description', 'path' ]
+      @tags = @fields.map_hash {|f| [ f, 'fluiddb/tags/'+f] }
+      @cached = @ids.map_hash do |id|
+        [ @adapter.send(:object_cache_key, id, @tags.values),
+          @fields.map_hash.merge("id"=>id) ]
+      end
+
+      @http.should_receive(:parallel).and_yield
+    end
+
+    describe 'when objects are cached' do
+      it 'should not fetch any fields' do
+        mock_multi_get(@cached.keys, @cached.values)
+        @adapter.send(:fetch_fields, @ids, @tags)
+      end
+    end
+
+    describe 'when objects are not cached' do
+      before(:each) do
+        mock_multi_get(@cached.keys)
+
+        @ids.each do |id|
+          key = @adapter.send(:object_cache_key, id, @tags.values)
+          @cache.should_receive(:set).with(key, @fields.map_hash.merge("id"=>id), 600)
+        end
+      end
+
+      it 'should fetch fields when not cached' do
+        @ids.each do |id|
+          mock_multi_get @fields.map {|f| id+'/fluiddb/tags/'+f }
+
+          @fields.each do |field|
+            resp = mock(:code => 200, :body => field)
+            @http.should_receive(:get).with("/objects/#{id}/fluiddb/tags/#{field}").and_yield(resp)
+            @cache.should_receive(:set).with("#{id}/fluiddb/tags/#{field}", field, 600)
+          end
+        end
+
+        @adapter.send(:fetch_fields, @ids, @tags)
+      end
+
+      it 'should not fetch fields when cached' do
+        @ids.each do |id|
+          values = @fields.map_hash {|f| [ id+'/fluiddb/tags/'+f, f ] }
+          mock_multi_get(values.keys, values.values)
+        end
+
+        @adapter.send(:fetch_fields, @ids, @tags)
+      end
+    end
+  end
+
+  describe :save do
+
+  end
+
+  describe :serialize do
+
+  end
+
+  describe :tags do
+
+  end
+
+end

data/spec/integration_spec.rb

@@ -0,0 +1,302 @@
+# This had to be copied from the db-core source because this adapter
+# doesn't support serial keys which the spec previously relied upon
+require 'spec/spec_helper'
+
+describe DataMapper::Adapters::FluidDBAdapter do
+  before :all do
+    @adapter = DataMapper.setup(:default, DATABASE_URL)
+    @repository = DataMapper.repository(:default)
+
+    class ::Heffalump
+      include DataMapper::Resource
+
+      property :id,        String, :key => true
+      property :color,     String
+      property :num_spots, Integer
+      property :striped,   Boolean
+    end
+
+    # create all tables and constraints before each spec
+    if @repository.respond_to?(:auto_migrate!)
+      Heffalump.auto_migrate!
+    end
+  end
+
+  after :all do
+    Heffalump.repository.delete(Heffalump.all)
+  end
+
+  def self.adapter_supports?(*methods)
+    methods.all? do |method|
+      # TODO: figure out a way to see if the instance method is only inherited
+      # from the Abstract Adapter, and not defined in it's class.  If that is
+      # the case return false
+
+      # CRUD methods can be inherited from parent class
+      described_type.instance_methods.any? { |instance_method| method.to_s == instance_method.to_s }
+    end
+  end
+
+  if adapter_supports?(:create)
+    describe '#create' do
+      it 'should not raise any errors' do
+        lambda {
+          Heffalump.create(:color => 'peach')
+        }.should_not raise_error
+      end
+
+      it 'should set the identity field for the resource' do
+        heffalump = Heffalump.new(:color => 'peach')
+        heffalump.id.should be_nil
+        heffalump.save
+        heffalump.id.should_not be_nil
+      end
+    end
+  else
+    it 'needs to support #create'
+  end
+
+  if adapter_supports?(:read)
+    describe '#read' do
+      before :all do
+        @heffalump = Heffalump.create(:color => 'brownish hue')
+        #just going to borrow this, so I can check the return values
+        @query = Heffalump.all.query
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          Heffalump.all()
+        }.should_not raise_error
+      end
+
+      it 'should return stuff' do
+        Heffalump.all.should be_include(@heffalump)
+      end
+    end
+  else
+    it 'needs to support #read'
+  end
+
+  if adapter_supports?(:update)
+    describe '#update' do
+      before do
+        @heffalump = Heffalump.create(:color => 'indigo')
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          @heffalump.color = 'violet'
+          @heffalump.save
+        }.should_not raise_error
+      end
+
+      it 'should not alter the identity field' do
+        id = @heffalump.id
+        @heffalump.color = 'violet'
+        @heffalump.save
+        @heffalump.id.should == id
+      end
+
+      it 'should update altered fields' do
+        @heffalump.color = 'violet'
+        @heffalump.save
+        Heffalump.get(*@heffalump.key).color.should == 'violet'
+      end
+
+      it 'should not alter other fields' do
+        color = @heffalump.color
+        @heffalump.num_spots = 3
+        @heffalump.save
+        Heffalump.get(*@heffalump.key).color.should == color
+      end
+    end
+  else
+    it 'needs to support #update'
+  end
+
+  if adapter_supports?(:delete)
+    describe '#delete' do
+      before do
+        @heffalump = Heffalump.create(:color => 'forest green')
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          @heffalump.destroy
+        }.should_not raise_error
+      end
+
+      it 'should delete the requested resource' do
+        id = @heffalump.id
+        @heffalump.destroy
+        Heffalump.get(id).should be_nil
+      end
+    end
+  else
+    it 'needs to support #delete'
+  end
+
+  if adapter_supports?(:read, :create)
+    describe 'query matching' do
+      before :all do
+        @red = Heffalump.create(:color => 'red')
+        @two = Heffalump.create(:num_spots => 2)
+        @five = Heffalump.create(:num_spots => 5)
+      end
+
+      describe 'conditions' do
+        describe 'eql' do
+          it 'should be able to search for objects included in an inclusive range of values' do
+            Heffalump.all(:num_spots => 1..5).should be_include(@five)
+          end
+
+          it 'should be able to search for objects included in an exclusive range of values' do
+            Heffalump.all(:num_spots => 1...6).should be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an inclusive range of values' do
+            Heffalump.all(:num_spots => 1..4).should_not be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an exclusive range of values' do
+            Heffalump.all(:num_spots => 1...5).should_not be_include(@five)
+          end
+        end
+
+        describe 'not' do
+          it 'should be able to search for objects with not equal value' do
+            Heffalump.all(:color.not => 'red').should_not be_include(@red)
+          end
+
+          it 'should include objects that are not like the value' do
+            Heffalump.all(:color.not => 'black').should be_include(@red)
+          end
+
+          it 'should be able to search for objects with not nil value' do
+            Heffalump.all(:color.not => nil).should be_include(@red)
+          end
+
+          it 'should not include objects with a nil value' do
+            Heffalump.all(:color.not => nil).should_not be_include(@two)
+          end
+
+          it 'should be able to search for objects not included in an array of values' do
+            Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should be_include(@two)
+          end
+
+          it 'should be able to search for objects not included in an array of values' do
+            Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should_not be_include(@five)
+          end
+
+          it 'should be able to search for objects not included in an inclusive range of values' do
+            Heffalump.all(:num_spots.not => 1..4).should be_include(@five)
+          end
+
+          it 'should be able to search for objects not included in an exclusive range of values' do
+            Heffalump.all(:num_spots.not => 1...5).should be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an inclusive range of values' do
+            Heffalump.all(:num_spots.not => 1..5).should_not be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an exclusive range of values' do
+            Heffalump.all(:num_spots.not => 1...6).should_not be_include(@five)
+          end
+        end
+
+        describe 'like' do
+          it 'should be able to search for objects that match value' do
+            Heffalump.all(:color.like => '%ed').should be_include(@red)
+          end
+
+          it 'should not search for objects that do not match the value' do
+            Heffalump.all(:color.like => '%blak%').should_not be_include(@red)
+          end
+        end
+
+        describe 'regexp' do
+          before do
+            if defined?(DataMapper::Adapters::Sqlite3Adapter) && @adapter.kind_of?(DataMapper::Adapters::Sqlite3Adapter)
+              pending 'delegate regexp matches to same system that the InMemory and YAML adapters use'
+            end
+          end
+
+          it 'should be able to search for objects that match value' do
+            Heffalump.all(:color => /ed/).should be_include(@red)
+          end
+
+          it 'should not be able to search for objects that do not match the value' do
+            Heffalump.all(:color => /blak/).should_not be_include(@red)
+          end
+
+          it 'should be able to do a negated search for objects that match value' do
+            Heffalump.all(:color.not => /blak/).should be_include(@red)
+          end
+
+          it 'should not be able to do a negated search for objects that do not match value' do
+            Heffalump.all(:color.not => /ed/).should_not be_include(@red)
+          end
+
+        end
+
+        describe 'gt' do
+          it 'should be able to search for objects with value greater than' do
+            Heffalump.all(:num_spots.gt => 1).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gt => 3).should_not be_include(@two)
+          end
+        end
+
+        describe 'gte' do
+          it 'should be able to search for objects with value greater than' do
+            Heffalump.all(:num_spots.gte => 1).should be_include(@two)
+          end
+
+          it 'should be able to search for objects with values equal to' do
+            Heffalump.all(:num_spots.gte => 2).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gte => 3).should_not be_include(@two)
+          end
+        end
+
+        describe 'lt' do
+          it 'should be able to search for objects with value less than' do
+            Heffalump.all(:num_spots.lt => 3).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gt => 2).should_not be_include(@two)
+          end
+        end
+
+        describe 'lte' do
+          it 'should be able to search for objects with value less than' do
+            Heffalump.all(:num_spots.lte => 3).should be_include(@two)
+          end
+
+          it 'should be able to search for objects with values equal to' do
+            Heffalump.all(:num_spots.lte => 2).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.lte => 1).should_not be_include(@two)
+          end
+        end
+      end
+
+      describe 'limits' do
+        it 'should be able to limit the objects' do
+          Heffalump.all(:limit => 2).length.should == 2
+        end
+      end
+    end
+  else
+    it 'needs to support #read and #create to test query matching'
+  end
+end