neuron-client 0.1.0 → 0.2.0

data/spec/lib/model/common/ad_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Common
+        describe Ad do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/common/ad_zone_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Common
+        describe AdZone do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/common/base_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Common
+        describe Base do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/common/blocked_referer_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Common
+        describe BlockedReferer do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/common/blocked_user_agent_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Common
+        describe BlockedUserAgent do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/common/geo_target_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Common
+        describe GeoTarget do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/common/report_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Common
+        describe Report do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/common/s3_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Common
+        describe S3File do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/common/zone_calculations_spec.rb

@@ -0,0 +1,54 @@
+module Neuron
+  module Client
+    module Model
+      module Common
+        class FakeZone
+          include ZoneCalculations
+          def initialize(ads, ad_links)
+            @ads = ads
+            @ad_links = ad_links
+          end
+          attr_reader :ad_links
+          def find_ad(ad_id)
+            @ads[ad_id]
+          end
+        end
+
+        class ZoneCalculationSpecAd
+          def initialize(active, pressure)
+            @active = active
+            @pressure = pressure
+          end
+          attr_reader :pressure, :active
+          alias_method :active?, :active
+        end
+
+        describe ZoneCalculations do
+          describe ".calculate_ads_by_priority" do
+            it "should generate the expected result" do
+              ads = {
+                "0" => ZoneCalculationSpecAd.new(false, 42.0),
+                "1" => ZoneCalculationSpecAd.new(true, 11.1),
+                "2" => ZoneCalculationSpecAd.new(true, 11.1),
+                "3" => ZoneCalculationSpecAd.new(true, 22.2),
+                "4" => ZoneCalculationSpecAd.new(true, 1000),
+                "5" => ZoneCalculationSpecAd.new(true, 828282)
+              }
+              ad_links = {
+                "0" => {"priority" => 1, "weight" => 50},
+                "1" => {"priority" => 1, "weight" => 4},
+                "2" => {"priority" => 1, "weight" => 2},
+                "3" => {"priority" => 1, "weight" => 2},
+                "4" => {"priority" => 2, "weight" => 99.9}
+              }
+              zone = FakeZone.new(ads, ad_links)
+
+              zone.calculate_ads_by_priority.should == [[["1", 44.4], ["2", 22.2], ["3", 44.4]], [["4", 99900.0]]]
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/model/common/zone_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Common
+        describe Zone do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/membase/ad_spec.rb

@@ -0,0 +1,50 @@
+module Neuron
+  module Client
+    module Model
+      module Membase
+        describe Ad do
+          describe "total_impressed" do
+            it "should call the expected methods and return the expected value" do
+              a = Ad.allocate
+              a.should_receive(:id).and_return(7)
+              Ad.stub_chain(:connection, :get).with('count_delivery_ad_7').and_return('999.999')
+
+              a.total_impressed.should == 999.999
+            end
+          end
+
+          describe "today_impressed" do
+            it "should call the expected methods and return the expected value" do
+              a = Ad.allocate
+              a.should_receive(:time_zone).and_return('time_zone_value')
+              Time.stub_chain(:now, :in_time_zone).with('time_zone_value').and_return(Time.new(2011, 5, 6, 7, 8, 9))
+              a.should_receive(:id).and_return(7)
+              Ad.stub_chain(:connection, :get).with('count_delivery_20110506_ad_7').and_return('99.99')
+
+              a.today_impressed.should == 99.99
+            end
+          end
+
+          describe "Ad.find(id)" do
+            context "when the connection returns a value" do
+              it "should call the expected methods and return the expected value" do
+                Ad.stub_chain(:connection, :get).with('Ad:7').and_return('{"ad":{"attr":"value","attr2":"value2"}}')
+                a = stub(:ad)
+                Ad.should_receive(:new).with({'attr' => 'value', 'attr2' => 'value2'}).and_return(a)
+
+                Ad.find(7).should == a
+              end
+            end
+            context "when the connection returns nil" do
+              it "should call the expected methods and return nil" do
+                Ad.stub_chain(:connection, :get).with('Ad:7').and_return(nil)
+
+                Ad.find(7).should be_nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/membase/ad_zone_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Membase
+        describe AdZone do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/membase/base_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Membase
+        describe Base do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/membase/blocked_referer_spec.rb

