sqlcached_client 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b748c4321404ba53adfea1f54149b8940e639b3e
-  data.tar.gz: 1aa280da099b3775b1f1573f3ff1f1a22d9db614
+  metadata.gz: e1f725ac30395fee0332b228f2f7afba9a8e3f63
+  data.tar.gz: 6c8f3618babaf1f18b1295d75bb86a89c84007ca
 SHA512:
-  metadata.gz: d19236cb3ede1bde65802ea4d6453bd4624a16c5d629a1bb91f65b59273701e9de81c66245ed947d40e86188ee43c9482c5f61ef397b7c9cb01786bcb316aed6
-  data.tar.gz: a12f68121d759e630c16873967b7413d1c2b5135e556a33dd49f366c365a4f0ac12663682dc86757c805b7c0dd161309d923416e5a628228ec9a425b1ea0dbc1
+  metadata.gz: e7759cc739a2e3d14bc63c294b84cc1096ed7c97f877e4e86210d3e792bfc61e95cab515b7a7a0362e87aaab382cad539305e5caf0eaf0beacdd8aeb860a848b
+  data.tar.gz: 26d535fd6114978514c5b726755bdfd69a30458955a31259ccfc4f86d6baf7dc1dde767f501e392c91cad7e7ffb62077f03e6eaba14e9705fb7998bb2bce9915

data/lib/sqlcached_client/attachment.rb

@@ -0,0 +1,54 @@
+require 'active_support/core_ext/hash'
+
+module SqlcachedClient
+  class Attachment
+
+    PREDICATES = ['=', '<=', '>']
+
+    attr_reader :name, :conditions
+    attr_accessor :content
+
+    # @param conditions [Hash] { var_1: 'value 1', var_2: 'value 2' }
+    def initialize(name, conditions, content)
+      @name = name
+      @conditions = conditions.with_indifferent_access
+      @content = content
+    end
+
+    class << self
+
+      attr_reader :variables
+
+      def add_variable(variable_name, predicate)
+        raise "Invalid predicate" if !PREDICATES.include?(predicate)
+        @variables = [] if @variables.nil?
+        @variables << OpenStruct.new(name: variable_name, predicate: predicate)
+      end
+
+      alias_method :depends_on, :add_variable
+    end # class << self
+
+    def variables
+      self.class.variables
+    end
+
+    def to_query_format
+      {
+        name: name,
+        condition_values: Hash[
+          variables.map { |v| [v.name, conditions[v.name]] }
+        ]
+      }
+    end
+
+    def to_save_format
+      {
+        name: name,
+        attachment: content,
+        conditions: variables.map do |v|
+          "#{v.name} #{v.predicate} #{conditions[v.name]}"
+        end
+      }
+    end
+  end
+end

data/lib/sqlcached_client/attachments.rb

@@ -0,0 +1,36 @@
+require 'sqlcached_client/attachment'
+
+module SqlcachedClient
+  module Attachments
+
+    module ClassMethods
+
+      def has_attachment(name, &block)
+        @attachment_classes ||= {}
+        @attachment_classes[name] =
+          Class.new(Attachment) do
+
+            @attachment_name = name
+            class << self
+              attr_reader :attachment_name
+            end
+
+            def initialize(conditions, content)
+              super(self.class.attachment_name, conditions, content)
+            end
+
+            instance_exec(&block)
+          end
+        attr_accessor(name)
+      end
+
+      def build_attachments(name, conditions, size)
+        size.times.map { @attachment_classes[name].new(conditions, nil) }
+      end
+    end # module ClassMethods
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/sqlcached_client/entity.rb

@@ -2,6 +2,7 @@ require 'sqlcached_client/resultset'
 require 'sqlcached_client/server'
 require 'sqlcached_client/arel'
 require 'sqlcached_client/tree_visitor'
+require 'sqlcached_client/proxy_object'
 
 module SqlcachedClient
   class Entity
@@ -85,6 +86,19 @@ module SqlcachedClient
         server.session(&block)
       end
 
+
+      def transaction(&block)
+        proxy = ProxyObject.new(self)
+        srv_local = server
+        session = server.get_session
+        proxy.plug_method(:server_session) do |server_session_block|
+          instance_exec(srv_local, session, &server_session_block)
+        end
+        result = proxy.execute(srv_local, session, &block)
+        session.finish
+        result
+      end
+
       # Runs the entity query with the provided parameters
       # @return [Resultset]
       def where(params, dry_run = false)
