baza_models 0.0.0 → 0.0.1

data/spec/baza_models/model/custom_validations_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe BazaModels::Model::CustomValidations do
+  include DatabaseHelper
+
+  let(:user) { User.new(email: "test@example.com") }
+
+  it "validates custom validations" do
+    user.custom_valid = false
+    expect(user.valid?).to eq false
+    expect(user.errors.full_messages.join(". ")).to eq "Custom validate failed"
+    expect(user.save).to eq false
+
+    user.custom_valid = nil
+    expect(user.valid?).to eq true
+    expect(user.save).to eq true
+  end
+end

data/spec/baza_models/model/delgation_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe BazaModels::Model::Delegation do
+  include DatabaseHelper
+
+  let(:user) { User.new(email: "test@example.com") }
+  let(:role_user) { Role.new(user: user, role: "user") }
+
+  it "delegates methods" do
+    user.save!
+    role_user.save!
+
+    expect(role_user.email).to eq "test@example.com"
+    expect(role_user.user_created_at).to eq user.created_at
+  end
+end

data/spec/baza_models/model/has_many_relations_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe BazaModels::Model::HasManyRelations do
+  include DatabaseHelper
+
+  let(:organization) { Organization.new }
+  let(:user) { User.new(email: "test@example.com", organization: organization) }
+  let(:role_user) { Role.new(user: user, role: "user") }
+  let(:role_admin) { Role.new(user: user, role: "administrator") }
+
+  context "destroy" do
+    before do
+      user.save!
+    end
+
+    it "destroyes through has_many" do
+      role_user.save!
+      user.destroy!
+      expect { user.reload }.to raise_error(BazaModels::Errors::RecordNotFound)
+      expect { role_user.reload }.to raise_error(BazaModels::Errors::RecordNotFound)
+    end
+
+    it "restricts through has_many" do
+      role_admin.save!
+      expect { user.destroy! }.to raise_error(BazaModels::Errors::InvalidRecord)
+    end
+  end
+
+  context "relationships" do
+    before do
+      user.save!
+      role_user.save!
+      role_admin.save!
+    end
+
+    describe "#has_many" do
+      it "returns whole collections without arguments" do
+        expect(user.roles.to_a).to eq [role_user, role_admin]
+      end
+
+      it "supports class_name and proc-arguments" do
+        expect(user.admin_roles.to_a).to eq [role_admin]
+        expect(user.admin_roles.to_sql).to eq "SELECT `roles`.* FROM `roles` WHERE `roles`.`user_id` = '#{user.id}' AND `roles`.`role` = 'administrator'"
+      end
+    end
+  end
+
+  context "#<<" do
+    it "adds models to persisted parent" do
+      organization.save!
+      organization.users << User.create!(email: "test@example.com")
+
+      expect(organization.users.count).to eq 1
+      expect(organization.users.first.email).to eq "test@example.com"
+    end
+
+    it "adds models to new parent" do
+      organization.users << User.new(email: "test1@example.com")
+      organization.users << User.new(email: "test2@example.com")
+
+      expect(organization.users.count).to eq 2
+
+      organization.save!
+
+      expect(organization.users.count).to eq 2
+    end
+  end
+end

data/spec/baza_models/model/has_one_relations_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe BazaModels::Model::HasOneRelations do
+  include DatabaseHelper
+
+  let!(:user) { User.create!(email: "test@example.com", organization: organization) }
+  let(:user_passport) { UserPassport.create(user: user) }
+  let(:person) { Person.create!(user: user) }
+  let(:role_user) { Role.create!(user: user, role: "user") }
+  let!(:organization) { Organization.create!(name: "Test") }
+
+  it "has one thorugh" do
+    person
+    expect(user.organization).to eq organization
+    expect(user.person).to eq person
+    expect(role_user.organization).to eq organization
+  end
+
+  context "destroy" do
+    before do
+      user.save!
+    end
+
+    it "restricts through has_one" do
+      person
+      expect { user.destroy! }.to raise_error(BazaModels::Errors::InvalidRecord)
+    end
+
+    it "destroys through has_one" do
+      user_passport
+      user.destroy!
+      expect { user_passport.reload }.to raise_error(BazaModels::Errors::RecordNotFound)
+    end
+  end
+end