@@ -0,0 +1,30 @@
+module Neuron
+  module Client
+    module Model
+      module Membase
+        describe BlockedReferer do
+          describe "BlockedReferer.all" do
+            context "when connection returns a value" do
+              it "should call the expected methods and return the expected value" do
+                BlockedReferer.stub_chain(:connection, :get).with('blocked_referers').and_return('[{"blocked_referer":{"attr":"value"}},{"blocked_referer":{"attr2":"value2"}}]')
+                br = stub(:blocked_referer)
+                br2 = stub(:blocked_referer2)
+                BlockedReferer.should_receive(:new).with({'attr' => 'value'}).and_return(br)
+                BlockedReferer.should_receive(:new).with({'attr2' => 'value2'}).and_return(br2)
+
+                BlockedReferer.all.should == [br, br2]
+              end
+            end
+            context "when connection returns nil" do
+              it "should call the expected methods and return the expected value" do
+                BlockedReferer.stub_chain(:connection, :get).with('blocked_referers').and_return(nil)
+
+                BlockedReferer.all.should == []
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/membase/blocked_user_agent_spec.rb

@@ -0,0 +1,30 @@
+module Neuron
+  module Client
+    module Model
+      module Membase
+        describe BlockedUserAgent do
+          describe "BlockedUserAgent.all" do
+            context "when connection returns a value" do
+              it "should call the expected methods and return the expected value" do
+                BlockedUserAgent.stub_chain(:connection, :get).with('blocked_user_agents').and_return('[{"blocked_user_agent":{"attr":"value"}},{"blocked_user_agent":{"attr2":"value2"}}]')
+                bua = stub(:blocked_user_agent)
+                bua2 = stub(:blocked_user_agent2)
+                BlockedUserAgent.should_receive(:new).with({'attr' => 'value'}).and_return(bua)
+                BlockedUserAgent.should_receive(:new).with({'attr2' => 'value2'}).and_return(bua2)
+
+                BlockedUserAgent.all.should == [bua, bua2]
+              end
+            end
+            context "when connection returns nil" do
+              it "should call the expected methods and return the expected value" do
+                BlockedUserAgent.stub_chain(:connection, :get).with('blocked_user_agents').and_return(nil)
+
+                BlockedUserAgent.all.should == []
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/membase/geo_target_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Membase
+        describe GeoTarget do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/membase/report_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Membase
+        describe Report do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/membase/s3_spec.rb

@@ -0,0 +1,11 @@
+module Neuron
+  module Client
+    module Model
+      module Membase
+        describe S3File do
+
+        end
+      end
+    end
+  end
+end

data/spec/lib/model/membase/zone_spec.rb

@@ -0,0 +1,28 @@
+module Neuron
+  module Client
+    module Model
+      module Membase
+        describe Zone do
+          describe "Zone.all" do
+            context "when connection.get returns a value" do
+              it "should call the expected methods and return the expected result" do
+                Zone.stub_chain(:connection, :get).with('Zone:7').and_return('{"zone":{"attr":"value","attr2":"value2"}}')
+                z = stub(:zone)
+                Zone.should_receive(:new).with({'attr' => 'value', 'attr2' => 'value2'}).and_return(z)
+
+                Zone.find(7).should == z
+              end
+            end
+            context "when connection.get returns nil" do
+              it "should call the expected methods and return nil" do
+                Zone.stub_chain(:connection, :get).with('Zone:7').and_return(nil)
+
+                Zone.find(7).should be_nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/old_spec.rb

