crud-service 0.0.9 → 0.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    OWU4YWI0ZDc4OWRiYTU2YjhjYjg5MzFjNWM2MDg2MjJhZjQwYzU4YQ==
-  data.tar.gz: !binary |-
-    NDFkMmFkZmZmODQ3YjVhNzA3Y2M4MzgwMjgzYzg2NGU1MzAxYTM4YQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    YTI3MDU2ZmU4MTc1ZDU2MWM3NmM1MGFiYTIwMDYzYWEzNWY3MGQ1MzY3YjBh
-    Y2Q5NWEyYjczZmIzZmMzZGY0Mjg5MGEzMTViOWE4NGRiODc1NThjZjA5NGE0
-    MzcyZmQxMmIxZDE2ZmZhMGY3OGY1NzU4ZjE0ZDczMTE4NGQ4ZWQ=
-  data.tar.gz: !binary |-
-    YTQzOGZlMjM2MDkxODAzZDU0ZmMyZDM1MzQ2Njc0ZTM2MTg1MmQ4ZmI4MTAw
-    NzVmZTkzNDJmMTRlNjBlNDQ2YmQ1MTY1YzE0MmI1MzljZTZhZjE4ZWJkODky
-    N2I0MjIwMWE0M2IwZjA2YjMxMmU2NzRhODhjNWM3MWY3ZDZiNjI=
+SHA1:
+  metadata.gz: 7790c1877ec4d0783a3813a172928fb84e8611c0
+  data.tar.gz: 53ec5d4ae333d795cf0aaa1a47b7211ce79256e2
+SHA512:
+  metadata.gz: 2900ea911d11cb0f7c2ab0c00280a656c135216309eee42397350ee06e0f072db7d2a71554d54d98b7ea071165b23a10b2073c798c463115d133d8f450478b32
+  data.tar.gz: 22124825d383be131bc3f58ac0f0eef5a9cadcf4f886e5548cf053c1c3bcc7e9b35e24a7174ba9b6529ab5dd5317bd984ae1c798b03b3e66c8787c7028bea1ba

data/lib/crud-service.rb

@@ -1,3 +1,6 @@
-require "api"
-require "dal"
-require "service"
+files = [
+  'version',
+  'api',
+  'dal',
+  'service',
+].each { |file| require "#{File.dirname(__FILE__)}/crud-service/#{file}" }

data/lib/crud-service/api.rb

