neuron-client 0.2.6 → 0.3.0

data/lib/neuron-client.rb

@@ -2,52 +2,40 @@ require "rubygems"
 require "tzinfo"
 require "active_support" #TODO: when we upgrade to 3.x, this can be "active_support/core_ext"
 require "active_support/core_ext"
+require "json-schema"
 require "neuron-client/version"
 require "neuron-client/admin_connection"
 require "neuron-client/membase_connection"
 require "neuron-client/api"
 
-require "neuron-client/model/common/base"
-require "neuron-client/model/common/ad_calculations"
-require "neuron-client/model/common/ad"
-require "neuron-client/model/common/ad_zone"
-require "neuron-client/model/common/blocked_referer"
-require "neuron-client/model/common/blocked_user_agent"
-require "neuron-client/model/common/geo_target"
-require "neuron-client/model/common/pixel"
-require "neuron-client/model/common/report"
-require "neuron-client/model/common/s3_file"
-require "neuron-client/model/common/zone_calculations"
-require "neuron-client/model/common/zone"
-
-require "neuron-client/model/admin/base"
-require "neuron-client/model/admin/ad"
-require "neuron-client/model/admin/ad_zone"
-require "neuron-client/model/admin/blocked_referer"
-require "neuron-client/model/admin/blocked_user_agent"
-require "neuron-client/model/admin/geo_target"
-require "neuron-client/model/admin/pixel"
-require "neuron-client/model/admin/report"
-require "neuron-client/model/admin/s3_file"
-require "neuron-client/model/admin/zone"
-
-require "neuron-client/model/membase/ad"
-require "neuron-client/model/membase/ad_zone"
-require "neuron-client/model/membase/blocked_referer"
-require "neuron-client/model/membase/blocked_user_agent"
-require "neuron-client/model/membase/geo_target"
-require "neuron-client/model/membase/pixel"
-require "neuron-client/model/membase/report"
-require "neuron-client/model/membase/s3_file"
-require "neuron-client/model/membase/zone"
-
 require "neuron-client/model/base"
-require "neuron-client/model/models"
+require "neuron-client/model/ad_calculations"
+require "neuron-client/model/ad"
+require "neuron-client/model/ad_zone"
+require "neuron-client/model/blocked_referer"
+require "neuron-client/model/blocked_user_agent"
+require "neuron-client/model/geo_target"
+require "neuron-client/model/pixel"
+require "neuron-client/model/report"
+require "neuron-client/model/s3_file"
+require "neuron-client/model/zone_calculations"
+require "neuron-client/model/zone"
+
+require "neuron-client/schema/common.rb"
+require "neuron-client/schema/ad.rb"
+require "neuron-client/schema/ad_zone.rb"
+require "neuron-client/schema/blocked_referer.rb"
+require "neuron-client/schema/blocked_user_agent.rb"
+require "neuron-client/schema/geo_target.rb"
+require "neuron-client/schema/pixel.rb"
+require "neuron-client/schema/report.rb"
+require "neuron-client/schema/s3_file.rb"
+require "neuron-client/schema/zone.rb"
 
 class Object
   def blank?
     return true if self.nil?
-    return true if self.respond_to?(:empty) && self.empty?
+    return true if self.respond_to?(:empty?) && self.empty?
     false
   end
 
@@ -55,26 +43,3 @@ class Object
     !self.blank?
   end
 end
-
-# lifted completely from the ruby facets gem source:
-# /lib/core-uncommon/facets/module/cattr.rb
-def Module
-  def cattr_writer(*syms)
-    syms.flatten.each do |sym|
-      module_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-
-        def #{sym}=(obj)
-          @@#{sym}=(obj)
-        end
-      EOS
-    end
-    return syms
-  end
-end

data/neuron-client.gemspec

@@ -24,6 +24,9 @@ Gem::Specification.new do |s|
   s.add_dependency "i18n", ">= 0.5.0", "< 0.7"
   s.add_dependency "dalli", ">= 1.0.5", "< 1.2"
   s.add_dependency "lrucache", "~> 0.1.0"
+  s.add_dependency "map", ">= 4.2.0", "< 5"
+  s.add_dependency "deep_merge", "~> 1.0.0"
+  s.add_dependency "json-schema", "~> 0.9.12"
 
   s.add_development_dependency "rspec", "~> 2.7.0"
   s.add_development_dependency "simplecov", "~> 0.5.4"