@@ -102,14 +116,14 @@ module SqlcachedClient
         if dry_run
           request
         else
-          data =
-            server.session do |server, session|
+          server_resp =
+            server_session do |server, session|
               server.run_query(session, server.build_request(
                 request.is_a?(Array) ? request : [request]
               ))
             end
-          data.flatten!(1) if data.is_a?(Array)
-          Resultset.new(self, data)
+          server_resp.flatten!(1) if server_resp.is_array?
+          Resultset.new(self, server_resp)
         end
       end
 
@@ -272,14 +286,24 @@ module SqlcachedClient
       # Like 'where' but loads every associated entity recursively at any level,
       #   with only one interaction with the server
       # @param root_conditions [Array]
-      def load_tree(root_conditions)
-        server.session do |server, session|
+      def load_tree(root_conditions, attachment_name = nil,
+          attachment_conditions = nil)
+        attachments =
+          if attachment_name.present?
+            build_attachments(attachment_name, attachment_conditions,
+              root_conditions.size)
+          else
+            nil
+          end
+        server_session do |server, session|
           Resultset.new(
             self,
             server.run_query(
               session,
-              server.build_tree_request(build_query_tree, root_conditions)
-            )
+              server.build_tree_request(build_query_tree, root_conditions,
+                attachments)
+            ),
+            attachments
           )
         end
       end

data/lib/sqlcached_client/proxy_object.rb

@@ -0,0 +1,29 @@
+module SqlcachedClient
+  class ProxyObject < BasicObject
+
+    def initialize(context)
+      @context = context
+    end
+
+    def method_missing(symbol, *args)
+      @context.send(symbol, *args)
+    end
+
+    def execute(*args, &block)
+      instance_exec(*args, &block)
+    end
+
+    def plug_method(method_name, &method_body)
+      memoize_var = "@m_#{method_name}"
+      instance_variable_set(memoize_var, method_body)
+      eval(
+        <<-RUBY
+          def self.#{method_name}(*args, &block)
+            instance_exec(*args, block, &#{memoize_var})
+          end
+        RUBY
+      )
+      method_name.to_sym
+    end
+  end
+end

data/lib/sqlcached_client/resultset.rb

@@ -5,10 +5,13 @@ module SqlcachedClient
     attr_reader :entity_class, :entities, :count
 
     # @param entity_class [Class]
-    # @param entities [Array]
-    def initialize(entity_class, entities)
+    # @param data [Array] or [ServerResponse]
+    def initialize(entity_class, data, attachments = nil)
+      # set entity class
       @entity_class = entity_class
-      @entities = (entities || []).map do |item|
+      # build the entities
+      ents = data.respond_to?(:entities) ? data.entities : data
+      @entities = (ents || []).map do |item|
         if item.is_a?(Hash)
           entity_class.new(item)
         elsif item.is_a?(entity_class)
@@ -17,7 +20,10 @@ module SqlcachedClient
           raise "Cannot handle: #{item.inspect}"
         end
       end
+      # record collection size
       @count = @entities.size
+      # set up attachments
+      set_entities_attachments(@entities, attachments, data.try(:attachments))
     end
 
     class << self
@@ -69,5 +75,28 @@ module SqlcachedClient
         entity.get_association_requests
       end
     end
+
+    def set_entities_attachments(entities, attachments, contents)
+      if attachments.is_a?(Array) && contents.is_a?(Array)
+        entities.each_with_index do |entity, i|
+          attachment = attachments[i]
+          entity.send("#{attachment.name}=", attachment)
+          attachment.content = contents[i] if attachment.respond_to?(:content=)
+        end
+      end
+    end
+
+    def store_attachments(attachment_name, server, session)
+      entities_with_a = entities.select do |entity|
+        !entity.send(attachment_name).nil?
+      end
+      server.store_attachments(
+        session,
+        server.build_store_attachments_request(
+          entities_with_a.map { |e| e.attributes },
+          entities_with_a.map { |e| e.send(attachment_name).to_save_format }
+        )
+      )
+    end
   end
 end

data/lib/sqlcached_client/server.rb

@@ -1,6 +1,7 @@
 require 'uri'
 require 'net/http'
 require 'json'
+require 'sqlcached_client/server_responses/query_response'
 
 module SqlcachedClient
   class Server
@@ -12,37 +13,32 @@ module SqlcachedClient
       @port = config[:port]
     end
 
-
+    # @return [ServerResponses::QueryResponse]
     def run_query(session, http_req_body)
       req = Net::HTTP::Post.new(data_batch_url)
       req.set_content_type('application/json')
       req.body = http_req_body.to_json
       resp = session.request(req)
-      if (resp['Content-Type'] || '') =~ /application\/json/
-        resp_body = parse_response_body(JSON.parse(resp.body))
-      else
-        resp_body = resp.body
-      end
+      resp_body =
+        if (resp['Content-Type'] || '') =~ /application\/json/
+          JSON.parse(resp.body)
+        else
+          resp.body
+        end
       if 200 == resp.code.to_i
-        resp_body
+        ServerResponses::QueryResponse.new(resp_body)
       else
         raise "Got HTTP response #{resp.code} from server - #{resp_body.inspect}"
       end
     end
 
 
-    def parse_response_body(body)
-      if body.is_a?(Array)
-        body.map { |item| parse_response_body(item) }
-      elsif body.is_a?(Hash)
-        if (resultset = body['resultset']).is_a?(String)
-          JSON.parse(resultset)
-        else
-          resultset
-        end
-      else
-        body
-      end
+    def store_attachments(session, http_req_body)
+      req = Net::HTTP::Post.new(store_attachments_url)
+      req.set_content_type('application/json')
+      req.body = http_req_body.to_json
+      resp = session.request(req)
+      201 == resp.code.to_i || raise("Failed to save attachments - server answered with #{resp.body.inspect}")
     end
 
     # Builds a 'standard' request body
@@ -56,8 +52,12 @@ module SqlcachedClient
     # @param tree [Hash]
     # @param root_parameters [Array] a vector of actual condition parameters
     #   for the root query
-    def build_tree_request(tree, root_parameters)
-      { tree: tree, root_parameters: root_parameters }
+    def build_tree_request(tree, root_parameters, attachments = nil)
+      h = { tree: tree, root_parameters: root_parameters }
+      if !attachments.nil?
+        h[:attachments] = attachments.map(&:to_query_format)
+      end
+      h
     end
 
     # Formats the parameters passed in the way the server expects
@@ -75,6 +75,14 @@ module SqlcachedClient
       }
     end
 