@@ -0,0 +1,152 @@
+module CrudService
+  # This mixin provides a static methods to configure a sinatra class with the
+  # provided resource name, service and api_options
+  module Api
+    # Set up full CRUD API functionality on the given resource
+    def crud_api(resource_name, service_name, primary_key_name, api_options = {})
+      api_options = get_defaults(api_options)
+
+      crud_options(resource_name, api_options) if api_options[:enable_options]
+
+      if api_options[:enable_write]
+        crud_post(resource_name, service_name, primary_key_name, api_options) if api_options[:enable_post]
+        crud_put(resource_name, service_name, primary_key_name, api_options)  if api_options[:enable_put]
+        crud_delete(resource_name, service_name, primary_key_name, api_options) if api_options[:enable_delete]
+      end
+
+      if api_options[:enable_read]
+        crud_get(resource_name, service_name, primary_key_name, api_options) if api_options[:enable_get]
+        crud_get_all(resource_name, service_name, api_options) if api_options[:enable_get_all]
+      end
+    end
+
+    # Set up OPTIONS functionality on the given resource
+    def crud_options(resource_name, api_options = {})
+      api_options = get_defaults(api_options)
+      options '/'+resource_name do
+        204
+      end
+    end
+
+    # Set up UPDATE/put functionality on the given resource
+    def crud_put(resource_name, service_name, primary_key_name, api_options = {})
+      api_options = get_defaults(api_options)
+      put '/'+resource_name+'/:'+primary_key_name do
+        service = settings.send(service_name)
+
+        # Must Exist
+        return 404 unless service.exists_by_primary_key?(params[primary_key_name.to_sym])
+
+        # Get The Data
+        begin
+          data = JSON.parse(request.body.read)
+        rescue Exception => e
+          return 422
+        end
+
+        # Valid Update?
+        return 422 unless service.valid_update?(data)
+
+        # Do Update
+        record = service.update_by_primary_key(params[primary_key_name.to_sym],data)
+
+        # Other Error
+        return 500 if record.nil?
+
+        # Return new Region
+        JSON.fast_generate record
+      end
+    end
+
+    # Set up GET/get_one functionality on the given resource
+    def crud_get(resource_name, service_name, primary_key_name, api_options = {})
+      api_options = get_defaults(api_options)
+      get '/'+resource_name+'/:'+primary_key_name do
+        service = settings.send(service_name)
+
+        sanitize_params(params)
+        return 400 unless service.valid_query?(params)
+
+        record = service.get_one_by_query(params)
+        return 404 if record.nil?
+        JSON.fast_generate record
+      end
+    end
+
+    # Set up GET/get_all functionality on the given resource
+    def crud_get_all(resource_name, service_name, api_options = {})
+      api_options = get_defaults(api_options)
+      get '/'+resource_name do
+        service = settings.send(service_name)
+
+        sanitize_params(params)
+        # Check query validity
+        return 400 unless service.valid_query?(params)
+
+        # Return Regions on Query
+        JSON.fast_generate service.get_all_by_query(params)
+      end
+    end
+
+    # Set up DELETE functionality on the given resource
+    def crud_delete(resource_name, service_name, primary_key_name, api_options = {})
+      api_options = get_defaults(api_options)
+      delete '/'+resource_name+'/:'+primary_key_name do
+        service = settings.send(service_name)
+
+        # Must Exist
+        return 404 unless service.exists_by_primary_key?(params[primary_key_name.to_sym])
+
+        # Do Delete
+        return 500 unless service.delete_by_primary_key(params[primary_key_name.to_sym])
+
+        204
+      end
+    end
+
+    # Set up POST/insert functionality on the given resource
+    def crud_post(resource_name, service_name, primary_key_name, api_options = {})
+      api_options = get_defaults(api_options)
+      post '/'+resource_name do
+        service = settings.send(service_name)
+
+        # Get The data
+        begin
+          data = JSON.parse(request.body.read)
+        rescue Exception => e
+          return 422
+        end
+
+        # Valid POST?
+        return 422 unless service.valid_insert?(data)
+
+        # Already Exists?
+        return 409 if service.exists_by_primary_key?(data[primary_key_name])
+
+        # Do Insert
+        record = service.insert(data)
+
+        # Other Error
+        return 500 if record.nil?
+
+        # Output new record
+        JSON.fast_generate record
+      end
+    end
+
+    # Return the given options with defaults set
+    def get_defaults(api_options)
+      defaults = {
+        :enable_read => true,
+        :enable_write => true,
+        :enable_options => true,
+        :enable_get_all => true,
+        :enable_get => true,
+        :enable_post => true,
+        :enable_put => true,
+        :enable_delete => true,
+      }
+      api_options.merge!(defaults) { |key, v1, v2| v1 }
+    end
+  end
+end

data/lib/{dal.rb → crud-service/dal.rb}

@@ -1,4 +1,3 @@
-require 'json'
 require 'mysql2'
 
 module CrudService
@@ -7,7 +6,24 @@ module CrudService
   # Your should extend this class to provide configuration for your dal, please see 
   # the README file at http://github.com/tomcully/crud-service
 	class Dal
-    attr_accessor :mysql, :memcache, :log, :table_name, :fields, :relations, :primary_key, :auto_primary_key, :cache_prefix
+    # The DB layer to use, e.g. an instance of Mysql2::Client
+    attr_accessor :mysql
+    # The Memcache layer to use, e.g. an instance of Dalli::Client
+    attr_accessor :memcache
+    # The logger to use, e.g. an instance of Console::Logger
+    attr_accessor :log
+    # The DB table name
+    attr_accessor :table_name
+    # A Hash of table fields (See README)
+    attr_accessor :fields
+    # A Hash of table relations (See README)
+    attr_accessor :relations
+    # The primary key name
+    attr_accessor :primary_key
+    # If true, the primary key values are assigned by the DB layer
+    attr_accessor :auto_primary_key
+    # The memcache key prefix for this DAL
+    attr_accessor :cache_prefix
 
     # Create an instance.
     def initialize(mysql, memcache = nil, log) 
