dm-persevere-adapter 0.17.0 → 0.18.0

data/VERSION

@@ -1 +1 @@
-0.17.0
+0.18.0

data/lib/model_json_support.rb

@@ -0,0 +1,51 @@
+module DataMapper
+  module Model
+    # module Json
+      def to_json_schema(repository_name = default_repository_name)
+        to_json_schema_compatible_hash(repository_name).to_json
+      end
+      
+      #TODO: Add various options in.
+      def to_json_schema_compatible_hash(repository_name = default_repository_name)
+        usable_properties = properties.select{|p| p.name != :id }
+        schema_hash = {}
+        schema_hash['id'] = self.storage_name(repository_name)
+        properties_hash = {}
+        usable_properties.each{|p| properties_hash[p.name] = p.to_json_schema_hash if p.name != :id }
+        schema_hash['properties'] = properties_hash
+        return schema_hash
+      end
+
+  end
+  
+  class Property
+    def to_json_schema_hash
+      json_hash = { "type" => to_json_type }
+      { "optional" => true }.merge(json_hash) unless required? == true
+      # MIN
+      # MAX
+    end
+    
+    private
+    
+    def to_json_type
+      # A case statement doesn't seem to be working when comparing classes.
+      # That's why we're using a if elseif block.
+      if type == DataMapper::Types::Serial
+        return "string"
+      elsif type == String
+        return "string"
+      elsif type == Float
+        return "number"
+      elsif type == DataMapper::Types::Boolean
+        return "boolean"
+      elsif type == DataMapper::Types::Text
+        elsif type == "string"
+      elsif type == Integer
+        return "integer"
+      else 
+        return"string"
+      end
+    end
+  end
+end

data/lib/persevere.rb

@@ -34,10 +34,9 @@ class PersevereResult
 end
 
 class Persevere
-  VERSION = '1.1'
   HEADERS = { 'Accept' => 'application/json',
               'Content-Type' => 'application/json'
-            }
+            } unless defined?(HEADERS)
 
   attr_accessor :server_url, :pservr
 
@@ -49,12 +48,12 @@ class Persevere
   end
 
   # Pass in a resource hash
-  def create(path, resource)
+  def create(path, resource, headers = {})
     json_blob = resource.to_json
     response = nil
     while response.nil?
       begin
-        response = @persevere.send_request('POST', path, json_blob, HEADERS)
+        response = @persevere.send_request('POST', path, json_blob, HEADERS.merge(headers))
       rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
             Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
         puts "Persevere Create Failed: #{e}, Trying again."
@@ -63,11 +62,11 @@ class Persevere
     return PersevereResult.make(response)
   end
 
-  def retrieve(path)
+  def retrieve(path, headers = {})
     response = nil
     while response.nil?
       begin
-        response = @persevere.send_request('GET', path, nil, HEADERS)
+        response = @persevere.send_request('GET', path, nil, HEADERS.merge(headers))
       rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
             Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
         puts "Persevere Create Failed: #{e}, Trying again."
@@ -76,13 +75,13 @@ class Persevere
     return PersevereResult.make(response)
   end
 
-  def update(path, resource)
+  def update(path, resource, headers = {})
     json_blob = resource.to_json
 #    puts "JSON to PERSEVERE: #{json_blob}"
     response = nil
     while response.nil?
       begin
-        response = @persevere.send_request('PUT', path, json_blob, HEADERS)
+        response = @persevere.send_request('PUT', path, json_blob, HEADERS.merge(headers))
       rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
             Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
         puts "Persevere Create Failed: #{e}, Trying again."
@@ -91,11 +90,11 @@ class Persevere
     return PersevereResult.make(response)
   end
 
-  def delete(path)
+  def delete(path, headers = {})
     response = nil
     while response.nil?
       begin
-        response = @persevere.send_request('DELETE', path, nil, HEADERS)
+        response = @persevere.send_request('DELETE', path, nil, HEADERS.merge(headers))
       rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
             Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
         puts "Persevere Create Failed: #{e}, Trying again."

data/lib/persevere_adapter.rb

@@ -3,11 +3,99 @@ require 'dm-core'
 require 'extlib'
 require 'json'
 