@@ -6,280 +6,323 @@ module Neuron
 
     describe API do
       describe "configure" do
-        it "creates a valid Connection object" do
-          API.reset!
-          API.connection.should be_nil
-          API.configure do |config|
+        it "creates a valid AdminConnection object" do
+          API.default_api = API.new
+          API.default_api.connection.should be_nil
+          API.default_api.configure do |config|
+            config.connection_type = :admin
             config.admin_url = "https://example.com"
             config.admin_key = "secret"
           end
-          API.connection.should be_a(Connection)
+          API.default_api.connection.should be_a(AdminConnection)
         end
       end
     end
 
-    describe AdZone do
-      before(:each) do
-        @connection = stub(:connection)
-        API.stub(:connection).and_return(@connection)
-      end
-      describe "create" do
-        it "makes a post call"
-      end
-    end
-
-    describe Ad do
-      before(:each) do
-        @connection = stub(:connection)
-        API.stub(:connection).and_return(@connection)
-      end
-
-      describe "all" do
+    module Model
+      describe AdZone do
         before(:each) do
-          @response = [{}]
+          @connection = stub(:connection)
+          API.stub(:default_api).and_return(stub(:default_api, :connection => @connection, :connection_type => :admin))
         end
-        it "returns a list of Ads" do
-          @connection.stub(:get).and_return(@response)
-          ads = Ad.all
-          ads.should be_a(Array)
-          ads.length.should be > 0
-          ads.first.should be_a(Ad)
-        end
-
-        it "makes a get call" do
-          @connection.should_receive(:get).with("ads").once.and_return(@response)
-          Ad.all
+        describe "create" do
+          it "makes a post call"
         end
       end
+    end
 
-      describe "find" do
+    module Model
+      describe Ad do
         before(:each) do
-          @response = {:ad => {:id => 1, :name => "Ad 1"}}
+          @connection = stub(:connection)
+          API.stub(:default_api).and_return(stub(:default_api, :connection => @connection, :connection_type => :admin))
         end
 
-        it "returns a Ad" do
-          @connection.stub(:get).and_return(@response)
-          ad = Ad.find(1)
-          ad.should be_a(Ad)
-        end
+        describe "all" do
+          before(:each) do
+            @response = [{}]
+          end
+          it "returns a list of Ads" do
+            @connection.stub(:get).and_return(@response)
+            ads = Ad.all
+            ads.should be_a(Array)
+            ads.length.should be > 0
+            ads.first.should be_a(Admin::Ad)
+          end
 
-        it "makes a get call" do
-          @connection.should_receive(:get).with("ads/1").once.and_return(@response)
-          Ad.find(1)
+          it "makes a get call" do
+            @connection.should_receive(:get).with("ads").once.and_return(@response)
+            Ad.all
+          end
         end
-      end
 
-      describe "create" do
-        before(:each) do
-          @attrs = {:name => "Ad 1"}
-          @response = {'ad' => @attrs.merge({:id => 1})}
-        end
+        describe "find" do
+          before(:each) do
+            @response = {:ad => {:id => 1, :name => "Ad 1"}}
+          end
+
+          it "returns a Ad" do
+            @connection.stub(:get).and_return(@response)
+            ad = Ad.find(1)
+            ad.should be_a(Admin::Ad)
+          end
 
-        it "posts json" do
-          @connection.should_receive(:post).with("ads", {'ad' => @attrs}).once.and_return(@response)
-          Ad.create(@attrs)
+          it "makes a get call" do
+            @connection.should_receive(:get).with("ads/1").once.and_return(@response)
+            Ad.find(1)
+          end
         end
 
