sqlcached_client 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f642ec5bff84d1fb7738aff7fedad4d695e8224
-  data.tar.gz: 0168729e04f2d4eca81b5159e09efaa8c0cedd5f
+  metadata.gz: 76ca46c57afc585a8a3ba673e64992b765534fde
+  data.tar.gz: 2be70c7d54517dd4a3d3bedb833572592b3bfea0
 SHA512:
-  metadata.gz: 5a96a6163594e8a34a86e93b503552d453bd67b0ff96ef4da4b97386da954fdf767504acf3876b1903bf06e18e3e519bc940ca60b3ded5f63fc2bbc34e813361
-  data.tar.gz: d494b4126fa2e8fb60ddfa7562675b48e6f94e9fd9474f2712d51631a11117905c3d9934fe2250b1f1ea4f9bfed498916697d672ec065c8bcbfd632e442f8097
+  metadata.gz: 6f797a555a1f56561da3a56c535ddd8f0822e6636cfa5d3b2bc648cff9e99f51cc0d8e215c1aca398ba381e5ed87b5f24f64b5cebd59ddec6b688fa475aef895
+  data.tar.gz: cfa1fa922a25c58a327361e0561b7fd5d4391562f4f125ac32cd16bb1a7de6252b2db9655767843847ae448f6550567152f74fea1000e498b6dba11776bae0a1

data/lib/sqlcached_client/entity.rb

@@ -17,14 +17,19 @@ module SqlcachedClient
     class << self
       attr_reader :query_id
 
+      # Sets the name of this entity
       def entity_name(value)
         @query_id = value
       end
 
+      # Sets the query of this entity if a parameter is provided, otherwise
+      # returns the value previously set.
       def query(sql_string = nil)
         sql_string.nil? ? @query : @query = sql_string.strip
       end
 
+      # Configures the server of this entity if a parameter is provided,
+      # otherwise returns the server object previously set.
       def server(config = nil)
         if config.nil?
           @server ||
@@ -43,17 +48,40 @@ module SqlcachedClient
         end
       end
 
+      # Gets a session from the server and yields the passed block
+      def server_session(&block)
+        server.session(&block)
+      end
+
+      # Runs the entity query with the provided parameters
+      # @return [Resultset]
       def where(params, dry_run = false)
         request = server.format_request(query_id, query, params)
         if dry_run
           request
         else
-          data = server.run_query(server.build_request_body([request]))
+          data =
+            server.session do |server, session|
+              server.run_query(session, server.build_request_body([request]))
+            end
           data = data[0] if data.is_a?(Array)
           Resultset.new(self, data)
         end
       end
 
+      # Defines a 'has_many' relationship. Available options are
+      # [class_name]
+      #   Specifies the class of the associated objects, if not given it's
+      #   inferred from the accessor_name (singularized + camelized).
+      # [where]
+      #   Specifies how to fill the query template for the associated objects.
+      #   It's an hash where each key is a foreign parameter that will be
+      #   set to the value provided. A special case occours when the value is
+      #   a Symbol, in this case it represents the value of the attribute named
+      #   as the symbol.
+      #   For example, <tt>where: { id: :user_id }</tt> fills the parameter
+      #   <tt>id</tt> of the foreign entity with the value of
+      #   <tt>self.user_id</tt>.
       def has_many(accessor_name, options)
         foreign_class_name =
           if options[:class_name].present?
@@ -100,6 +128,8 @@ module SqlcachedClient
         register_association(accessor_name)
       end
 
+      # Defines a 'has_one' relationship. See 'has_many' for the available
+      # options
       def has_one(accessor_name, options)
         plural_accessor_name = "s_#{accessor_name}".to_s.pluralize
         class_name = accessor_name.to_s.camelize

data/lib/sqlcached_client/resultset.rb

@@ -22,12 +22,13 @@ module SqlcachedClient
 
     class << self
 
