ampere 0.1.0

data/spec/models/indices_spec.rb

@@ -0,0 +1,141 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper.rb")
+
+describe "Model indices", :indices => true do
+  before :all do
+    Redis.new.flushall
+    Ampere.connect
+
+    class Student < Ampere::Model
+      field :first_name
+      field :last_name
+      field :student_id_num
+      
+      index :last_name
+      index :student_id_num, :unique => true
+    end
+    
+    @a = Student.create :first_name     => "Hannibal",
+                        :last_name      => "Smith",
+                        :student_id_num => "1001"
+    @b = Student.create :first_name     => "Cindy",
+                        :last_name      => "Smith",
+                        :student_id_num => "1002"
+    @c = Student.create :first_name     => "Emmanuel",
+                        :last_name      => "Goldstein",
+                        :student_id_num => "1003"
+  end
+  
+  ###
+  
+  it 'should know about its own indices' do
+    Student.indices.should include(:last_name)
+    Student.indices.should_not include(:first_name)
+    Student.indices.should include(:student_id_num)
+  end
+  
+  it 'should find an array of values for a non-unique index' do
+    smiths = Student.where(:last_name => "Smith")
+    smiths.should_not be_empty
+    smiths.to_a.map(&:first_name).should include("Hannibal")
+    smiths.to_a.map(&:first_name).should include("Cindy")
+  end
+  
+  it 'should find a single value for a unique index' do
+    emmanuel = Student.where(:student_id_num => "1003")
+    emmanuel.should_not be_empty
+    emmanuel.first.first_name.should == "Emmanuel"
+  end
+  
+  it 'should refuse to create an index on a field that does not exist' do
+    (->{
+      class Student < Ampere::Model
+        field :this_field_exists
+
+        index :this_field_exists
+      end
+    }).should_not raise_error
+    (->{
+      class Student < Ampere::Model
+        index :this_field_does_not_exist
+      end
+    }).should raise_error
+    (->{
+      class Student < Ampere::Model
+        field :this_field_exists
+        
+        index [:this_field_exists, :but_this_one_does_not]
+      end
+    }).should raise_error
+  end
+  
+  it 'should enforce the uniqueness of unique single-field indices' do
+    pending
+    # The student_id_num field of Student is unique. If two Students
+    # with the same student_id_num are stored, the second should not 
+    # save successfully, throwing an exception instead.
+    (->{
+      Student.create :first_name     => "Bobby",
+                     :last_name      => "Tables",
+                     :student_id_num => "2000"
+    }).should_not raise_error
+    (->{
+      Student.create :first_name     => "Johnny",
+                     :last_name      => "Tables",
+                     :student_id_num => "2000"
+    }).should raise_error
+    Student.where(:student_id_num => "2000").first.first_name.should == "Bobby"
+  end
+  
+  context 'compound indices' do
+    before :all do
+      class Professor < Ampere::Model
+        field :first_name
+        field :last_name
+        field :employee_id_number
+        
+        index :employee_id_number
+        index [:last_name, :first_name]
+      end
+    end
+    
+    ###
+    
+    it 'should define compound indices' do
+      Professor.indices.should include([:first_name, :last_name])
+
+      Ampere.connection.exists("ampere.index.professor.first_name:last_name").should be_false
+      Professor.create :first_name         => "Warren",
+                       :last_name          => "Satterfield",
+                       :employee_id_number => "31415926"
+      Professor.count.should == 1
+      Ampere.connection.exists("ampere.index.professor.first_name:last_name").should be_true
+    end
+    
+    it 'should be able to search on both fields of a compound index' do
+      Professor.create :first_name         => "Ava",
+                       :last_name          => "Jenkins",
+                       :employee_id_number => "31415927"
+      Professor.create :first_name         => "Lazaro",
+                       :last_name          => "Adams",
+                       :employee_id_number => "31415928"
+      Professor.create :first_name         => "Brandi",
+                       :last_name          => "O'Kon",
+                       :employee_id_number => "31415929"
+
+      brandi = Professor.where(:first_name => "Brandi", :last_name => "O'Kon")
+      brandi.count.should == 1
+      brandi.first.employee_id_number.should == "31415929"
+    end
+    
+    it 'should still be able to search on just one field of a compound index' do
+      pending
+    end
+  end
+  
+  ###
+  
+  after :all do
+    Redis.new.flushall
+    Ampere.disconnect
+  end
+end