-        it "returns the created Ad" do
-          @connection.should_receive(:post).and_return(@response)
-          ad = Ad.create(@attrs)
-          ad.id.should == 1
-          ad.name.should == "Ad 1"
+        describe "create" do
+          before(:each) do
+            @attrs = {:name => "Ad 1"}
+            @response = {'ad' => @attrs.merge({:id => 1})}
+          end
+
+          it "posts json" do
+            @connection.should_receive(:post).with("ads", {'ad' => @attrs}).once.and_return(@response)
+            Ad.create(@attrs)
+          end
+
+          it "returns the created Ad" do
+            @connection.should_receive(:post).and_return(@response)
+            ad = Ad.create(@attrs)
+            ad.id.should == 1
+            ad.name.should == "Ad 1"
+          end
+
+          it "returns the created Ad With AdTrackers" do
+            @attrs = {:name => "Ad 1", :ad_trackers => [{:url => "http://www.google.com", :event => "video.impression"}]}
+            @response = {'ad' => @attrs.merge({:id => 1})}
+            @connection.should_receive(:post).and_return(@response)
+            ad = Ad.create(@attrs)
+            ad.id.should == 1
+            ad.name.should == "Ad 1"
+            ad.ad_trackers.should have(1).things
+          end
         end
-      end
 
-      describe "update_attributes" do
-        it "makes a put call" do
-          attrs = {:id => 1, :name => "Ad 1"}
-          ad = Ad.new(attrs)
-          @connection.should_receive(:put).with("ads/1", {'ad' => {:name => "Ad 2"}})
-          ad.update_attributes(:name => "Ad 2")
+        describe "update_attributes" do
+          it "makes a put call" do
+            attrs = {:id => 1, :name => "Ad 1"}
+            ad = Ad.new(attrs)
+            @connection.should_receive(:put).with("ads/1", {'ad' => {:name => "Ad 2"}})
+            ad.update_attributes(:name => "Ad 2")
+          end
+
+          it "makes a put call with AdTrackers" do
+            attrs = {:id => 1, :name => "Ad 1", :ad_trackers => [{:id => 1, :advertiser_id => 1, :url => "http://testurl.com", :event => "video.impression"}]}
+            ad = Ad.new(attrs)
+            @connection.should_receive(:put).with("ads/1", {'ad' => {:ad => {:ad_trackers => [{:url => "http://testurl.com/new"}]}}})
+            ad.update_attributes(:ad => {:ad_trackers => [{:url => "http://testurl.com/new"}]})
+          end
         end
       end
     end
 
-    describe Zone do
-      before(:each) do
-        @connection = stub(:connection)
-        API.stub(:connection).and_return(@connection)
-      end
-      describe "all" do
+    module Model
+      describe Zone do
         before(:each) do
-          @response = [{}]
+          @connection = stub(:connection)
+          API.stub(:default_api).and_return(stub(:default_api, :connection => @connection, :connection_type => :admin))
         end
+        describe "all" do
+          before(:each) do
+            @response = [{}]
+          end
 
-        it "returns a list of Zones" do
-          @connection.stub(:get).and_return(@response)
-          zones = Zone.all
-          zones.should be_a(Array)
-          zones.length.should be > 0 
-          zones.first.should be_a(Zone)
-        end
+          it "returns a list of Zones" do
+            @connection.stub(:get).and_return(@response)
+            zones = Zone.all
+            zones.should be_a(Array)
+            zones.length.should be > 0
+            zones.first.should be_a(Admin::Zone)
+          end
 
-        it "makes a get call" do
-          @connection.should_receive(:get).with("zones").once.and_return(@response)
-          Zone.all
+          it "makes a get call" do
+            @connection.should_receive(:get).with("zones").once.and_return(@response)
+            Zone.all
+          end
         end
-      end
 
-      describe "find" do
-        before(:each) do
-          @response = {:zone => {:id => 1, :slug => "zone1"}}
+        describe "find" do
+          before(:each) do
+            @response = {:zone => {:id => 1, :slug => "zone1"}}
+          end
+
+          it "returns a Zone" do
+            @connection.stub(:get).and_return(@response)
+            zone = Zone.find(1)
+            zone.should be_a(Admin::Zone)
+          end
+
+          it "makes a get call" do
+            @connection.should_receive(:get).with("zones/1").once.and_return(@response)
+            Zone.find(1)
+          end
         end
 