@@ -105,6 +121,7 @@ module CrudService
       where.chomp(' AND ')
     end
 
+    # Build a simple where clause from the given query with the given table/db namespace
     def build_where_ns(query,ns)
       where = ""
       query.each_pair do |k, v| 
@@ -214,6 +231,7 @@ module CrudService
       map_to_hash_by_primary_key(get_all_by_query(query))
     end
 
+    # Map in the included relations to each of the supplied result rows
     def map_in_included_relations!(result, query)
       dat = get_relation_data_as_hash(query)
       result.each do |res|
@@ -230,7 +248,7 @@ module CrudService
 
     # Get data for included relations for a query
     def get_relation_data_as_hash(query) 
-      return {} if @relations.nil?
+      return {} if @relations.nil? or @relations.empty?
 
       includes = get_includes(query)
 
@@ -248,6 +266,7 @@ module CrudService
       reldata
     end
 
+    # Remove the given key from each record in the supplied hash
     def remove_key_from_hash_of_arrays!(hash,key)
       hash.each do |name,arr|
         arr.each do |record|
@@ -311,6 +330,7 @@ module CrudService
         return get_has_many_through_relation_query_sql(relation, query)
       else
         @log.error("Relation type #{relation[:type]} undefined!")
+        nil
       end
     end
 
@@ -354,7 +374,7 @@ module CrudService
       when :has_many_through
         return [@table_name, relation[:table], relation[:link_table]].sort
       else
-        throw "Unknown Relation type #{relation.type}"
+        raise "Unknown Relation type #{relation[:type]}"
       end
     end
 
@@ -427,7 +447,7 @@ module CrudService
         queryresult = @mysql.query(query)
       rescue Exception => e
         @log.error("#{e}")
-        return false
+        return nil
       end
 
       expire_table_cache(get_all_related_tables)

data/lib/{service.rb → crud-service/service.rb}

@@ -1,6 +1,12 @@
 module CrudService
+  # Service provides a generic mapping layer between the API and the DAL.
+  # You should extend this class, or provide a class with the same interface,
+  # to implement service level functionality, or support REST-like RPC.
   class Service
-    attr_accessor :dal, :log
+    # The DAL layer to use, e.g. an instance of CrudService::DAL
+    attr_accessor :dal
+    # The logger to use, e.g. an instance of Console::Logger
+    attr_accessor :log
 
     # Instantiate a service with the specified DAL and logger.
     def initialize(dal, log)

data/lib/crud-service/version.rb

@@ -0,0 +1,5 @@
+# The `crud-service` module provides classes and mixins to implement a basic JSON CRUD service using Sinatra, MySQL and memcached.
+module CrudService
+  # The version of CrudService
+  VERSION = '0.1.0'
+end

data/spec/api_spec.rb