data/spec/models/model_spec.rb

@@ -0,0 +1,208 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper.rb")
+
+describe "Base models", :model => true do
+  context "by themselves" do
+    before :all do
+      Ampere.connect
+      
+      # Clear out Redis
+      Redis.new.flushall
+      
+      # Define a model class here.
+      class Post < Ampere::Model
+        field :title
+        field :byline
+        field :content
+      end
+      
+    end
+    
+    # # #
+
+    context 'fields' do
+      it "should define attr accessors and suchlike" do
+        post = Post.new
+        post.should respond_to(:title)
+        post.should respond_to(:"title=")
+        post.should respond_to(:byline)
+        post.should respond_to(:"byline=")
+        post.should respond_to(:content)
+        post.should respond_to(:"content=")
+      end
+    
+      it "should know about its own fields" do
+        Post.fields.should include(:title)
+        Post.fields.should include(:byline)
+        Post.fields.should include(:content)
+      end
+    
+      it "should have default values definable" do
+        class Comment < Ampere::Model
+          field :subject, :default => "No subject"
+          field :content
+        end
+      
+        comment = Comment.new
+        comment.subject.should == "No subject"
+        comment.content.should be_nil
+      end
+    
+      it "should raise an exception when you try to set a field that doesn't exist" do
+        (->{Post.new :shazbot => "This isn't the right key"}).should raise_error
+      end
+      
+      context 'types', :types => true do
+        before :all do
+          # Just adding a field with a type to Post
+          class Post < Ampere::Model
+            field :pageviews, :type => Integer, :default => 0
+          end
+        end
+        
+        it "shouldn't care what the value types are assigned to a field with no type defined" do
+          pending "Types not implemented yet."
+          # Assign a string to the :make of a motorcycle.
+          (->{
+            Post.create :title     => "",
+                        :byline    => "",
+                        :content   => "",
+                        :pageviews => 1234
+            
+            
+          }).should_not raise_error
+          
+          # Assign an integer to the :make of a motorcycle, for some reason.
+          (->{
+            Motorcycle.create :make         => 1234,
+                              :model        => 'CB450SC',
+                              :year         => 1986,
+                              :displacement => 450.0
+          }).should_not raise_error
+        end
+        
+        it "should, given a field's type, only accept values for that field of that type", :wip => true do
+          pending "Types not implemented yet."
+          cycle = Motorcycle.create :make         => 'Honda',
+                                    :model        => 'CB450SC',
+                                    :year         => 1986,
+                                    :displacement => 450.0
+          
+          # Try to assign a string to :year, raising an error.
+          (->{cycle.year = "this is not a year"}).should raise_error
+          (->{cycle.year = 1996}).should_not raise_error
+        end
+      end
+    end
+    
+    it "should have a 'new' method that works like we'd expect" do
+      post = Post.new :title   => "Amish Give Up - 'This is bullshit!', Elders Say",
+                      :byline  => "The Onion",
+                      :content => %{
+                        Lorem ipsum dolor sit amet, consectetur adipisicing
+                        elit, sed do eiusmod tempor incididunt ut labore et
+                        dolore magna aliqua.
+                      }
+      post.title.should   == "Amish Give Up - 'This is bullshit!', Elders Say"
+      post.byline.should  == "The Onion"
+      post.content.should =~ /Lorem ipsum dolor/
+    end
+    
+    it "should be able to convert itself to a hash" do
+      post = Post.new :title   => "A title",
+                      :byline  => "Max",
+                      :content => "Some content"
+      hash = post.attributes
+      hash[:title].should   == "A title"
+      hash[:byline].should  == "Max"
+      hash[:content].should == "Some content"
+    end
+    
+    it "should have a 'save' and 'reload' method that work like we'd expect" do
+      post = Post.new :title   => "A title",
+                      :byline  => "Max",
+                      :content => "Some content"
+
+      post.save.should be_true
+
+      post.reload
+      post.title.should   == "A title"
+      post.byline.should  == "Max"
+      post.content.should == "Some content"
+    end
+    
+    it "should refuse to reload a new record, that hasn't yet been saved" do
+      post = Post.new :title   => "A title",
+                      :byline  => "Max",
+                      :content => "Some content"
+      (->{post.reload}).should raise_error
+    end
+    
+    it "should be able to tell when two records are equivalent" do
+      foo = Post.create :title => "Kitties!", :byline => "Max", :content => "Kitties are awesome."
+      bar = Post.create :title => "Doggies!", :byline => "Max", :content => "Doggies are cool."
+      
+      foo.should == foo # Post.new(:title => "Kitties!", :byline => "Max", :content => "Kitties are awesome.")
+      foo.should_not == bar
+      
+    end
+
+    it "should be able to tell when it's new" do
+      post = Post.new :title   => "A title",
+                      :byline  => "Max",
+                      :content => "Some content"
+      post.new?.should be_true
+      post.save
+      post.new?.should be_false
+    end
+    
+    it "should be deleteable from the model class" do
+      post = Post.create :title   => "This post should be deleted",
+                         :byline  => "because it's awful",
+                         :content => "and it doesn't even make sense."
+      id = post.id
+      post.should_not be_nil
+      Post.delete(id).should == 1
+      Post.find(id).should be_nil
+    end
+    
+    it "should be destroyable by itself" do
+      another_post = Post.create :title   => "This one too, probably.",
+                                 :byline  => "Just seems like one bit",
+                                 :content => "non sequitor."
+      id = another_post.id
+      another_post.destroy.should == 1
+      Post.find(id).should be_nil
+    end
+    
+    it "should be findable by ID" do
+      post = Post.new :title   => "foo",
+                      :byline  => "bar",
+                      :content => "baz"
+      post.save
+      Post.find(post.id).should == post
+      # Since we're using GUIDs, this should also be true:
+      post2 = Post.find(post.id)
+      
+      post.title.should   == post2.title
+      post.byline.should  == post2.byline
+      post.content.should == post2.content
+    end
+
+    it "should be able to save itself upon creation" do
+      post = Post.create :title   => "Another title",
+                         :byline  => "Max",
+                         :content => "Some other content"
+      Post.find(post.id).should == post
+    end
+    
+    # # #
+    
+    after :all do
+      # Clear out Redis
+      Redis.new.flushall
+      Ampere.disconnect
+    end
+    
+  end
+  
+end