+require 'model_json_support'
 require 'persevere'
 
 module DataMapper
+    module Migrations
+      module PersevereAdapter
+        # @api private
+        def self.included(base)  
+          DataMapper.extend(Migrations::SingletonMethods)
+
+          [ :Repository, :Model ].each do |name|
+            DataMapper.const_get(name).send(:include, Migrations.const_get(name))
+          end
+        end
+
+        # Returns whether the storage_name exists.
+        #
+        # @param [String] storage_name
+        #   a String defining the name of a storage, for example a table name.
+        #
+        # @return [Boolean]
+        #   true if the storage exists
+        #
+        # @api semipublic
+        def storage_exists?(storage_name)
+          class_names = JSON.parse(@persevere.retrieve('/Class/[=id]').body)
+          return true if class_names.include?("Class/"+storage_name)
+          false
+        end
+
+         ##
+         # Creates the persevere schema from the model.
+         #
+         # @param [DataMapper::Model] model
+         #   The model that corresponds to the storage schema that needs to be created.
+         #
+         # @api semipublic
+         def create_model_storage(model)
+           name       = self.name
+           properties = model.properties_with_subclasses(name)
+
+           return false if storage_exists?(model.storage_name(name))
+           return false if properties.empty?
+
+           schema_hash = model.to_json_schema_compatible_hash
+
+           return true unless put_schema(schema_hash).nil?
+           false
+         end
+
+         ##
+         # Updates the persevere schema from the model.
+         #
+         # @param [DataMapper::Model] model
+         #   The model that corresponds to the storage schema that needs to be updated.
+         #
+         # @api semipublic
+          def upgrade_model_storage(model)
+            name       = self.name
+            properties = model.properties_with_subclasses(name)
+
+            if success = create_model_storage(model)
+              return properties
+            end
+
+            table_name = model.storage_name(name)
+            schema_hash = model.to_json_schema_compatible_hash
+          end
+
+         ##
+         # Destroys the persevere schema from the model.
+         #
+         # @param [DataMapper::Model] model
+         #   The model that corresponds to the storage schema that needs to be destroyed.
+         #
+         # @api semipublic
+         def destroy_model_storage(model)
+           return true unless storage_exists?(model.storage_name(name))
+           schema_hash = model.to_json_schema_compatible_hash
+           return true unless delete_schema(schema_hash).nil?
+           false
+         end
+
+      end # module PersevereAdapter
+    end # module Migrations
+    
   module Adapters
     class PersevereAdapter < AbstractAdapter
+      extend Chainable
+      extend Deprecate
+      
+      include Migrations::PersevereAdapter
+      
       ##
       # Used by DataMapper to put records into a data-store: "INSERT"
       # in SQL-speak.  It takes an array of the resources (model
@@ -37,7 +125,7 @@ module DataMapper
           tblname = resource.model.storage_name
 
           path = "/#{tblname}/"
-          payload = resource.attributes
+          payload = resource.attributes.reject{ |key,value| value.nil? }
           payload.delete(:id)
 
           response = @persevere.create(path, payload)
@@ -98,7 +186,9 @@ module DataMapper
           tblname = resource.model.storage_name
           path = "/#{tblname}/#{resource.id}"
 
-          result = @persevere.update(path, resource.attributes)
+          payload = resource.attributes.reject{ |key,value| value.nil? }
+
+          result = @persevere.update(path, payload)
 
           if result.code == "200"
             updated += 1
@@ -193,8 +283,6 @@ module DataMapper
           resources = read_many(query)
         end
 
-        puts resources.inspect
-
         resources.each do |resource|
           tblname = resource.model.storage_name
           path = "/#{tblname}/#{resource.id}"
@@ -225,13 +313,13 @@ module DataMapper
           path = "/Class/#{project}/#{name}"
         end
 
-        response = @persevere.retrieve(path)
-
-        if response.code == "200"
-          return JSON.parse(response.body)
+        result = @persevere.retrieve(path)
+        
+        if result.code == "200"
+          return result.body
         else
-          return nil
-        end        
+          return false
+        end
       end
 
       def put_schema(schema_hash, project = nil)
@@ -246,16 +334,56 @@ module DataMapper
             puts "You need an id key/value in the hash"
           end
         end