data/spec/baza_models/model/manipulation_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe BazaModels::Model::Manipulation do
+  include DatabaseHelper
+
+  let(:user) { User.new(email: "test@example.com") }
+  let(:role_user) { Role.new(user: user, role: "user") }
+  let(:role_admin) { Role.new(user: user, role: "administrator") }
+
+  it "#created_at" do
+    expect(user.created_at).to eq nil
+    user.save!
+    expect(user.created_at).to_not eq nil
+  end
+
+  it "#updated_at" do
+    expect(user.updated_at).to eq nil
+    user.save!
+    expect(user.updated_at).to_not eq nil
+    old_updated_at = user.updated_at
+    sleep 1
+    user.save!
+    expect(user.updated_at).to_not eq old_updated_at
+  end
+end

data/spec/baza_models/model/queries_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe BazaModels::Model::Queries do
+  include DatabaseHelper
+
+  let(:user) { User.new(email: "test@example.com") }
+  let(:role_user) { Role.new(user: user, role: "user") }
+  let(:role_admin) { Role.new(user: user, role: "administrator") }
+
+  it "#find" do
+    user.save!
+    user_found = User.find(user.id)
+    expect(user_found.email).to eq "test@example.com"
+  end
+
+  describe "#find_by" do
+    it "finds existing models" do
+      user.save!
+      user_found = User.find_by(id: 1, email: "test@example.com")
+      expect(user_found.email).to eq "test@example.com"
+    end
+
+    it "returns false when nothing is found" do
+      user_found = User.find_by(id: 1, email: "test@example.com")
+      expect(user_found).to eq false
+    end
+
+    it "#find_by!" do
+      expect { User.find_by!(email: "doesntexist@example.com") }.to raise_error(BazaModels::Errors::RecordNotFound)
+    end
+  end
+
+  describe "#find_or_initialize_by" do
+    it "finds existing models" do
+      user.save!
+      user_found = User.find_or_initialize_by(id: 1, email: "test@example.com")
+      expect(user_found.new_record?).to eq false
+      expect(user_found.persisted?).to eq true
+    end
+
+    it "returns false when nothing is found" do
+      user_found = User.find_or_initialize_by(email: "test@example.com")
+      expect(user_found.new_record?).to eq true
+      expect(user_found.persisted?).to eq false
+    end
+
+    it "#find_or_create_by" do
+      user_found = User.find_or_create_by(id: 1, email: "test@example.com")
+      expect(user_found.new_record?).to eq false
+      expect(user_found.persisted?).to eq true
+    end
+
+    it "#find_or_create_by!" do
+      user_found = User.find_or_create_by!(id: 1, email: "test@example.com")
+      expect(user_found.new_record?).to eq false
+      expect(user_found.persisted?).to eq true
+    end
+  end
+end

data/spec/baza_models/model/scopes_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe BazaModels::Model::Scopes do
+  include DatabaseHelper
+
+  let(:user) { User.new(email: "test@example.com") }
+  let(:role_user) { Role.new(user: user, role: "user") }
+  let(:role_admin) { Role.new(user: user, role: "administrator") }
+
+  before do
+    user.save!
+    role_user.save!
+    role_admin.save!
+  end
+
+  it "works with where" do
+    expect(Role.admin_roles.to_a).to eq [role_admin]
+  end
+
+  it "joins as well" do
+    expect(User.admin_roles_scope.to_a).to eq [user]
+  end
+end

data/spec/baza_models/model/translate_functionality_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe BazaModels::Model::TranslationFunctionality do
+  include DatabaseHelper
+
+  it "#model_name" do
+    expect(User.model_name.human).to eq "User"
+  end
+
+  it "#human_attribute_name" do
+    expect(User.human_attribute_name(:email)).to eq "Email"
+  end
+end