data/spec/models/queries_spec.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper.rb")
+
+describe 'queries', :queries => true do
+  before :each do
+    Redis.new.flushall
+    Ampere.connect
+    
+    class Kitty < Ampere::Model
+      field :name
+      field :breed
+      field :age
+      field :color
+      
+      index :name     # => Unique
+      index :color    # => Non-unique
+    end
+    
+    @kitty_paws = Kitty.create name:  'Kitty Paws',
+                               breed: 'Domestic shorthair',
+                               age:   19,
+                               color: 'orange'
+    @nate       = Kitty.create name:  'Nate',
+                               breed: 'Domestic shorthair',
+                               age:   17,
+                               color: 'black'
+    @jinxii     = Kitty.create name:  'Jinxii',
+                               breed: 'Chartreux',
+                               age:   3,
+                               color: 'grey'
+    @italics    = Kitty.create name:  'Italics',
+                               breed: 'Siberian',
+                               age:   7,
+                               color: 'orange'
+    @serif      = Kitty.create name:  'Serif',
+                               breed: 'Siberian',
+                               age:   5,
+                               color: 'grey'
+    [@kitty_paws, @nate, @jinxii, @italics, @serif]. each {|k| k.reload}
+  end
+  
+  ### 
+  
+  it 'should pass a basic sanity check' do
+    Kitty.count.should == 5
+  end
+  
+  it 'should be able to select all kitties' do
+    Kitty.all.map(&:name).should include('Kitty Paws')
+    Kitty.all.map(&:name).should include('Nate')
+    Kitty.all.map(&:name).should include('Jinxii')
+    Kitty.all.map(&:name).should include('Italics')
+    Kitty.all.map(&:name).should include('Serif')
+  end
+  
+  context 'with no fields' do
+    it 'should return the empty set with no conditions given' do
+      Kitty.where().should be_empty
+    end
+  end
+  
+  context 'with one field' do
+    it 'should be able to find by an indexed field using where()' do
+      Kitty.where(:name => 'Nate').to_a.map(&:name).should include('Nate')
+    end
+  
+    it 'should be able to find by a non-indexed field using where()' do
+      Kitty.where(:breed => 'Siberian').to_a.map(&:name).should include('Italics')
+      Kitty.where(:breed => 'Siberian').to_a.map(&:name).should include('Serif')
+    end
+  end
+  
+  it 'should be able to find by two indexed fields at once' do
+    kitty = Kitty.where(:name => "Kitty Paws", :color => "orange")
+    kitty.count.should == 1
+    kitty.first.name.should == "Kitty Paws"
+  end
+  
+  it 'should be able to find by two non-indexed fields at once' do
+    # :breed and :age are not indexed
+    Kitty.where(:breed => "Domestic shorthair", :age => "17").count.should == 1
+  end
+  
+  it 'should be able to find by a mix of indexed and non-indexed fields' do
+    # :color is indexed, :breed is not
+    Kitty.where(:color => "orange").count.should == 2
+    Kitty.where(:breed => "Siberian").count.should == 2
+    Kitty.where(:color => "orange", :breed => "Siberian").count.should == 1
+    Kitty.where(:color => "orange", :breed => "Siberian").first.name.should == "Italics"
+  end
+  
+  ###
+  
+  after :all do
+    Redis.new.flushall
+    Ampere.connect
+  end
+end