-              
-        response = @persevere.create(path, schema_hash)
+     
+        result = @persevere.create(path, schema_hash)
+        if result.code == '201'
+          return JSON.parse(result.body)
+        else
+          return false
+        end
+      end
+      
+      def update_schema(schema_hash, project = nil)
+
+        id = schema_hash['id']
+        payload = schema_hash.reject{|key,value| key.to_sym.eql?(:id) }
+
 
-        if response.code == "201"
-          return JSON.parse(response.body)
+        if project.nil?
+          path = "/Class/#{id}"
         else
-          return nil
-        end        
+          path =  "/Class/#{project}/#{id}"
+        end
+        # debugger
+        result = @persevere.update(path, payload)
+    
+        if result.code == '200'
+          return result.body
+        else
+          return false
+        end
       end
       
+      def delete_schema(schema_hash, project = nil)
+        if ! project.nil?
+          if schema_hash.has_key?("id")
+            if ! schema_hash['id'].index(project)
+              schema_hash['id'] = "#{project}/#{schema_hash['id']}"
+            end
+          else
+            puts "You need an id key/value in the hash"
+          end
+        end
+        path = "/Class/#{schema_hash['id']}"
+        result = @persevere.delete(path)
+        
+        if result.code == "204"
+          return true
+        else
+          return false
+        end
+      end
+
       private
 
       ##
@@ -383,6 +511,9 @@ module DataMapper
 
         query
       end
-    end
-  end
-end
+    end # class PersevereAdapter
+    const_added(:PersevereAdapter)
+  end # module Adapters
+  
+
+end # module DataMapper

data/spec/adapter_shared_spec.rb

@@ -0,0 +1,311 @@
+share_examples_for 'An Adapter Foo' do
+
+  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
+
+  before :all do
+    raise '+@adapter+ should be defined in before block' unless instance_variable_get('@adapter')
+
+    class ::Heffalump
+      include DataMapper::Resource
+
+      property :id,        Serial
+      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
+
+  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 object with a nil value using required properties' do
+             Heffalump.all(:id.not => nil).should == [ @red, @two, @five ]
+           end
+  
+           it 'should be able to search for objects not in an empty list (match all)' do
+             Heffalump.all(:color.not => []).should == [ @red, @two, @five ]
+           end
+  
+           it 'should be able to search for objects in an empty list and another OR condition (match none on the empty list)' do
+             Heffalump.all(:conditions => DataMapper::Query::Conditions::Operation.new(
+                                            :or,
+                                            DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:color], []),
+                                            DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:num_spots], [5]))).should == [ @five ]
+           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) ||
+                 defined?(DataMapper::Adapters::SqlserverAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter))
+               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

data/spec/lib/adapter_helpers.rb