-      def build_associations(resultsets, server, max_depth, current_depth = 0)
+      def build_associations(resultsets, server, session, max_depth, current_depth = 0)
         if resultsets.any?
           batch = resultsets.map { |r| r._get_entities_association_requests }
           if batch.flatten.any?
             next_batch =
               server.run_query(
+                session,
                 server.build_request_body(
                   batch
                 )
@@ -35,7 +36,8 @@ module SqlcachedClient
                 resultsets[i]._fill_associations(resultset_data)
               end.flatten!
             if !max_depth || current_depth < max_depth
-              build_associations(next_batch, server, max_depth, current_depth + 1)
+              build_associations(next_batch, server, session, max_depth,
+                current_depth + 1)
             end
           end
         end
@@ -55,7 +57,9 @@ module SqlcachedClient
     end
 
     def build_associations(max_depth = false)
-      self.class.build_associations([self], entity_class.server, max_depth)
+      entity_class.server_session do |server, session|
+        self.class.build_associations([self], server, session, max_depth)
+      end
     end
 
     def _fill_associations(data)

data/lib/sqlcached_client/server.rb

@@ -12,23 +12,20 @@ module SqlcachedClient
     end
 
 
-    def run_query(http_req_body)
-      url = server_url
-      Net::HTTP.start(url.host, url.port) do |http|
-        req = Net::HTTP::Post.new(data_batch_url)
-        req.set_content_type('application/json')
-        req.body = http_req_body.to_json
-        resp = http.request(req)
-        if 'application/json' == resp['Content-Type']
-          resp_body = parse_response_body(JSON.parse(resp.body))
-        else
-          resp_body = resp.body
-        end
-        if 200 == resp.code.to_i
-          resp_body
-        else
-          raise "Got http response #{resp.code} from server - #{resp_body.inspect}"
-        end
+    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 'application/json' == resp['Content-Type']
+        resp_body = parse_response_body(JSON.parse(resp.body))
+      else
+        resp_body = resp.body
+      end
+      if 200 == resp.code.to_i
+        resp_body
+      else
+        raise "Got http response #{resp.code} from server - #{resp_body.inspect}"
       end
     end
 
@@ -61,6 +58,20 @@ module SqlcachedClient
       }
     end
 
+
+    def get_session
+      url = server_url
+      Net::HTTP.start(url.host, url.port)
+    end
+
+
+    def session
+      s = get_session
+      ret_value = yield(self, s) if block_given?
+      s.finish
+      ret_value
+    end
+
   private
 
     def server_url

data/lib/sqlcached_client/version.rb

@@ -1,3 +1,3 @@
 module SqlcachedClient
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/sqlcached_client/entity_spec.rb

@@ -0,0 +1,150 @@
+require 'sqlcached_client/entity'
+require 'sqlcached_client/server'
+
+describe SqlcachedClient::Entity do
+
+  describe :initialize do
+    it "should record the attribute names" do
+      e = SqlcachedClient::Entity.new({ foo: 'bar', baz: 'biz' })
+      expect(e.attribute_names).to eq([:foo, :baz])
+    end
+  end
+
+
+  describe :entity_name do
+    it "should set query_id" do
+      entity_class = Class.new(SqlcachedClient::Entity) do
+        entity_name("foo")
+      end
+      expect(entity_class.query_id).to eq("foo")
+    end
+  end
+
+
+  describe :query do
+    context "if a parameter is provided" do
+      it "should set @query and strip spaces" do
+        entity_class = Class.new(SqlcachedClient::Entity) do
+          query("  foo \n  ")
+        end
+        expect(entity_class.instance_variable_get(:@query)).to eq("foo")
+      end
+    end
+
+    context "if no parameter is provided" do
+      it "should return the value previously stored" do
+        entity_class = Class.new(SqlcachedClient::Entity) do
+          query("  foo \n  ")
+        end
+        expect(entity_class.query).to eq("foo")
+      end
+    end
+  end
+
+
+  describe :server do
+    context "if a parameter is provided" do
+      it "should set @server" do
+        entity_class = Class.new(SqlcachedClient::Entity) do
+          server("foo")
+        end
+        expect(entity_class.instance_variable_get(:@server)).to eq("foo")
+      end
+
+      context "if the parameter is an hash" do
+        it "should instantiate a new Server" do
+          entity_class = Class.new(SqlcachedClient::Entity) do
+            server(foo: "bar")
+          end
+          expect(entity_class.server).to be_instance_of(SqlcachedClient::Server)
+        end
+      end
+    end
+
+    context "if no parameter is provided" do
+      it "should return the value previously stored" do
+        entity_class = Class.new(SqlcachedClient::Entity) do
+          server("foo")
+        end
+        expect(entity_class.server).to eq("foo")
+      end
+
+      context "if no server was configured for the class" do
+        it "should use the value from the first ancestor" do
+          entity_class0 = Class.new(SqlcachedClient::Entity) do
+            server("foo")
+          end
+          entity_class1 = Class.new(entity_class0)
+          expect(entity_class1.server).to eq("foo")
+        end
+      end
+    end
+  end
+
+
+  describe :where do
+    let(:entity_class) do
+      Class.new(SqlcachedClient::Entity) do
+        entity_name 'foo'
+        query 'bar'
+      end
+    end
+
+    context "if dry_run" do
+      it "should return the request that would be sent to the server" do
+        entity_class.server(double(format_request: "this is the request"))
+        expect(entity_class.server).to receive(:format_request).with("foo", "bar", { baz: "biz" })
+        expect(entity_class.where({ baz: "biz" }, true)).to eq("this is the request")
+      end
+    end
+
+    context "if not dry_run" do
+      it "should create a new ResultSet" do
+        entity_class.server(double(
+          format_request: "this is the request",
+          build_request_body: "request body",
+          session: [[{ key: "value" }], 2, 3]
+        ))
+        expect(entity_class.server).to receive(:format_request).with(
+          "foo", "bar", { baz: "biz" })
+        expect(entity_class.where({ baz: "biz" })).to be_instance_of(
+          SqlcachedClient::Resultset)
+      end
+    end
+  end
+
+
+  describe :has_many do
+    pending
+  end
+
+
+  describe :has_one do
+    pending
+  end
+
+
+  describe :get_association_requests do
+    pending
+  end
+
+
+  describe :set_associations_data do
+    pending
+  end
+
+
+  describe :get_associations do
+    pending
+  end
+
+
+  describe :build_associations do
+    pending
+  end
+
+
+  describe :to_h do
+    pending
+  end
+end