+
+    def build_store_attachments_request(entities, attachments)
+      {
+        resultset: entities,
+        attachments: attachments
+      }
+    end
+
     # @return [Net::HTTP] an http session on the server
     def get_session
       url = server_url
@@ -99,7 +107,13 @@ module SqlcachedClient
 
     def data_batch_url
       url = server_url
-      url.path = "/data-batch"
+      url.path = '/data-batch'
+      url
+    end
+
+    def store_attachments_url
+      url = server_url
+      url.path = '/resultset-attachments'
       url
     end
   end

data/lib/sqlcached_client/server_responses/query_response.rb

@@ -0,0 +1,52 @@
+module SqlcachedClient
+  module ServerResponses
+
+    class QueryResponse
+      include Enumerable
+
+      attr_reader :body
+
+      # @param body [Hash]
+      def initialize(body)
+        @body = body
+      end
+
+      def each(&block)
+        block ? entities.each(&block) : entities.each
+      end
+
+      def attachments
+        body.is_a?(Hash) ? body['attachments'] : nil
+      end
+
+      def entities
+        @entities ||= get_entities(body)
+      end
+
+      def is_array?
+        entities.is_a?(Array)
+      end
+
+      def flatten!(level = nil)
+        entities if @entities.nil?
+        @entities.flatten!(level)
+      end
+
+    private
+
+      def get_entities(data)
+        if data.is_a?(Array)
+          data.map { |item| get_entities(item) }
+        elsif data.is_a?(Hash)
+          if (resultset = data['resultset']).is_a?(String)
+            JSON.parse(resultset)
+          else
+            resultset
+          end
+        else
+          data
+        end
+      end
+    end # class QueryResponse
+  end
+end

data/lib/sqlcached_client/version.rb

@@ -1,3 +1,3 @@
 module SqlcachedClient
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/spec/sqlcached_client/attachment_spec.rb