@@ -0,0 +1,105 @@
+require "benchmark"
+
+module DataMapper::Spec
+  module AdapterHelpers
+    def self.current_adapters
+      @current_adapters ||= []
+    end
+
+    def supported_by(*adapters, &block)
+      adapters = get_adapters(*adapters)
+
+      PRIMARY.only(*adapters).each do |adapter, connection_uri|
+        # keep track of the current adapters
+        AdapterHelpers.current_adapters << adapters
+
+        describe("with #{adapter}") do
+
+          before :all do
+            # store these in instance vars for the shared adapter specs
+            @adapter    = DataMapper.setup(:default, connection_uri)
+            @repository = DataMapper.repository(@adapter.name)
+
+            # create all tables and constraints before each spec
+            if @repository.respond_to?(:auto_migrate!)
+              @repository.auto_migrate!
+            end
+          end
+
+          after :all do
+            # remove all tables and constraints after each spec
+            if DataMapper.respond_to?(:auto_migrate_down!, true)
+              DataMapper.send(:auto_migrate_down!, @repository.name)
+            end
+          end
+
+          # TODO: add destroy_model_storage and migrations code
+          # that removes the YAML file and remove this code
+          after :all do
+            if defined?(DataMapper::Adapters::YamlAdapter) && @adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+              descendants = DataMapper::Model.descendants.to_a
+              while model = descendants.shift
+                descendants.concat(model.descendants.to_a - [ model ])
+
+                model.default_scope.clear
+                model.all(:repository => @repository).destroy!
+              end
+            end
+          end
+
+          self.instance_eval(&block)
+        end
+
+        AdapterHelpers.current_adapters.pop
+      end
+    end
+
+    def with_alternate_adapter(&block)
+      adapters = AdapterHelpers.current_adapters.last
+
+      ALTERNATE.only(*adapters).each do |adapter, connection_uri|
+        describe("and #{adapter}") do
+
+          before :all do
+            @alternate_adapter    = DataMapper.setup(:alternate, connection_uri)
+            @alternate_repository = DataMapper.repository(@alternate_adapter.name)
+
+            # create all tables and constraints before each spec
+            if @alternate_repository.respond_to?(:auto_migrate!)
+              @alternate_repository.auto_migrate!
+            end
+          end
+
+          after :all do
+            # remove all tables and constraints after each spec
+            if DataMapper.respond_to?(:auto_migrate_down!, true)
+              DataMapper.send(:auto_migrate_down!, @alternate_repository.name)
+            end
+          end
+
+          # TODO: add destroy_model_storage and migrations code
+          # that removes the YAML file and remove this code
+          after :all do
+            if defined?(DataMapper::Adapters::YamlAdapter) && @alternate_adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+              descendants = DataMapper::Model.descendants.to_a
+              while model = descendants.shift
+                descendants.concat(model.descendants.to_a - [ model ])
+
+                model.default_scope.clear
+                model.all(:repository => @alternate_repository).destroy!
+              end
+            end
+          end
+
+          self.instance_eval(&block)
+        end
+      end
+    end
+
+    def get_adapters(*adapters)
+      adapters.map! { |adapter_name| adapter_name.to_s }
+      adapters = ADAPTERS if adapters.include?('all')
+      ADAPTERS & adapters
+    end
+  end
+end

data/spec/persevere_adapter_spec.rb

@@ -1,47 +1,26 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require 'pathname'
-require 'rubygems'
- 
+require File.dirname(__FILE__) + '/spec_helper' 
 gem 'rspec'
 require 'spec'
- 
-require Pathname(__FILE__).dirname.expand_path.parent + 'lib/persevere_adapter'
- 
-DataMapper.setup(:default, {
-                            :adapter => 'persevere',
-                            :host => 'localhost',
-                            :port => '8080',
-                            :uri => 'http://localhost:8080'
-                           })
- 
-#
-# I need to make the Book class for Books to relate to
-#
- 
-class Book
-  include DataMapper::Resource
- 
-  # Persevere only does id's as strings.  
-  property :id, String, :serial => true
-  property :author, String
-  property :created_at, DateTime
-  property :title, String
-end
-
-require 'dm-core'
-require 'extlib'
 
+require 'ruby-debug'
 require DataMapper.root / 'lib' / 'dm-core' / 'spec' / 'adapter_shared_spec'
 require Pathname(__FILE__).dirname.expand_path.parent + 'lib/persevere_adapter'
 
 describe DataMapper::Adapters::PersevereAdapter do
   before :all do
     # This needs to point to a valid persevere server
-    @adapter = DataMapper.setup(:default, { :adapter => 'persevere',
-                                            :host => 'localhost',
-                                            :port => '8080' }
-                               )
-     
+    @adapter = DataMapper.setup(:default, { :adapter => 'persevere', :host => 'localhost', :port => '8080' })
+
+    class Bozon
+      include DataMapper::Resource
+
+      # Persevere only does id's as strings.  
+      property :id, String, :serial => true
+      property :author, String
+      property :created_at, DateTime
+      property :title, String
+    end
+
     @test_schema_hash = {
       'id' => 'Vanilla',
       'properties' => {
@@ -50,40 +29,120 @@ describe DataMapper::Adapters::PersevereAdapter do
         'data' => { 'type' => 'string'}
       }
     }
-  end
 