-        it "returns a Zone" do
-          @connection.stub(:get).and_return(@response)
-          zone = Zone.find(1)
-          zone.should be_a(Zone)
+        describe "create" do
+          before(:each) do
+            @attrs = {:slug => "zone1"}
+            @response = {'zone' => @attrs.merge({:id => 1})}
+          end
+
+          it "posts json" do
+            @connection.should_receive(:post).with("zones", {'zone' => @attrs}).once.and_return(@response)
+            Zone.create(@attrs)
+          end
+
+          it "returns the created Ad" do
+            @connection.should_receive(:post).and_return(@response)
+            zone = Zone.create(@attrs)
+            zone.id.should == 1
+            zone.slug.should == "zone1"
+          end
         end
 
-        it "makes a get call" do
-          @connection.should_receive(:get).with("zones/1").once.and_return(@response)
-          Zone.find(1)
+        describe "update_attributes" do
+          it "makes a put call" do
+            attrs = {:id => 1, :slug => "zone1"}
+            zone = Zone.new(attrs)
+            @connection.should_receive(:put).with("zones/1", {'zone' => {:slug => "zone2"}})
+            zone.update_attributes(:slug => "zone2")
+          end
         end
       end
+    end
 
-      describe "create" do
-        before(:each) do
-          @attrs = {:slug => "zone1"}
-          @response = {'zone' => @attrs.merge({:id => 1})}
-        end
 
-        it "posts json" do
-          @connection.should_receive(:post).with("zones", {'zone' => @attrs}).once.and_return(@response)
-          Zone.create(@attrs)
-        end
+    module Model
+      module Common
+        class TestModel
+          include Base
 
-        it "returns the created Ad" do
-          @connection.should_receive(:post).and_return(@response)
-          zone = Zone.create(@attrs)
-          zone.id.should == 1
-          zone.slug.should == "zone1"
+          resource_name 'test'
+          resources_name 'tests'
         end
       end
+    end
+
+    module Model
+      module Admin
+        class TestModel < Common::TestModel
+          include Base
 
-      describe "update_attributes" do
-        it "makes a put call" do
-          attrs = {:id => 1, :slug => "zone1"}
-          zone = Zone.new(attrs)
-          @connection.should_receive(:put).with("zones/1", {'zone' => {:slug => "zone2"}})
-          zone.update_attributes(:slug => "zone2")
         end
       end
     end
 
-    describe Connected do
-      class ConnectedTest
-        include Connected
-        resource_name 'connection'
-        resources_name 'connection'
-      end
+    module Model
+      class TestModel < Base; end
+    end
 
+    describe AdminConnection do
       before(:each) do
         @connection = stub(:connection)
-        API.stub(:connection).and_return(@connection)
+        API.stub(:default_api).and_return(stub(:default_api, :connection => @connection, :connection_type => :admin))
       end
       
       describe "update_attributes" do
         it "should return false when errors occur for updated objects" do
-          @connection.should_receive(:put).with("connection/1", {'connection' => {}}) do
+          @connection.should_receive(:put).with("tests/1", {'test' => {}}) do
             throw :errors, {:error => "is required"}
           end 
 
-          ConnectedTest.new(:id => 1).update_attributes({}).should be_false
+          Model::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("connection/1", {'connection' => {}}) do
+          @connection.should_receive(:put).with("tests/1", {'test' => {}}) do
             throw :errors, {:error => "is required"}
           end 
 
-          c = ConnectedTest.new(:id => 1)
+          c = Model::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 occure for updated objects" do
-          @connection.should_receive(:put).with("connection/1", {'connection' => {}})
+          @connection.should_receive(:put).with("tests/1", {'test' => {}})
 