@@ -0,0 +1,68 @@
+require 'sqlcached_client/attachment'
+
+describe SqlcachedClient::Attachment do
+
+  let(:described_class) { SqlcachedClient::Attachment }
+
+  describe :initialize do
+    it "accepts name, conditions and content" do
+      attachment = described_class.new('name', { 'foo' => 'bar'}, 'content')
+      expect(attachment.name).to eq('name')
+      expect(attachment.conditions).to eq({ 'foo' => 'bar' })
+      expect(attachment.content).to eq('content')
+    end
+  end
+
+  describe :variables do
+    it "returns the variables added to the class" do
+      attachment = described_class.new(nil, {}, nil)
+      allow(described_class).to receive(:variables).and_return('foo')
+      expect(attachment.variables).to eq('foo')
+    end
+  end
+
+  describe :to_query_format do
+    it "is an hash with name and condition values" do
+      attachment = described_class.new('foo', { v1: 'bar', v2: 'baz'}, nil)
+      allow(attachment).to receive(:variables).and_return([
+        double(name: 'v1'), double(name: 'v2')
+      ])
+      expect(attachment.to_query_format).to eq({
+        name: 'foo',
+        condition_values: {
+          'v1' => 'bar', 'v2' => 'baz'
+        }
+      })
+    end
+  end
+
+  describe :to_save_format do
+    it "is an hash with name, attachment and conditions" do
+      attachment = described_class.new('foo', { v1: 'bar', v2: 'baz'},
+        'content')
+      allow(attachment).to receive(:variables).and_return([
+        double(name: 'v1', predicate: '='), double(name: 'v2', predicate: '<=')
+      ])
+      expect(attachment.to_save_format).to eq({
+        name: 'foo',
+        attachment: 'content',
+        conditions: ['v1 = bar', 'v2 <= baz']
+      })
+    end
+  end
+
+  describe :add_variable do
+    it "adds a new variable in the class list" do
+      described_class.add_variable('foo', '=')
+      v = described_class.variables.first
+      expect(v.name).to eq('foo')
+      expect(v.predicate).to eq('=')
+    end
+
+    context "if predicate symbol is not allowed" do
+      it "raises an exception" do
+        expect { described_class.add_variable('foo', 'X') }.to raise_exception
+      end
+    end
+  end
+end

data/spec/sqlcached_client/attachments_spec.rb

@@ -0,0 +1,19 @@
+require 'sqlcached_client/attachments'
+
+describe SqlcachedClient::Attachments do
+  let(:klass) do
+    Class.new do
+      include SqlcachedClient::Attachments
+
+      has_attachment :foo do
+      end
+    end
+  end
+
+  context "after including the module" do
+    it "add methods 'has_attachment' and 'build_attachments' to the class" do
+      expect(klass.respond_to?(:has_attachment)).to eq(true)
+      expect(klass.respond_to?(:build_attachments)).to eq(true)
+    end
+  end
+end

data/spec/sqlcached_client/entity_spec.rb

@@ -154,7 +154,8 @@ describe SqlcachedClient::Entity do
         entity_class.server(double(
           build_request_item: "this is the request",
           build_request: "request body",
-          session: [ [{ key: "value" }], [{ key: "value" }] ]
+          session: double(is_array?: false,
+            entities: [{ key: "value" }, { key: "value" }])
         ))
         expect(entity_class.server).to receive(:build_request_item).with(
           "foo", "bar", { baz: "biz" }, true)
@@ -224,4 +225,9 @@ describe SqlcachedClient::Entity do
   describe :build_query_tree do
     pending
   end
+
+
+  describe :transaction do
+    pending
+  end
 end

data/spec/sqlcached_client/proxy_object_spec.rb

@@ -0,0 +1,35 @@
+require 'sqlcached_client/proxy_object'
+
+describe SqlcachedClient::ProxyObject do
+  let(:klass) do
+    Class.new do
+      def foo
+        'bar'
+      end
+    end
+  end
+
+  it "forwards method calls to the proxied object" do
+    f = klass.new
+    p = SqlcachedClient::ProxyObject.new(f)
+    expect(p.foo).to eq('bar')
+  end
+
+  describe :execute do
+    it "executes the block provided in the context of the instance" do
+      f = klass.new
+      p = SqlcachedClient::ProxyObject.new(f)
+      expect(p.execute { foo }).to eq('bar')
+    end
+  end
+
+  describe :plug_method do
+    it "defines a singleton method on the proxy object" do
+      p = SqlcachedClient::ProxyObject.new(Object.new)
+      p.plug_method(:sum) do |a, b|
+        a + b
+      end
+      expect(p.sum(2, 3)).to eq(5)
+    end
+  end
+end