-    it_should_behave_like 'An Adapter'
+    @test_schema_hash_alt = {
+      'id' => 'test1/Vanilla',
+      'properties' => {
+        'cid' => {'type' => 'string' },
+        'parent' => { 'type' => 'string'},
+        'data' => { 'type' => 'string'}
+      }
+    }
+    @test_schema_hash_mod = {
+      'id' => 'Vanilla',
+      'properties' => {
+        'cid' => {'type' => 'string' },
+        'newdata' => { 'type' => 'any'}
+      }
+    }
+
+    @test_schema_hash_alt_mod = {
+      'id' => 'test1/Vanilla',
+      'properties' => {
+        'cid' => {'type' => 'string' },
+        'newdata' => { 'type' => 'any'}
+      }
+    }
+  end
 
-    describe '#get_schema' do
-      it 'should return all of the schemas (in json) if no name is provided' do
-        @adapter.get_schema()
-      end 
+  describe 'migrations' do
+    it 'should create the Bozon storage' do
+      Bozon.auto_migrate!
+      Bozon.auto_migrate_down!
+    end
+    
+    it "should destroy Create then Remove the Bozon Storage" do
+      @adapter.get_schema(Bozon.storage_name).should == false
+      Bozon.auto_migrate_up!
+      @adapter.get_schema(Bozon.storage_name).should_not == false
+      Bozon.auto_migrate_down!
+      @adapter.get_schema(Bozon.storage_name).should == false
+    end
+  end
 
-      it 'should return the json schema of the class specified' do
-        @adapter.get_schema("Object")
-      end
+  it_should_behave_like 'An Adapter Foo'
 
-      it 'should return all of the schemas (in json) for a project if no name is provided' do
-        @adapter.get_schema(nil, "Class")
-      end 
+  describe '#put_schema' do
+     it 'should create the json schema for the hash' do
+       @adapter.put_schema(@test_schema_hash).should_not == false
+     end 
+  
+     it 'should create the json schema for the hash under the specified project' do
+       @adapter.put_schema(@test_schema_hash, "test").should_not == false
+     end
+  
+     it 'should create the json schema for the hash under the specified project' do
+       @adapter.put_schema(@test_schema_hash_alt).should_not == false
+     end 
+   end
 
-      it 'should return all of the schemas (in json) if no name is provided' do
-        @adapter.get_schema("Object", "Class")
-      end 
+  describe '#get_schema' do
+    it 'should return all of the schemas (in json) if no name is provided' do
+      result = @adapter.get_schema()
+      result.should_not == false
+      JSON.parse(result).class.should == Array
+    end 
+  
+    it 'should return the json schema of the class specified' do
+      result = @adapter.get_schema("Object")
+      result.should_not == false
+      JSON.parse(result)["id"].should == "Object"
     end
+  
+    # I don't think we need these tests.
+    # it 'should return all of the schemas (in json) for a project if no name is provided' do
+    #   result = @adapter.get_schema(nil, "Class")
+    #   debugger
+    #   result
+    # end 
+    #   
+    # it 'should return all of the schemas (in json) if no name is provided' do
+    #   @adapter.get_schema("Object", "Class")
+    # end 
+  end
 
-    describe '#put_schema' do
-      it 'should create the json schema for the hash' do
-        @adapter.put_schema(@test_schema_hash)
-      end 
+  describe '#update_schema' do
+    it 'should update a previously existing schema' do
+      result = @adapter.update_schema(@test_schema_hash_mod)
+      result.should_not == false
 
-      it 'should create the json schema for the hash under the specified project' do
-        @adapter.put_schema(@test_schema_hash, "test")
-      end
+      @test_schema_hash_mod['id'].should match(JSON.parse(result)['id'])
+    end
+      
+    it 'should update a previously created schema under the specified project' do
+      result = @adapter.update_schema(@test_schema_hash_mod, "test")
+      result.should_not == false
+      @test_schema_hash_mod['id'].should match(JSON.parse(result)['id'])
+    end
+      
+    it 'should update a previously created schema under the specified project' do
+      result = @adapter.update_schema(@test_schema_hash_alt_mod)
+      result.should_not == false
+      @test_schema_hash_alt_mod['id'].should match(JSON.parse(result)['id'])
+    end
+  end
 