data/spec/baza_models/model/validations_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe BazaModels::Model::Validations do
+  include DatabaseHelper
+
+  let(:user) { User.new(email: "test@example.com") }
+  let(:role_user) { Role.new(user: user, role: "user") }
+  let(:role_admin) { Role.new(user: user, role: "administrator") }
+
+  describe "#valid?" do
+    it "returns true when valid" do
+      expect(user.valid?).to eq true
+    end
+
+    it "returns false when invalid" do
+      user.email = " "
+      expect(user.valid?).to eq false
+    end
+  end
+
+  it "#before_validation, #after_validation" do
+    expect(user.before_validation_called).to eq nil
+    expect(user.after_validation_called).to eq nil
+    user.valid?
+    expect(user.before_validation_called).to eq 1
+    expect(user.after_validation_called).to eq 1
+  end
+
+  it "#before_validation_on_create, #after_validation_on_create, #before_validation_on_update, #after_validation_on_update" do
+    expect(user.before_validation_on_create_called).to eq nil
+    expect(user.after_validation_on_create_called).to eq nil
+
+    expect(user.before_validation_on_update_called).to eq nil
+    expect(user.after_validation_on_update_called).to eq nil
+
+    user.save!
+
+    expect(user.before_validation_on_create_called).to eq 1
+    expect(user.after_validation_on_create_called).to eq 1
+
+    expect(user.before_validation_on_update_called).to eq nil
+    expect(user.after_validation_on_update_called).to eq nil
+
+    user.update_attributes!(email: "newemail@example.com")
+
+    expect(user.before_validation_on_create_called).to eq 1
+    expect(user.after_validation_on_create_called).to eq 1
+
+    expect(user.before_validation_on_update_called).to eq 1
+    expect(user.after_validation_on_update_called).to eq 1
+  end
+end

data/spec/baza_models/model_spec.rb

@@ -1,152 +1,129 @@
 require "spec_helper"
 
 describe "BazaModels::Model" do
-  let(:db) { @db }
-  let(:user) { UserTest.new(email: "test@example.com") }
-
-  before do
-    @count ||= 0
-    @count += 1
-
-    require "tempfile"
-    require "baza"
-    require "sqlite3"
-
-    path = Tempfile.new("baza_test").path
-    File.unlink(path) if File.exists?(path)
-
-    @db = Baza::Db.new(type: :sqlite3, path: path)
-    BazaModels.primary_db = @db
-
-    @db.tables.create(:user_tests, {
-      columns: [
-        {name: :id, type: :int, primarykey: true, autoincr: true},
-        {name: :email, type: :varchar}
-      ],
-      indexes: [
-        :email
-      ]
-    })
-
-    require "test_classes/user_test"
-  end
+  include DatabaseHelper
+
+  let(:user) { User.new(email: "test@example.com") }
+  let(:role_user) { Role.new(user: user, role: "user") }
+  let(:role_admin) { Role.new(user: user, role: "administrator") }
 
-  after do
-    BazaModels.primary_db = nil
+  describe "#email" do
+    it "returns set attributes" do
+      expect(user.email).to eq "test@example.com"
+    end
 
-    @db.close
-    path = db.args[:path]
-    File.unlink(path)
-    Thread.current[:baza] = nil
-    @db = nil
+    it "returns nil for attributes that hasn't been set" do
+      user = User.new
+      expect(user.email).to eq nil
+    end
   end
 
-  it "#email" do
-    user.email.should eq "test@example.com"
+  it "#id #to_param" do
+    expect(user.id).to eq nil
+    expect(user.to_param).to eq nil
+    user.save!
+    expect(user.id).to_not eq nil
+    expect(user.to_param).to_not eq nil
+    expect(user.to_param).to eq user.id.to_s
   end
 
   it "#email=" do
     user.email = "newemail@example.com"
-    user.email.should eq "newemail@example.com"
+    expect(user.email).to eq "newemail@example.com"
   end
 
   it "#email_was" do
+    user.save!
     user.email = "newemail@example.com"
-    user.email_was.should eq "test@example.com"
+    expect(user.email_was).to eq "test@example.com"
   end
 
   it "#changes" do
     user.email = "newemail@example.com"
-    user.changes.should eq(email: "newemail@example.com")
+    expect(user.changes).to eq email: "newemail@example.com"
   end
 
   describe "#save" do
     it "inserts a new record when new" do
-      user.new_record?.should eq true
-      user.save
-      user.id.should eq 1
-      user.new_record?.should eq false
-    end
-  end
-
-  describe "#valid?" do
-    it "returns true when valid" do
-      user.valid?.should eq true
-    end
-
-    it "returns false when invalid" do
-      user.email = " "
-      user.valid?.should eq false
+      expect(user.new_record?).to eq true
+      user.save!
+      expect(user.id).to eq 1
+      expect(user.new_record?).to eq false
     end
   end
 
   it "#update_attributes" do
     user.save!