data/spec/sqlcached_client/resultset_spec.rb

@@ -26,12 +26,10 @@ describe SqlcachedClient::Resultset do
     end
   end
 
-
   describe :build_associations do
     pending
   end
 
-
   describe :[] do
     it "should be entities[i]" do
       entities = [Object.new] * 3
@@ -39,4 +37,43 @@ describe SqlcachedClient::Resultset do
       3.times { |i| expect(r[i]).to eq(entities[i]) }
     end
   end
+
+  describe :set_entities_attachments do
+    let(:resultset) { SqlcachedClient::Resultset.new(nil, nil) }
+
+    let(:entities) do
+      [double(:attach1=)]
+    end
+
+    let(:attachment) { double(:content=, name: 'attach1') }
+
+    it "sets each attachment to the corresponding entity and saves the content" do
+      expect(entities.first).to receive(:attach1=).with(attachment)
+      expect(attachment).to receive(:content=).with('content')
+      resultset.set_entities_attachments(entities, [attachment], ['content'])
+    end
+  end
+
+  describe :store_attachments do
+    let(:resultset) { SqlcachedClient::Resultset.new(nil, nil) }
+
+    let(:entities) do
+      [
+        double(att1: double(to_save_format: 'value a'), attributes: 'attrs a'),
+        double(att1: double(to_save_format: 'value b'), attributes: 'attrs b')
+      ]
+    end
+
+    let(:server) { double }
+
+    it "calls server.store_attachments" do
+      expect(server).to receive(:build_store_attachments_request).with(
+        ['attrs a', 'attrs b'], ['value a', 'value b']
+      ).and_return('attachment request')
+      expect(server).to receive(:store_attachments).with('session',
+        'attachment request')
+      allow(resultset).to receive(:entities).and_return(entities)
+      resultset.store_attachments(:att1, server, 'session')
+    end
+  end
 end

data/spec/sqlcached_client/server_responses/query_response_spec.rb

@@ -0,0 +1,79 @@
+require 'sqlcached_client/server_responses/query_response'
+
+describe SqlcachedClient::ServerResponses::QueryResponse do
+  let(:described_class) { SqlcachedClient::ServerResponses::QueryResponse }
+
+  describe :entities do
+    context "if body is an array" do
+      it "parses each item recoursively" do
+        query_response = described_class.new([[1, 2, [3, 4]], 5])
+        expect(query_response.entities).to eq(
+          [[1, 2, [3, 4]], 5])
+      end
+    end
+
+    context "if body is an hash" do
+      it "returns the value corresponding to the key 'resultset'" do
+        query_response = described_class.new({ 'resultset' => 1 })
+        expect(query_response.entities).to eq(1)
+      end
+
+      context "if key 'resultset' is not present" do
+        it "is nil" do
+          query_response = described_class.new({ foo: 'bar' })
+          expect(query_response.entities).to be_nil
+        end
+      end
+
+      context "if resultset is a string" do
+        it "is parsed as json" do
+          query_response = described_class.new({
+            'resultset' => "{ \"foo\": \"bar\", \"baz\": 1 }"
+          })
+          expect(query_response.entities).to eq({
+            "foo" => "bar", "baz" => 1 })
+        end
+      end
+    end
+  end
+
+  describe :attachments do
+    context "when body is an Hash" do
+      it "is body.attachments" do
+        query_response = described_class.new({ 'attachments' => 'foo' })
+        expect(query_response.attachments).to eq('foo')
+      end
+    end
+
+    context "when body is not an Hash" do
+      it "is nil" do
+        query_response = described_class.new(['foo', 'bar'])
+        expect(query_response.attachments).to be_nil
+      end
+    end
+  end
+
+  describe :is_array? do
+    context "when entities is an Array" do
+      it "is true" do
+        query_response = described_class.new(['foo'])
+        expect(query_response.is_array?).to eq(true)
+      end
+    end
+
+    context "when entities is not an Array" do
+      it "is false" do
+        query_response = described_class.new({})
+        expect(query_response.is_array?).to eq(false)
+      end
+    end
+  end
+
+  describe :flatten! do
+    it "flattens the entities in place" do
+      query_response = described_class.new([[1, [2]], [3]])
+      query_response.flatten!
+      expect(query_response.entities).to eq([1, 2, 3])
+    end
+  end
+end