-      it 'should create the json schema for the hash under the specified project' do
-        @test_schema_hash['id'] = 'test1/Vanilla'
-        @adapter.put_schema(@test_schema_hash)
-      end 
+  describe '#delete_schema' do
+    it 'should delete the specified schema' do
+      @adapter.delete_schema(@test_schema_hash).should == true
+    end
+  
+    it 'should delete the specified schema in the specified project' do
+      @adapter.delete_schema(@test_schema_hash, "test").should == true
+    end
+  
+    it 'should delete the specified schema in the specified project' do
+      @adapter.delete_schema(@test_schema_hash_alt).should == true
     end
   end
+end

data/spec/persevere_spec.rb

@@ -57,7 +57,6 @@ describe Persevere do
       result = @p.create('/Class/', @blobObj)
       result.code.should == "201"
       JSON.parse(result.body).should == @blobObj
-#      result.body.should == "\"Can not modify queries\""
       # This shouldn't be a 201, it should say something mean.
     end
   end
@@ -73,7 +72,7 @@ describe Persevere do
     end
     
     it 'should 404 on a non-existent object' do
-      result = @p.retrieve('/Class/NotThere')
+      result = @p.retrieve('/Class/GetNotThere')
       result.code.should == "404"
       result.message.should == "Not Found"
     end
@@ -91,9 +90,10 @@ describe Persevere do
     end
     
     it 'should fail to modify a non-existent item' do
-      result = @p.update('/Class/NotThere', @blobObj)
+      result = @p.update('/Class/NonExistent', @blobObj)
       result.code.should == "500"
       result.body.should == "\"id does not match location\""
+      @p.delete('/Class/NonExistent') # A bug(?) in Persevere makes a broken NonExistent class.
       # This should be a 404 and not throw a persevere server exception
     end
   end
@@ -110,10 +110,9 @@ describe Persevere do
     
     it 'should fail to delete a non-existent item' do
       result = @p.delete('/Class/NotThere')
-      result.code.should == "204"
-      result.message.should == "No Content"
-      result.body.should be_nil
-      # This should be a 404 and not fail silently with a 204
+      result.code.should == "404"
+      result.message.should == "Not Found"
+      result.body.should == "\"Class/NotThere not found\""
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,14 +1,52 @@
-# require 'pathname'
-# require 'rubygems'
-#require 'spec'
-
-# DataMapper.setup(:default, {
-#                             :adapter => 'persevere',
-#                             :host => 'localhost',
-#                             :port => '8080',
-#                             :uri => 'http://localhost:8080'
-#                            })
-
-#
-# I need to make the Book class for Books to relate to
-#
+require 'pathname'
+require 'rubygems'
+
+require 'addressable/uri'
+require 'spec'
+
+require 'ruby-debug'
+
+require 'dm-core'
+
+require 'adapter_shared_spec'
+
+SPEC_ROOT = Pathname(__FILE__).dirname.expand_path
+# $LOAD_PATH.unshift(SPEC_ROOT.parent + 'lib')
+
+Pathname.glob((SPEC_ROOT + '{lib,*/shared}/**/*.rb').to_s).each { |file| require file }
+
+ENV['ADAPTERS'] ||= 'all'
+
+ADAPTERS = []
+
+PRIMARY = {
+  'persevere' => {:adapter => 'persevere', :host => 'localhost', :port => '8080'}
+}
+
+adapters = ENV['ADAPTERS'].split(' ').map { |adapter_name| adapter_name.strip.downcase }.uniq
+adapters = PRIMARY.keys if adapters.include?('all')
+
+PRIMARY.only(*adapters).each do |name, default|
+  connection_string = ENV["#{name.upcase}_SPEC_URI"] || default
+  begin
+    adapter = DataMapper.setup(name.to_sym, connection_string)
+
+    # test the connection if possible
+    if adapter.respond_to?(:query)
+      name == 'oracle' ? adapter.select('SELECT 1 FROM dual') : adapter.select('SELECT 1')
+    end
+
+    ADAPTERS << name
+    PRIMARY[name] = connection_string  # ensure *_SPEC_URI is saved
+   rescue Exception => exception
+     puts "Could not connect to the database using #{connection_string.inspect} because: #{exception.inspect}"
+  end
+end
+
+logger = DataMapper::Logger.new(DataMapper.root / 'log' / 'dm.log', :debug)
+logger.auto_flush = true
+
+Spec::Runner.configure do |config|
+  config.extend(DataMapper::Spec::AdapterHelpers)
+  # config.include(DataMapper::Spec::PendingHelpers)
+end