-    user.update_attributes(email: "newemail@example.com").should eq true
-    user.email.should eq "newemail@example.com"
-    user.update_attributes(email: " ").should eq false
+    expect(user.update_attributes(email: "newemail@example.com")).to eq true
+    expect(user.email).to eq "newemail@example.com"
   end
 
   it "#before_save, #after_save" do
-    user.before_save_called.should eq nil
-    user.after_save_called.should eq nil
+    expect(user.before_save_called).to eq nil
+    expect(user.after_save_called).to eq nil
     user.save!
-    user.before_save_called.should eq 1
-    user.after_save_called.should eq 1
+    expect(user.before_save_called).to eq 1
+    expect(user.after_save_called).to eq 1
     user.save!
-    user.before_save_called.should eq 2
-    user.after_save_called.should eq 2
+    expect(user.before_save_called).to eq 2
+    expect(user.after_save_called).to eq 2
   end
 
   it "#before_create, #after_create" do
-    user.before_create_called.should eq nil
-    user.after_create_called.should eq nil
+    expect(user.before_create_called).to eq nil
+    expect(user.after_create_called).to eq nil
     user.save!
-    user.before_create_called.should eq 1
-    user.after_create_called.should eq 1
+    expect(user.before_create_called).to eq 1
+    expect(user.after_create_called).to eq 1
     user.save!
-    user.before_create_called.should eq 1
-    user.after_create_called.should eq 1
+    expect(user.before_create_called).to eq 1
+    expect(user.after_create_called).to eq 1
   end
 
   it "#before_destroy, #after_destroy" do
     user.save!
-    user.before_destroy_called.should eq nil
-    user.after_destroy_called.should eq nil
+    expect(user.before_destroy_called).to eq nil
+    expect(user.after_destroy_called).to eq nil
     user.destroy!
-    user.before_destroy_called.should eq 1
-    user.after_destroy_called.should eq 1
+    expect(user.before_destroy_called).to eq 1
+    expect(user.after_destroy_called).to eq 1
   end
 
-  it "#before_validation, #after_validation" do
-    user.before_validation_called.should eq nil
-    user.after_validation_called.should eq nil
-    user.valid?
-    user.before_validation_called.should eq 1
-    user.after_validation_called.should eq 1
+  it "can use callbacks as blocks" do
+    expect(user.before_save_block_called).to eq nil
+    user.save!
+    expect(user.before_save_block_called).to eq 1
+    user.save!
+    expect(user.before_save_block_called).to eq 2
   end
 
-  it "#before_validation_on_create, #after_validation_on_create, #before_validation_on_update, #after_validation_on_update" do
-    user.before_validation_on_create_called.should eq nil
-    user.after_validation_on_create_called.should eq nil
+  it "has array accessors" do
+    expect(user[:email]).to eq "test@example.com"
+    user[:email] = "new@example.com"
+    expect(user[:email]).to eq "new@example.com"
 
-    user.before_validation_on_update_called.should eq nil
-    user.after_validation_on_update_called.should eq nil
+    user.write_attribute(:email, "new2@example.com")
+    expect(user.read_attribute(:email)).to eq "new2@example.com"
+  end
 
+  it "#to_key" do
+    expect(user.to_key).to eq nil
     user.save!
+    expect(user.to_key).to eq [1]
+  end
 
-    user.before_validation_on_create_called.should eq 1
-    user.after_validation_on_create_called.should eq 1
-
-    user.before_validation_on_update_called.should eq nil
-    user.after_validation_on_update_called.should eq nil
-
-    user.update_attributes!(email: "newemail@example.com")
-
-    user.before_validation_on_create_called.should eq 1
-    user.after_validation_on_create_called.should eq 1
+  it "#changed?" do
+    expect(user.changed?).to eq true
+    user.save!
+    expect(user.changed?).to eq false
+    user.email = "new@example.com"
+    expect(user.changed?).to eq true
+    user.save!
+    expect(user.changed?).to eq false
+  end
 
-    user.before_validation_on_update_called.should eq 1
-    user.after_validation_on_update_called.should eq 1
+  it "doesnt care if initialized data has keys as strings" do
+    user = User.new("email" => "test@example.com")
+    expect(user.email).to eq "test@example.com"
   end
 end