data/spec/sqlcached_client/server_spec.rb

@@ -12,14 +12,12 @@ describe SqlcachedClient::Server do
     end
   end
 
-
   describe :build_request do
     it "should put the passed value into an hash" do
       expect(server.build_request("foo")).to eq({ batch: "foo" })
     end
   end
 
-
   describe :build_tree_request do
     it "should be an Hash with 'tree' and 'root_parameters' keys" do
       expect(server.build_tree_request('tree', 'root')).to eq({
@@ -28,7 +26,6 @@ describe SqlcachedClient::Server do
     end
   end
 
-
   describe :build_request_item do
     it "should be an hash with id, template, params keys" do
       expect(server.build_request_item("foo", "bar", "baz", "cache")).to eq({
@@ -40,33 +37,11 @@ describe SqlcachedClient::Server do
     end
   end
 
-
-  describe :parse_response_body do
-    context "if body is an array" do
-      it "should parse each item recoursively" do
-        expect(server.parse_response_body([[1, 2, [3, 4]], 5])).to eq(
-          [[1, 2, [3, 4]], 5])
-      end
-    end
-
-    context "if body is an hash" do
-      it "should return the value corresponding to the key 'resultset'" do
-        expect(server.parse_response_body({ 'resultset' => 1 })).to eq(1)
-      end
-
-      context "if key 'resultset' is not present" do
-        it "should be nil" do
-          expect(server.parse_response_body({ foo: 'bar' })).to be_nil
-        end
-      end
-
-      context "if resultset is a string" do
-        it "should be parsed as json" do
-          expect(server.parse_response_body({
-            'resultset' => "{ \"foo\": \"bar\", \"baz\": 1 }" })).to eq({
-            "foo" => "bar", "baz" => 1 })
-        end
-      end
+  describe :build_store_attachments_request do
+    it "contains keys resultset and attachments" do
+      expect(server.build_store_attachments_request('e', 'a')).to eq({
+        resultset: 'e', attachments: 'a'
+      })
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sqlcached_client
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Roberto Maestroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-29 00:00:00.000000000 Z
+date: 2015-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -122,13 +122,21 @@ files:
 - Rakefile
 - lib/sqlcached_client.rb
 - lib/sqlcached_client/arel.rb
+- lib/sqlcached_client/attachment.rb
+- lib/sqlcached_client/attachments.rb
 - lib/sqlcached_client/entity.rb
+- lib/sqlcached_client/proxy_object.rb
 - lib/sqlcached_client/resultset.rb
 - lib/sqlcached_client/server.rb
+- lib/sqlcached_client/server_responses/query_response.rb
 - lib/sqlcached_client/tree_visitor.rb
 - lib/sqlcached_client/version.rb
+- spec/sqlcached_client/attachment_spec.rb
+- spec/sqlcached_client/attachments_spec.rb
 - spec/sqlcached_client/entity_spec.rb
+- spec/sqlcached_client/proxy_object_spec.rb
 - spec/sqlcached_client/resultset_spec.rb
+- spec/sqlcached_client/server_responses/query_response_spec.rb
 - spec/sqlcached_client/server_spec.rb
 - spec/sqlcached_client/tree_visitor_spec.rb
 - sqlcached_client.gemspec
@@ -157,7 +165,11 @@ signing_key:
 specification_version: 4
 summary: A Ruby client for sqlcached
 test_files:
+- spec/sqlcached_client/attachment_spec.rb
+- spec/sqlcached_client/attachments_spec.rb
 - spec/sqlcached_client/entity_spec.rb
+- spec/sqlcached_client/proxy_object_spec.rb
 - spec/sqlcached_client/resultset_spec.rb
+- spec/sqlcached_client/server_responses/query_response_spec.rb
 - spec/sqlcached_client/server_spec.rb
 - spec/sqlcached_client/tree_visitor_spec.rb