data/spec/unit/create_spec.rb

@@ -2,6 +2,19 @@ $LOAD_PATH << File.dirname(__FILE__)
 
 require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
 
+#
+# I need to make the Book class for Books to relate to
+#
+class Book
+  include DataMapper::Resource
+ 
+  # Persevere only does id's as strings.  
+  property :id, String, :serial => true
+  property :author, String
+  property :created_at, DateTime
+  property :title, String
+end
+
 describe 'A Persevere adapter' do
 
   before do

metadata

@@ -1,92 +1,95 @@
 --- !ruby/object:Gem::Specification 
 name: dm-persevere-adapter
 version: !ruby/object:Gem::Version 
-  version: 0.17.0
+  version: 0.18.0
 platform: ruby
 authors: 
-  - Ivan R. Judson
-  - The Yogo Data Management Development Team
+- Ivan R. Judson
+- The Yogo Data Management Development Team
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-01-11 00:00:00 -07:00
+date: 2010-01-13 00:00:00 -07:00
 default_executable: 
 dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: dm-core
-    type: :runtime
-    version_requirement: 
-    version_requirements: !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: 0.10.1
-      version: 
-  - !ruby/object:Gem::Dependency 
-    name: extlib
-    type: :runtime
-    version_requirement: 
-    version_requirements: !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: "0"
-      version: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.10.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: extlib
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: A DataMapper Adapter for persevere
 email: 
-  - irjudson [a] gmail [d] com
+- irjudson [a] gmail [d] com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-  - LICENSE.txt
-  - README.txt
+- LICENSE.txt
+- README.txt
 files: 
-  - .gitignore
-  - History.txt
-  - LICENSE.txt
-  - Manifest.txt
-  - README.txt
-  - Rakefile
-  - VERSION
-  - lib/persevere.rb
-  - lib/persevere_adapter.rb
-  - persevere/History.txt
-  - persevere/LICENSE.txt
-  - persevere/Manifest.txt
-  - persevere/README.txt
-  - spec/persevere_adapter_spec.rb
-  - spec/persevere_spec.rb
-  - spec/spec.opts
-  - spec/spec_helper.rb
-  - spec/unit/create_spec.rb
-  - spec/unit/delete_spec.rb
-  - spec/unit/read_spec.rb
-  - spec/unit/update_spec.rb
-  - tasks/spec.rb
+- .gitignore
+- History.txt
+- LICENSE.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- VERSION
+- lib/model_json_support.rb
+- lib/persevere.rb
+- lib/persevere_adapter.rb
+- persevere/History.txt
+- persevere/LICENSE.txt
+- persevere/Manifest.txt
+- persevere/README.txt
+- spec/adapter_shared_spec.rb
+- spec/lib/adapter_helpers.rb
+- spec/persevere_adapter_spec.rb
+- spec/persevere_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/unit/create_spec.rb
+- spec/unit/delete_spec.rb
+- spec/unit/read_spec.rb
+- spec/unit/update_spec.rb
+- tasks/spec.rb
 has_rdoc: true
 homepage: http://github.com/yogo/dm-persevere-adapter
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-  - --main
-  - README.txt
+- --main
+- README.txt
 require_paths: 
-  - lib
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
   version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
   version: 
 requirements: []
 
@@ -96,10 +99,12 @@ signing_key:
 specification_version: 3
 summary: A DataMapper Adapter for persevere
 test_files: 
-  - spec/persevere_adapter_spec.rb
-  - spec/persevere_spec.rb
-  - spec/spec_helper.rb
-  - spec/unit/create_spec.rb
-  - spec/unit/delete_spec.rb
-  - spec/unit/read_spec.rb
-  - spec/unit/update_spec.rb
+- spec/adapter_shared_spec.rb
+- spec/lib/adapter_helpers.rb
+- spec/persevere_adapter_spec.rb
+- spec/persevere_spec.rb
+- spec/spec_helper.rb
+- spec/unit/create_spec.rb
+- spec/unit/delete_spec.rb
+- spec/unit/read_spec.rb
+- spec/unit/update_spec.rb