data/spec/sqlcached_client/resultset_spec.rb

@@ -0,0 +1,43 @@
+require 'sqlcached_client/resultset'
+require 'sqlcached_client/hash_struct'
+
+describe SqlcachedClient::Resultset do
+
+  describe :initialize do
+
+    it "should set count" do
+      r = SqlcachedClient::Resultset.new(Object, [Object.new] * 3)
+      expect(r.count).to eq(3)
+    end
+
+    context "when passed entities are hashes" do
+      it "should map them to instances of the entity class provided" do
+        r = SqlcachedClient::Resultset.new(SqlcachedClient::HashStruct,
+          [{ foo: 'bar' }] * 3)
+        expect(r.entities[0]).to be_instance_of(SqlcachedClient::HashStruct)
+      end
+    end
+
+    context "when passing entities that are instances of the class" do
+      it "should set them without do anything" do
+        entities = [Object.new] * 3
+        r = SqlcachedClient::Resultset.new(Object, entities)
+        expect(r.entities).to eq(entities)
+      end
+    end
+  end
+
+
+  describe :build_associations do
+    pending
+  end
+
+
+  describe :[] do
+    it "should be entities[i]" do
+      entities = [Object.new] * 3
+      r = SqlcachedClient::Resultset.new(Object, entities)
+      3.times { |i| expect(r[i]).to eq(entities[i]) }
+    end
+  end
+end

data/spec/sqlcached_client/server_spec.rb

@@ -0,0 +1,62 @@
+require 'sqlcached_client/server'
+
+describe SqlcachedClient::Server do
+
+  let(:server) { SqlcachedClient::Server.new({}) }
+
+  describe :initialize do
+    it "should set host and port" do
+      server = SqlcachedClient::Server.new(host: "localhost", port: 80)
+      expect(server.host).to eq("localhost")
+      expect(server.port).to eq(80)
+    end
+  end
+
+
+  describe :build_request_body do
+    it "should put the passed value into an hash" do
+      expect(server.build_request_body("foo")).to eq({ batch: "foo" })
+    end
+  end
+
+
+  describe :format_request do
+    it "should be an hash with id, template, params keys" do
+      expect(server.format_request("foo", "bar", "baz")).to eq({
+        queryId: "foo",
+        queryTemplate: "bar",
+        queryParams: "baz"
+      })
+    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
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sqlcached_client
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Roberto Maestroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-28 00:00:00.000000000 Z
+date: 2015-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -84,7 +84,10 @@ files:
 - lib/sqlcached_client/resultset.rb
 - lib/sqlcached_client/server.rb
 - lib/sqlcached_client/version.rb
+- spec/sqlcached_client/entity_spec.rb
 - spec/sqlcached_client/hash_struct_spec.rb
+- spec/sqlcached_client/resultset_spec.rb
+- spec/sqlcached_client/server_spec.rb
 - sqlcached_client.gemspec
 homepage: https://github.com/rmaestroni/sqlcached_client
 licenses:
@@ -111,4 +114,7 @@ signing_key:
 specification_version: 4
 summary: A Ruby client for sqlcached
 test_files:
+- spec/sqlcached_client/entity_spec.rb
 - spec/sqlcached_client/hash_struct_spec.rb
+- spec/sqlcached_client/resultset_spec.rb
+- spec/sqlcached_client/server_spec.rb