data/spec/models/relationships/belongs_to_spec.rb

@@ -0,0 +1,100 @@
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper.rb")
+
+describe 'belongs_to relationships', :belongs_to => true do
+  before :all do
+    Redis.new.flushall
+    Ampere.connect
+    
+    # These are used by the has_one/belongs_to example below
+    class Car < Ampere::Model
+      field :make
+      field :model
+      field :year
+
+      has_one :engine
+      has_many :passengers
+    end
+
+    class Engine < Ampere::Model
+      field :displacement
+      field :cylinders
+      field :configuration
+      
+      belongs_to :car
+    end
+    
+    class Passenger < Ampere::Model
+      field :name
+      field :seat
+      
+      belongs_to :car
+    end
+    
+    @car    = Car.create :make  => "Lamborghini",
+                         :model => "Countach",
+                         :year  => "1974"
+    @engine = Engine.create :displacement  => "5167",
+                            :cylinders     => "12",
+                            :configuration => "V"
+    @driver = Passenger.create :name => "Max",
+                               :seat => "driver"
+    @passenger = Passenger.create :name => "Leila",
+                                  :seat => "passenger"
+  end
+  
+  ###
+  
+  it 'sets accessor methods for a belongs_to relationship' do
+    # Other side of a has_many
+    @driver.should respond_to(:car)
+    # Other side of a has_one
+    @engine.should respond_to(:car)
+  end
+  
+  it 'sets belongs_to pointer for has_one relationship that is set from the parent' do
+    @car.engine = @engine
+    @car.save
+    @engine.save
+    
+    car    = Car.find(@car.id)
+    engine = Engine.find(@engine.id)
+    
+    car.engine.should == @engine
+    engine.car.should == @car
+    
+    # Cleanup
+    @car.engine = nil
+    @engine.car = nil
+    @car.save
+    @engine.save
+  end
+  
+  it 'sets belongs_to pointer for has_one relationship that is set from the child' do
+    @engine.car = @car
+    @car.save
+    @engine.save
+    
+    car    = Car.find(@car.id)
+    engine = Engine.find(@engine.id)
+    
+    car.engine.should == @engine
+    engine.car.should == @car
+    
+    # Cleanup
+    @car.engine = nil
+    @engine.car = nil
+    @car.save
+    @engine.save
+  end
+  
+  it 'sets belongs_to pointer for has_many relationship' do
+    pending
+  end
+  
+  ###
+  
+  after :all do
+    Redis.new.flushall
+    Ampere.connect
+  end
+end