-          ConnectedTest.new(:id => 1).update_attributes({}).should be_true
+          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("connection", {'connection' => {}}) do
+          @connection.should_receive(:post).with("tests", {'test' => {}}) do
             throw :errors, {:error => "is required"}
           end 
 
-          ConnectedTest.new.save.should be_false
+          Model::TestModel.new.save.should be_false
         end
 
         it "should provide access to errors when validation fails" do
-          @connection.should_receive(:post).with("connection", {'connection' => {}}) do
+          @connection.should_receive(:post).with("tests", {'test' => {}}) do
             throw :errors, {:error => "is required"}
           end 
 
-          c = ConnectedTest.new
+          c = Model::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("connection", {'connection' => {}}).and_return({'connection' => {:id => 1}})
+          @connection.should_receive(:post).with("tests", {'test' => {}}).and_return({'test' => {:id => 1}})
 
-          ConnectedTest.new.save.should be_true
+          Model::TestModel.new.save.should be_true
         end 
 
         it "should return false when errors occur for existing objects" do
-          @connection.should_receive(:put).with('connection/1', {'connection' => {}}) do
+          @connection.should_receive(:put).with('tests/1', {'test' => {}}) do
             throw :errors, {:error => "is required"}
           end 
 
-          ConnectedTest.new(:id => 1).save.should be_false
+          Model::TestModel.new(:id => 1).save.should be_false
         end
 
         it "should provide access to errors when validation fails" do
-          @connection.should_receive(:put).with("connection/1", {'connection' => {}}) do
+          @connection.should_receive(:put).with("tests/1", {'test' => {}}) do
             throw :errors, {:error => "is required"}
           end 
 
-          c = ConnectedTest.new(:id => 1)
+          c = Model::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("connection/1", {'connection' => {}})
+          @connection.should_receive(:put).with("tests/1", {'test' => {}})
 
-          ConnectedTest.new(:id => 1).save.should be_true
+          Model::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("connection", {'connection' => {}}) do
+          @connection.should_receive(:post).with("tests", {'test' => {}}) do
             throw :errors, {:error => "is_required"}
           end
 
-          ConnectedTest.create({}).should be_nil
+          Model::TestModel.create({}).should be_nil
         end
 
         it "should return the created object when no errors occur" do
-          @connection.should_receive(:post).with("connection", {'connection' => {}}).and_return({'connection' => {:id => 1}})
+          @connection.should_receive(:post).with("tests", {'test' => {}}).and_return({'test' => {:id => 1}})
 
-          ConnectedTest.create({}).should be_a ConnectedTest
+          Model::TestModel.create({}).should be_a Model::Admin::TestModel
         end
       end
 
       describe "create!" do
         it "should return nil when errors occur" do
-          @connection.should_receive(:post).with("connection", {'connection' => {}}) do
+          @connection.should_receive(:post).with("tests", {'test' => {}}) do
             throw :errors, {:error => "is_required"}
           end
 
           errors = catch(:errors) do
-            ConnectedTest.create!({})
+            Model::TestModel.create!({})
             nil
           end
           errors.should_not be_nil
@@ -287,20 +330,20 @@ module Neuron
         end
 
         it "should return the created object when no errors occur" do
-          @connection.should_receive(:post).with("connection", {'connection' => {}}).and_return({'connection' => {:id => 1}})
+          @connection.should_receive(:post).with("tests", {'test' => {}}).and_return({'test' => {:id => 1}})
 
-          ConnectedTest.create!({}).should be_a ConnectedTest
+          Model::TestModel.create!({}).should be_a Model::Admin::TestModel
         end
       end
     end
 
-    describe Connection do
+    describe AdminConnection do
       before(:each) do
-        @connection = Connection.new('http://neuron.admin', "my_api_key")
+        @connection = AdminConnection.new('http://neuron.admin', "my_api_key")
       end
 
       it "should escape the passed api_key" do
-        connection = Connection.new("http://neuron.admin", "an unescaped string")
+        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