data/spec/lib/admin_connection_spec.rb

@@ -1,5 +1,239 @@
 module Neuron
+  module Schema
+    class TestModel
+      SCHEMA = self.new
+      def index; {}; end
+      def show; {}; end
+      def create; {} end
+      def update; {} end
+    end
+  end
   module Client
+    class TestModel
+      include Base
+      def attributes
+        []
+      end
+    end
+
+    describe AdminConnection do
+      before(:each) do
+        @connection = stub(:connection)
+        API.stub(:default_api).and_return(stub(:default_api, :connection => @connection, :connection_type => :admin, :validate? => true))
+      end
+      
+      describe "update_attributes" do
+        it "should return false when errors occur for updated objects" do
+          @connection.should_receive(:put).with("test_models/1", {'test_model' => {}}) do
+            throw :errors, {:error => "is required"}
+          end 
+
+          TestModel.new(:id => 1).update_attributes({}).should be_false
+        end
+
+        it "should provide access to errors when validation fails" do
+          @connection.should_receive(:put).with("test_models/1", {'test_model' => {}}) do
+            throw :errors, {:error => "is required"}
+          end 
+
+          c = TestModel.new(:id => 1)
+          c.update_attributes({}).should be_false
+          c.errors.should == {:error => "is required"}
+        end
+
+        it "should return true when errors do not occur for updated objects" do
+          @connection.should_receive(:put).with("test_models/1", {'test_model' => {}}).and_return({'test_model' => {}})
+
+          TestModel.new(:id => 1).update_attributes({}).should be_true
+        end
+      end
+
+      describe "save" do
+        it "should return false when errors occur for new objects" do
+          @connection.should_receive(:post).with("test_models", {'test_model' => {}}) do
+            throw :errors, {:error => "is required"}
+          end 
+
+          TestModel.new.save.should be_false
+        end
+
+        it "should provide access to errors when validation fails" do
+          @connection.should_receive(:post).with("test_models", {'test_model' => {}}) do
+            throw :errors, {:error => "is required"}
+          end 
+
+          c = TestModel.new
+          c.save.should be_false
+          c.errors.should == {:error => "is required"}
+        end
+
+        it "should return true when errors do not occur for new objects" do
+          @connection.should_receive(:post).with("test_models", {'test_model' => {}}).and_return({'test_model' => {:id => 1}})
+
+          TestModel.new.save.should be_true
+        end 
+
+        it "should return false when errors occur for existing objects" do
+          @connection.should_receive(:put).with('test_models/1', {'test_model' => {}}) do
+            throw :errors, {:error => "is required"}
+          end 
+
+          TestModel.new(:id => 1).save.should be_false
+        end
+
+        it "should provide access to errors when validation fails" do
+          @connection.should_receive(:put).with("test_models/1", {'test_model' => {}}) do
+            throw :errors, {:error => "is required"}
+          end 
+
+          c = TestModel.new(:id => 1)
+          c.save.should be_false
+          c.errors.should == {:error => "is required"}
+        end
+
+        it "should return true when errors do not occur for existing objects" do
+          @connection.should_receive(:put).with("test_models/1", {'test_model' => {}}).and_return({'test_model' => {:id => 1}})
+
+          TestModel.new(:id => 1).save.should be_true
+        end
+      end
+
+      describe "create" do
+        it "should return nil when errors occur" do
+          @connection.should_receive(:post).with("test_models", {'test_model' => {}}) do
+            throw :errors, {:error => "is_required"}
+          end
+
+          TestModel.create({}).should be_nil
+        end
+
+        it "should return the created object when no errors occur" do
+          @connection.should_receive(:post).with("test_models", {'test_model' => {}}).and_return({'test_model' => {:id => 1}})
+
+          TestModel.create({}).should be_a TestModel
+        end
+      end
+
+      describe "create!" do
+        it "should return nil when errors occur" do
+          @connection.should_receive(:post).with("test_models", {'test_model' => {}}) do
+            throw :errors, {:error => "is_required"}
+          end
+
+          errors = catch(:errors) do
+            TestModel.create!({})
+            nil
+          end
+          errors.should_not be_nil
+          errors.should == {:error => 'is_required'}
+        end
+
+        it "should return the created object when no errors occur" do
+          @connection.should_receive(:post).with("test_models", {'test_model' => {}}).and_return({'test_model' => {:id => 1}})
+
+          TestModel.create!({}).should be_a TestModel
+        end
+      end
+    end
+
+    describe AdminConnection do
+      before(:each) do
+        @connection = AdminConnection.new('http://neuron.admin', "my_api_key")
+      end
+
+      it "should escape the passed api_key" do
+        connection = AdminConnection.new("http://neuron.admin", "an unescaped string")
+        FakeWeb.register_uri(:get, "http://neuron.admin/test.json?api_key=an+unescaped+string", :body => Yajl.dump({"escaped" => true}))
+        connection.get("test").should == {"escaped" => true}
+      end
+
+      describe "get" do
+        it "should make a GET request to the specified url passing an API key" do
+          FakeWeb.register_uri(:get, "http://neuron.admin/test.json", :body => "ERROR", :status => ["403", "Unauthorized"])
+          FakeWeb.register_uri(:get, "http://neuron.admin/test.json?api_key=my_api_key", :body => "{}")
+          @connection.get("test").should == {}
+        end
+
+        it "should GET an error if the wrong api_key is passed" do
+          FakeWeb.register_uri(:get, "http://neuron.admin/test.json?api_key=new_api_key", :body => "{}")
+          FakeWeb.register_uri(:get, "http://neuron.admin/test.json?api_key=my_api_key", :body => "ERROR", :status => ["403", "Unauthorized"])
+          lambda do
+            @connection.get("test")
+          end.should raise_error
+        end
+      end
+
+      describe "post" do
+        it "should make a POST request to the specified url passing an API key" do
+          FakeWeb.register_uri(:post, "http://neuron.admin/test.json", :body => "ERROR", :status => ["403", "Unauthorized"])
+          FakeWeb.register_uri(:post, "http://neuron.admin/test.json?api_key=my_api_key", :body => "{}", :status => ["201", "Created"])
+          @connection.post("test", {:data => 1}).should == {}
+        end
+
+        it "should POST an error if the wrong api_key is passed" do
+          FakeWeb.register_uri(:post, "http://neuron.admin/test.json?api_key=new_api_key", :body => "{}", :status => ["201", "Created"])
+          FakeWeb.register_uri(:post, "http://neuron.admin/test.json?api_key=my_api_key", :body => "ERROR", :status => ["403", "Unauthorized"])
+          lambda do 
+            @connection.post("test", {:data => 1})
+          end.should raise_error
+        end
+
+        it "should throw :errors if validation fails" do
+          FakeWeb.register_uri(:post, "http://neuron.admin/test.json?api_key=my_api_key", :body => Yajl.dump({:my_field => 'is_required'}), :status => ["422", "Errors"])
+          errors = catch(:errors) do
+            value = @connection.post("test", {:data => 1})
+            nil
+          end
+          errors.should_not be_nil
+          errors.should == {'my_field' => 'is_required'}
+        end
+      end
+
+      describe "put" do
+        it "should make a PUT request to the specified url passing an API key" do
+          FakeWeb.register_uri(:put, "http://neuron.admin/test.json", :body => "ERROR", :status => ["403", "Unauthorized"])
+          FakeWeb.register_uri(:put, "http://neuron.admin/test.json?api_key=my_api_key", :body => "{}")
+          @connection.put("test", {:data => 1}).should == {}
+        end
+
+        it "should PUT an error if the wrong api_key is passed" do
+          FakeWeb.register_uri(:put, "http://neuron.admin/test.json?api_key=new_api_key", :body => "{}")
+          FakeWeb.register_uri(:put, "http://neuron.admin/test.json?api_key=my_api_key", :body => "ERROR", :status => ["403", "Unauthorized"])
+          lambda do
+            @connection.put("test", {:data => 1})
+          end.should raise_error
+        end
+
+        it "should throw :errors if validation fails" do
+          FakeWeb.register_uri(:put, "http://neuron.admin/test.json?api_key=my_api_key", :body => Yajl.dump({:my_field => 'is_required'}), :status => ["422", "Errors"])
+          errors = catch(:errors) do
+            value = @connection.put("test", {:data => 1})
+            nil
+          end
+          errors.should_not be_nil
+          errors.should == {'my_field' => 'is_required'}
+        end
+      end
+
+      describe "delete" do
+        it "should make a DELETE request to the specified url passing an API key" do
+          FakeWeb.register_uri(:delete, "http://neuron.admin/test.json", :body => "ERROR", :status => ["403", "Unauthorized"])
+          FakeWeb.register_uri(:delete, "http://neuron.admin/test.json?api_key=my_api_key", :body => "{}")
+          @connection.delete("test").should == {}
+        end
+
+        it "should DELETE an error if the wrong api_key is passed" do
+          FakeWeb.register_uri(:delete, "http://neuron.admin/test.json?api_key=new_api_key", :body => "{}")
+          FakeWeb.register_uri(:delete, "http://neuron.admin/test.json?api_key=my_api_key", :body => "ERROR", :status => ["403", "Unauthorized"])
+          lambda do
+            @connection.delete("test")
+          end.should raise_error
+        end
+      end
+    end
+
+
+
     describe AdminConnection do
       
       def stub_rest_client(receive, with_args, yield_args)