@@ -0,0 +1,609 @@
+require "spec_helper"
+
+class TestAPI
+  include CrudService::Api
+end
+
+describe CrudService::Api do
+
+  describe '#get_defaults' do
+
+    it 'should produce correct fields' do
+      inst = TestAPI.new
+
+      mock_opts = {
+        :enable_read=>true,
+        :enable_write=>true,
+        :enable_options=>true,
+        :enable_get_all=>true,
+        :enable_get=>true,
+        :enable_post=>true,
+        :enable_put=>true,
+        :enable_delete=>true
+      }
+
+      expect(inst.get_defaults({})).to eq(mock_opts)
+    end
+
+    it 'should not overwrite existing fields' do
+      inst = TestAPI.new
+
+      mock_opts = {
+        :enable_read=>true,
+        :enable_write=>true,
+        :enable_options=>false,
+        :enable_get_all=>true,
+        :enable_get=>true,
+        :enable_post=>true,
+        :enable_put=>true,
+        :enable_delete=>true
+      }
+
+      expect(inst.get_defaults({:enable_options=>false})).to eq(mock_opts)
+    end
+
+  end
+  describe '#crud_api' do
+    it 'should call correct methods in correct order for defaults' do
+      mock_opts = {
+        :enable_read=>true,
+        :enable_write=>true,
+        :enable_options=>true,
+        :enable_get_all=>true,
+        :enable_get=>true,
+        :enable_post=>true,
+        :enable_put=>true,
+        :enable_delete=>true
+      }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:crud_options).with(1,mock_opts)
+      expect(inst).to receive(:crud_post).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_put).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_delete).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get_all).with(1,2,mock_opts)
+
+      inst.crud_api(1,2,3,{})
+    end
+
+    it 'should not call write methods if enable_write is false' do
+      mock_opts = { :enable_write=>false, :enable_post=>true, :enable_put=>true, :enable_delete=>true }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:crud_options).with(1,mock_opts)
+      expect(inst).not_to receive(:crud_post).with(1,2,3,mock_opts)
+      expect(inst).not_to receive(:crud_put).with(1,2,3,mock_opts)
+      expect(inst).not_to receive(:crud_delete).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get_all).with(1,2,mock_opts)
+
+      inst.crud_api(1,2,3,mock_opts)
+    end
+
+    it 'should not call read methods if enable_read is false' do
+      mock_opts = { :enable_read=>false, :enable_get=>true, :enable_get_all=>true }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:crud_options).with(1,mock_opts)
+      expect(inst).to receive(:crud_post).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_put).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_delete).with(1,2,3,mock_opts)
+      expect(inst).not_to receive(:crud_get).with(1,2,3,mock_opts)
+      expect(inst).not_to receive(:crud_get_all).with(1,2,mock_opts)
+
+      inst.crud_api(1,2,3,mock_opts)
+    end
+
+    it 'should not call crud_post method if enable_post is false' do
+      mock_opts = { :enable_read=>true, :enable_write=>true, :enable_post=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:crud_options).with(1,mock_opts)
+      expect(inst).not_to receive(:crud_post).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_put).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_delete).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get_all).with(1,2,mock_opts)
+
+      inst.crud_api(1,2,3,mock_opts)
+    end
+
+    it 'should not call crud_put method if enable_put is false' do
+      mock_opts = { :enable_read=>true, :enable_write=>true, :enable_put=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:crud_options).with(1,mock_opts)
+      expect(inst).to receive(:crud_post).with(1,2,3,mock_opts)
+      expect(inst).not_to receive(:crud_put).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_delete).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get_all).with(1,2,mock_opts)
+
+      inst.crud_api(1,2,3,mock_opts)
+    end
+
+    it 'should not call crud_delete method if enable_delete is false' do
+      mock_opts = { :enable_read=>true, :enable_write=>true, :enable_delete=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:crud_options).with(1,mock_opts)
+      expect(inst).to receive(:crud_post).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_put).with(1,2,3,mock_opts)
+      expect(inst).not_to receive(:crud_delete).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get_all).with(1,2,mock_opts)
+
+      inst.crud_api(1,2,3,mock_opts)
+    end
+
+    it 'should not call crud_get method if enable_get is false' do
+      mock_opts = { :enable_read=>true, :enable_write=>true, :enable_get=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:crud_options).with(1,mock_opts)
+      expect(inst).to receive(:crud_post).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_put).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_delete).with(1,2,3,mock_opts)
+      expect(inst).not_to receive(:crud_get).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get_all).with(1,2,mock_opts)
+
+      inst.crud_api(1,2,3,mock_opts)
+    end
+
+    it 'should not call crud_get_all method if enable_get_all is false' do
+      mock_opts = { :enable_read=>true, :enable_write=>true, :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:crud_options).with(1,mock_opts)
+      expect(inst).to receive(:crud_post).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_put).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_delete).with(1,2,3,mock_opts)
+      expect(inst).to receive(:crud_get).with(1,2,3,mock_opts)
+      expect(inst).not_to receive(:crud_get_all).with(1,2,mock_opts)
+
+      inst.crud_api(1,2,3,mock_opts)
+    end
+  end
+
+  describe '#crud_options' do
+    it 'should call get_defaults and options' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:options) do |resname, &block|
+        expect(resname).to eq('/resource')
+        expect(block.call).to eq(204)
+      end
+
+      inst.crud_options('resource', mock_opts)
+    end
+  end
+
+  describe '#crud_put' do
+    it 'should call get_defaults and options, return 404 if record doesnt exist' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:put) do |resname, &block|
+        expect(resname).to eq('/resource/:primary')
+
+        settings = OpenStruct.new
+        service = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(settings).to receive(:send).with('service').and_return(service)
+
+        expect(inst).to receive(:params).and_return({:primary=>34567})
+        expect(service).to receive(:exists_by_primary_key?).with(34567).and_return(false)
+        block.call
+
+      end
+
+      expect(inst.crud_put('resource','service','primary',mock_opts)).to eq(404)
+    end
+
+    it 'should call get_defaults and options, return 422 if JSON parse fails' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:put) do |resname, &block|
+        expect(resname).to eq('/resource/:primary')
+
+        settings = OpenStruct.new
+        service = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(settings).to receive(:send).with('service').and_return(service)
+
+        expect(inst).to receive(:params).and_return({:primary=>34567})
+        expect(service).to receive(:exists_by_primary_key?).with(34567).and_return(true)
+
+        request = OpenStruct.new({:body=>OpenStruct.new({:read => '{"one":1'})})
+        expect(inst).to receive(:request).and_return(request)
+
+        block.call
+      end
+
+      expect(inst.crud_put('resource','service','primary',mock_opts)).to eq(422)
+    end
+
+    it 'should call get_defaults and options, return 500 if update fails' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:put) do |resname, &block|
+        expect(resname).to eq('/resource/:primary')
+
+        settings = OpenStruct.new
+        service = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(settings).to receive(:send).with('service').and_return(service)
+
+        expect(inst).to receive(:params).twice.and_return({:primary=>34567})
+        expect(service).to receive(:exists_by_primary_key?).with(34567).and_return(true)
+
+        request = OpenStruct.new({:body=>OpenStruct.new({:read => '{"one":1}'})})
+        expect(inst).to receive(:request).and_return(request)
+
+        expect(service).to receive(:valid_update?).with({"one"=>1}).and_return(true)
+
+        expect(service).to receive(:update_by_primary_key).with(34567, {"one"=>1}).and_return(nil)
+
+        block.call
+      end
+
+      expect(inst.crud_put('resource','service','primary',mock_opts)).to eq(500)
+    end
+
+    it 'should call get_defaults and options, return JSON string of record' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:put) do |resname, &block|
+        expect(resname).to eq('/resource/:primary')
+
+        settings = OpenStruct.new
+        service = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(settings).to receive(:send).with('service').and_return(service)
+
+        expect(inst).to receive(:params).twice.and_return({:primary=>34567})
+        expect(service).to receive(:exists_by_primary_key?).with(34567).and_return(true)
+
+        request = OpenStruct.new({:body=>OpenStruct.new({:read => '{"one":1}'})})
+        expect(inst).to receive(:request).and_return(request)
+
+        expect(service).to receive(:valid_update?).with({"one"=>1}).and_return(true)
+
+        expect(service).to receive(:update_by_primary_key).with(34567, {"one"=>1}).and_return({"two"=>2})
+
+        block.call
+      end
+
+      expect(inst.crud_put('resource','service','primary',mock_opts)).to eq('{"two":2}')
+    end
+  end
+
+  describe '#crud_get' do
+    it 'should call get_defaults and options, return 400 if bad query' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:get) do |resname, &block|
+        expect(resname).to eq('/resource/:primary')
+
+        service = OpenStruct.new
+        settings = OpenStruct.new("service_name" => service)
+        params = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(inst).to receive(:params).twice.and_return(params)
+
+        expect(inst).to receive(:sanitize_params).with(params)
+        expect(service).to receive(:valid_query?).with(params).and_return(false)
+
+        block.call
+      end
+
+      expect(inst.crud_get('resource','service_name','primary',mock_opts)).to eq(400)
+    end
+
+    it 'should call get_defaults and options, return 404 if not found' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:get) do |resname, &block|
+        expect(resname).to eq('/resource/:primary')
+
+        service = OpenStruct.new
+        settings = OpenStruct.new("service_name" => service)
+        params = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(inst).to receive(:params).thrice.and_return(params)
+
+        expect(inst).to receive(:sanitize_params).with(params)
+        expect(service).to receive(:valid_query?).with(params).and_return(true)
+
+        expect(service).to receive(:get_one_by_query).with(params).and_return(nil)
+
+        block.call
+      end
+
+      expect(inst.crud_get('resource','service_name','primary',mock_opts)).to eq(404)
+    end
+
+    it 'should call get_defaults and options, return 404 if not found' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:get) do |resname, &block|
+        expect(resname).to eq('/resource/:primary')
+
+        service = OpenStruct.new
+        settings = OpenStruct.new("service_name" => service)
+        params = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(inst).to receive(:params).thrice.and_return(params)
+
+        expect(inst).to receive(:sanitize_params).with(params)
+        expect(service).to receive(:valid_query?).with(params).and_return(true)
+
+        expect(service).to receive(:get_one_by_query).with(params).and_return({"three"=>3})
+
+        block.call
+      end
+
+      expect(inst.crud_get('resource','service_name','primary',mock_opts)).to eq('{"three":3}')
+    end
+  end
+
+  describe '#crud_get_all' do
+    it 'should call get_defaults and options, return 400 if bad query' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:get) do |resname, &block|
+        expect(resname).to eq('/resource')
+
+        service = OpenStruct.new
+        settings = OpenStruct.new("service_name" => service)
+        params = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(inst).to receive(:params).twice.and_return(params)
+
+        expect(inst).to receive(:sanitize_params).with(params)
+        expect(service).to receive(:valid_query?).with(params).and_return(false)
+
+        block.call
+      end
+
+      expect(inst.crud_get_all('resource','service_name',mock_opts)).to eq(400)
+    end
+
+    it 'should call get_defaults and options, return JSON string from records' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:get) do |resname, &block|
+        expect(resname).to eq('/resource')
+
+        service = OpenStruct.new
+        settings = OpenStruct.new("service_name" => service)
+        params = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(inst).to receive(:params).thrice.and_return(params)
+
+        expect(inst).to receive(:sanitize_params).with(params)
+        expect(service).to receive(:valid_query?).with(params).and_return(true)
+
+        expect(service).to receive(:get_all_by_query).with(params).and_return([{"three"=>3}])
+
+        block.call
+      end
+
+      expect(inst.crud_get_all('resource','service_name',mock_opts)).to eq('[{"three":3}]')
+    end
+  end
+
+  describe '#crud_delete' do
+    it 'should call get_defaults and options, return 404 if not found' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:delete) do |resname, &block|
+        expect(resname).to eq('/resource/:primary')
+
+        service = OpenStruct.new
+        settings = OpenStruct.new("service_name" => service)
+        params = OpenStruct.new({"primary"=>6})
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(inst).to receive(:params).and_return(params)
+
+        expect(service).to receive(:exists_by_primary_key?).with(6).and_return(false)
+
+        block.call
+      end
+
+      expect(inst.crud_delete('resource','service_name','primary',mock_opts)).to eq(404)
+    end
+
+    it 'should call get_defaults and options, return 500 if record failed to delete' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:delete) do |resname, &block|
+        expect(resname).to eq('/resource/:primary')
+
+        service = OpenStruct.new
+        settings = OpenStruct.new("service_name" => service)
+        params = OpenStruct.new({"primary"=>6})
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(inst).to receive(:params).twice.and_return(params)
+
+        expect(service).to receive(:exists_by_primary_key?).with(6).and_return(true)
+        expect(service).to receive(:delete_by_primary_key).with(6).and_return(false)
+
+        block.call
+      end
+
+      expect(inst.crud_delete('resource','service_name','primary',mock_opts)).to eq(500)
+    end
+
+    it 'should call get_defaults and options, return 204 if record deletes ok' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:delete) do |resname, &block|
+        expect(resname).to eq('/resource/:primary')
+
+        service = OpenStruct.new
+        settings = OpenStruct.new("service_name" => service)
+        params = OpenStruct.new({"primary"=>6})
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(inst).to receive(:params).twice.and_return(params)
+
+        expect(service).to receive(:exists_by_primary_key?).with(6).and_return(true)
+        expect(service).to receive(:delete_by_primary_key).with(6).and_return(true)
+
+        block.call
+      end
+
+      expect(inst.crud_delete('resource','service_name','primary',mock_opts)).to eq(204)
+    end
+  end
+
+  describe '#crud_put' do
+    it 'should call get_defaults and options, return 422 if body parse fails' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:post) do |resname, &block|
+        expect(resname).to eq('/resource')
+
+        settings = OpenStruct.new
+        service = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(settings).to receive(:send).with('service').and_return(service)
+
+        request = OpenStruct.new({:body=>OpenStruct.new({:read => '{"one":1'})})
+        expect(inst).to receive(:request).and_return(request)
+        block.call
+      end
+
+      expect(inst.crud_post('resource','service','primary',mock_opts)).to eq(422)
+    end
+
+    it 'should call get_defaults and options, return 422 if non valid insert' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:post) do |resname, &block|
+        expect(resname).to eq('/resource')
+
+        settings = OpenStruct.new
+        service = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(settings).to receive(:send).with('service').and_return(service)
+
+        request = OpenStruct.new({:body=>OpenStruct.new({:read => '{"one":1}'})})
+        expect(inst).to receive(:request).and_return(request)
+
+        expect(service).to receive(:valid_insert?).with({"one"=>1}).and_return(false)
+
+        block.call
+      end
+
+      expect(inst.crud_post('resource','service','one',mock_opts)).to eq(422)
+    end
+
+    it 'should call get_defaults and options, return 409 if pk already exists' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:post) do |resname, &block|
+        expect(resname).to eq('/resource')
+
+        settings = OpenStruct.new
+        service = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(settings).to receive(:send).with('service').and_return(service)
+
+        request = OpenStruct.new({:body=>OpenStruct.new({:read => '{"one":1}'})})
+        expect(inst).to receive(:request).and_return(request)
+
+        expect(service).to receive(:valid_insert?).with({"one"=>1}).and_return(true)
+        expect(service).to receive(:exists_by_primary_key?).with(1).and_return(true)
+
+        block.call
+      end
+
+      expect(inst.crud_post('resource','service','one',mock_opts)).to eq(409)
+    end
+
+    it 'should call get_defaults and options, return 500 if record fails to insert' do
+      mock_opts = { :enable_get_all=>false }
+
+      inst = TestAPI.new
+
+      expect(inst).to receive(:get_defaults).with(mock_opts)
+      expect(inst).to receive(:post) do |resname, &block|
+        expect(resname).to eq('/resource')
+
+        settings = OpenStruct.new
+        service = OpenStruct.new
+        expect(inst).to receive(:settings).and_return(settings)
+        expect(settings).to receive(:send).with('service').and_return(service)
+
+        request = OpenStruct.new({:body=>OpenStruct.new({:read => '{"one":1}'})})
+        expect(inst).to receive(:request).and_return(request)
+
+        expect(service).to receive(:valid_insert?).with({"one"=>1}).and_return(true)
+        expect(service).to receive(:exists_by_primary_key?).with(1).and_return(false)
+        expect(service).to receive(:insert).with({"one"=>1}).and_return({"five"=>5})
+
+        block.call
+      end
+
+      expect(inst.crud_post('resource','service','one',mock_opts)).to eq("{\"five\":5}")
+    end
+
+  end
+end