data/spec/lib/api_spec.rb

@@ -1,80 +1,58 @@
 module Neuron
   module Client
     describe API do
-      describe "configure" do
-        context "when connection_type is :admin" do
-          it "should call the expected methods" do
-            a = API.new
-            c = stub(:config)
-            a.should_receive(:config).exactly(4).times.and_return(c)
-            c.should_receive(:connection_type=).with(:admin)
-            a.should_receive(:inclusion).with(c, :connection_type, [:admin, :membase])
-            c.should_receive(:connection_type).exactly(2).times.and_return(:admin)
-            a.should_receive(:configure_admin_connection)
 
-            a.configure do |conf|
-              conf.connection_type = :admin
-            end
+      describe "configure" do
+        it "creates a valid AdminConnection object" do
+          api = API.new
+          api.connection.should be_nil
+          api.configure do |config|
+            config.connection_type = :admin
+            config.admin_url = "https://example.com"
+            config.admin_key = "secret"
           end
+          api.connection.should be_a(AdminConnection)
         end
-        context "when connection_type is :membase" do
-          it "should call the expected methods" do
-            a = API.new
-            c = stub(:config)
-            a.should_receive(:config).exactly(4).times.and_return(c)
-            c.should_receive(:connection_type=).with(:membase)
-            a.should_receive(:inclusion).with(c, :connection_type, [:admin, :membase])
-            c.should_receive(:connection_type).exactly(2).times.and_return(:membase)
-            a.should_receive(:configure_membase_connection)
 
-            a.configure do |conf|
-              conf.connection_type = :membase
-            end
+        it "creates a valid MembaseConnection object" do
+          api = API.new
+          api.connection.should be_nil
+          api.configure do |config|
+            config.connection_type = :membase
+            config.membase_servers = '127.0.0.1:11211'
+            config.local_cache_size = 1000,
+            config.local_cache_expires = 60
           end
+          api.connection.should be_a(MembaseConnection)
         end
-      end
-
-      describe "connection_type" do
-        it "should return the expected value"
-      end
-
-      describe "config" do
-        it "should return the expected value"
-      end
-
-      describe "required(obj, attrib)" do
-        context "when val is nil" do
-          it "should call the expected methods and raise an error"
-        end
-        context "when val is not nil and val.empty? does not exist" do
-          it "should call the expected methods and not raise an error"
-        end
-        context "when val is not nil and val.empty? exists and returns true" do
-          it "should call the expected methods and raise an error"
-        end
-      end
 
-      describe "inclusion(obj, attrib, valid_values)" do
-        context "when valid_values includes the attribute value" do
-          it "should not raise an error"
-        end
-        context "when valid_values does not include the attribute value" do
-          it "should raise an error"
+        it "raises an exception when given an admin_url that is not a URL" do
+          api = API.new
+          expect do
+            api.configure do |config|
+              config.connection_type = :admin
+              config.admin_url = "not a url"
+              config.admin_key = "secret"
+            end
+          end.to raise_exception
         end
-      end
 
-      describe "configure_admin_connection" do
-        context "when URI.parse raises an error" do
-          it "should raise a custom error"
-        end
-        context "when URI.parse does not raise an error" do
-          it "should call the expected methods"
+        it "turns on validations by default" do
+          api = API.new
+          api.validate?.should be_true
+          api.configure do |config|
+            config.connection_type = :admin
+            config.admin_url = "https://example.com"
+            config.admin_key = "secret"
+            config.validate = true
+          end
+          api.validate?.should be_true
+          api.configure do |config|
+            config.validate = false
+          end
+          api.validate?.should be_false
         end
       end
-
-      describe "configure_membase_connection" do
-        it "should call the expected methods"
-      end
     end
   end
 end