massive_record 0.1.0

data/spec/orm/schema/column_interface_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+class TestColumnInterface
+  include MassiveRecord::ORM::Schema::ColumnInterface
+end
+
+describe MassiveRecord::ORM::Schema::TableInterface do
+  after do
+    TestColumnInterface.fields = nil
+  end
+
+  it "should respond_to default_attributes_from_schema" do
+    TestColumnInterface.should respond_to :default_attributes_from_schema
+  end
+
+  it "should have fields set to nil if no fields are defined" do
+    TestColumnInterface.fields.should be_nil
+  end
+
+  it "should have one field if one field is added" do
+    class TestColumnInterface
+      field :field_name, :string
+    end
+
+    TestColumnInterface.should have(1).fields
+    TestColumnInterface.fields.first.name.should == "field_name"
+  end
+
+  it "should not be possible to have to fields with the same name" do
+    lambda {
+      class TestColumnInterface
+        field :will_raise_error
+        field :will_raise_error
+      end
+    }.should raise_error MassiveRecord::ORM::Schema::InvalidField
+  end
+
+  it "should return attributes schema based on DSL" do
+    class TestColumnInterface
+      field :name
+      field :age, :integer, :default => 1
+    end
+
+    TestColumnInterface.attributes_schema["name"].type.should == :string
+    TestColumnInterface.attributes_schema["age"].type.should == :integer
+    TestColumnInterface.attributes_schema["age"].default.should == 1
+  end
+
+  it "should make attributes_schema readable from instances" do
+    class TestColumnInterface
+      field :name
+    end
+
+    TestColumnInterface.new.attributes_schema["name"].type.should == :string
+  end
+
+  it "should have a list of known attribute names" do
+    class TestColumnInterface
+      field :name, :string
+      field :age, :integer
+    end
+
+    TestColumnInterface.should have(2).known_attribute_names
+    TestColumnInterface.known_attribute_names.should include("name", "age")
+  end
+
+  it "should give us default attributes from schema" do
+    class TestColumnInterface
+      field :name
+      field :age, :integer, :default => 1
+    end
+
+    defaults = TestColumnInterface.default_attributes_from_schema
+    defaults["name"].should be_nil
+    defaults["age"].should == 1
+  end
+
+
+  describe "dynamically adding a field" do
+    it "should be possible to dynamically add a field" do
+      TestColumnInterface.add_field :name, :default => "NA"
+
+      TestColumnInterface.should have(1).fields
+
+      field = TestColumnInterface.fields.first
+
+      field.name.should == "name"
+      field.default.should == "NA"
+    end
+
+    it "should be possible to set field's type just like the DSL" do
+      TestColumnInterface.add_field :age, :integer, :default => 0
+
+      TestColumnInterface.fields.first.name.should == "age"
+      TestColumnInterface.fields.first.type.should == :integer
+      TestColumnInterface.fields.first.default.should == 0
+    end
+
+    it "should call class' undefine_attribute_methods to make sure it regenerates for newly added" do
+      TestColumnInterface.should_receive(:undefine_attribute_methods)
+      TestColumnInterface.add_field :name, :default => "NA"
+    end
+
+    it "should return the new field" do
+      field = TestColumnInterface.add_field :age, :integer, :default => 0
+      field.should == TestColumnInterface.fields.first
+    end
+
+    it "should insert the new field's default value right away" do
+      test_interface = TestColumnInterface.new
+      test_interface.should_receive("age=").with(1)
+      test_interface.add_field :age, :integer, :default => 1
+    end
+  end
+end

data/spec/orm/schema/field_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Schema::Field do
+  describe "initializer" do
+    %w(name column default).each do |attr_name|
+      it "should set #{attr_name}" do
+        field = MassiveRecord::ORM::Schema::Field.new attr_name => "a_value"
+        field.send(attr_name).should == "a_value"
+      end
+    end
+
+    it "should set type, cast it to a symbol" do
+      MassiveRecord::ORM::Schema::Field.new(:type => "a_value").type.should == :a_value
+    end
+
+    it "should default to type string" do
+      MassiveRecord::ORM::Schema::Field.new(:name => "a_value").type.should == :string
+    end
+  end
+
+  describe "new_with_arguments_from_dsl" do
+    it "should take the first argument as name" do
+      field = MassiveRecord::ORM::Schema::Field.new_with_arguments_from_dsl("info")
+      field.name.should == "info"
+    end
+
+    it "should take the second argument as type" do
+      field = MassiveRecord::ORM::Schema::Field.new_with_arguments_from_dsl("info", "integer")
+      field.type.should == :integer
+    end
+
+    it "should take the rest as options" do
+      field = MassiveRecord::ORM::Schema::Field.new_with_arguments_from_dsl("info", "integer", :default => 0)
+      field.default.should == 0
+    end
+  end
+
+  describe "validations" do
+    before do
+      @fields = MassiveRecord::ORM::Schema::Fields.new
+      @field = MassiveRecord::ORM::Schema::Field.new :name => "field_name", :fields => @fields
+    end
+
+    it "should be valid from before hook" do
+      @field.should be_valid
+    end
+
+    it "should not be valid if name is blank" do
+      @field.send(:name=, nil)
+      @field.should_not be_valid
+    end
+    
+    it "should not be valid without fields to belong to" do
+      @field.fields = nil
+      @field.should_not be_valid
+    end
+
+    it "should not be valid if it's parent some how knows that it's name has been taken" do
+      @fields.should_receive(:attribute_name_taken?).with("field_name").and_return true
+      @field.should_not be_valid
+    end
+
+    MassiveRecord::ORM::Schema::Field::TYPES.each do |type|
+      it "should be valid with type #{type}" do
+        @field.type = type
+        @field.should be_valid
+      end
+    end
+
+    it "should not be valid with foo as type" do
+      @field.type = :foo
+      @field.should_not be_valid
+    end
+  end
+
+  it "should cast name to string" do
+    field = MassiveRecord::ORM::Schema::Field.new(:name => :name)
+    field.name.should == "name"
+  end
+
+  it "should compare two column families based on name" do
+    field_1 = MassiveRecord::ORM::Schema::Field.new(:name => :name)
+    field_2 = MassiveRecord::ORM::Schema::Field.new(:name => :name)
+
+    field_1.should == field_2
+    field_1.eql?(field_2).should be_true
+  end
+
+  it "should have the same hash value for two families with the same name" do
+    field_1 = MassiveRecord::ORM::Schema::Field.new(:name => :name)
+    field_2 = MassiveRecord::ORM::Schema::Field.new(:name => :name)
+
+    field_1.hash.should == field_2.hash
+  end
+
+  describe "#decode" do
+    it "should return a value if value is of correct class" do
+      today = Date.today
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :created_at, :type => :date)
+      @subject.decode(today) == today
+    end
+
+    it "should decode a boolean value" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :boolean)
+      @subject.decode("1").should be_true
+      @subject.decode("0").should be_false
+      @subject.decode("").should be_nil
+      @subject.decode(nil).should be_nil
+    end
+
+    it "should decode a string value" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :string)
+      @subject.decode("value").should == "value"
+      @subject.decode("").should == ""
+      @subject.decode(nil).should be_nil
+    end
+
+    it "should decode an integer value" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :status, :type => :integer)
+      @subject.decode("1").should == 1
+      @subject.decode("").should be_nil
+      @subject.decode(nil).should be_nil
+    end
+
+    it "should decode an float value" do
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :code, :type => :float)
+      @subject.decode("12.345").should == 12.345
+      @subject.decode("").should be_nil
+      @subject.decode(nil).should be_nil
+    end
+    
+    it "should decode a date type" do
+      today = Date.today
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :created_at, :type => :date)
+      @subject.decode(today.to_s) == today
+      @subject.decode("").should be_nil
+      @subject.decode(nil).should be_nil
+    end
+    
+    it "should decode a time type" do
+      today = Time.now
+      @subject = MassiveRecord::ORM::Schema::Field.new(:name => :created_at, :type => :time)
+      @subject.decode(today.to_s) == today
+      @subject.decode("").should be_nil
+      @subject.decode(nil).should be_nil
+    end
+  end
+
+  describe "#unique_name" do
+    before do
+      @family = MassiveRecord::ORM::Schema::ColumnFamily.new :name => :info
+      @field = MassiveRecord::ORM::Schema::Field.new :name => "field_name"
+      @field_with_column = MassiveRecord::ORM::Schema::Field.new :name => "field_name", :column => "fn"
+    end
+
+    it "should raise an error if it has no contained_in" do
+      lambda { @field.unique_name }.should raise_error "Can't generate a unique name as I don't have a column family!"
+    end
+
+    it "should return correct unique name" do
+      @family << @field
+      @field.unique_name.should == "info:field_name"
+    end
+    
+    it "should return a correct unique name when using column" do
+      @family << @field_with_column
+      @field_with_column.unique_name.should == "info:fn"
+    end
+  end
+
+  describe "#column" do
+    before do
+      @field = MassiveRecord::ORM::Schema::Field.new :name => "field_name"
+    end
+
+    it "should default to name" do
+      @field.column.should == "field_name"
+    end
+
+    it "should be overridable" do
+      @field.column = "new"
+      @field.column.should == "new"
+    end
+
+    it "should be returned as a string" do
+      @field.column = :new
+      @field.column.should == "new"
+    end
+  end
+
+  it "should duplicate the default value" do
+    default_array = []
+    field = MassiveRecord::ORM::Schema::Field.new :name => "array", :type => :array, :default => default_array
+    field.default.object_id.should_not == default_array.object_id
+  end
+end

data/spec/orm/schema/fields_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe MassiveRecord::ORM::Schema::Fields do
+  before do
+    @fields = MassiveRecord::ORM::Schema::Fields.new
+  end
+
+  it "should be a kind of set" do
+    @fields.should be_a_kind_of Set
+  end
+
+  describe "add fields to the set" do
+    it "should be possible to add fields" do
+      @fields << MassiveRecord::ORM::Schema::Field.new(:name => "field")
+    end
+
+    it "should add self to field's fields attribute" do
+      field = MassiveRecord::ORM::Schema::Field.new(:name => :field)
+      @fields << field
+      field.fields.should == @fields
+    end
+
+    it "should not be possible to add two fields with the same name" do
+      @fields << MassiveRecord::ORM::Schema::Field.new(:name => "attr")
+      @fields.add?(MassiveRecord::ORM::Schema::Field.new(:name => "attr")).should be_nil
+    end
+
+    it "should raise error if invalid column familiy is added" do
+      invalid_field = MassiveRecord::ORM::Schema::Field.new
+      lambda { @fields << invalid_field }.should raise_error MassiveRecord::ORM::Schema::InvalidField
+    end
+  end
+
+  describe "#to_hash" do
+    before do
+      @name_field = MassiveRecord::ORM::Schema::Field.new(:name => :name)
+      @phone_field = MassiveRecord::ORM::Schema::Field.new(:name => :phone)
+      @fields << @name_field << @phone_field
+    end
+
+    it "should return nil if no fields are added" do
+      @fields.clear
+      @fields.to_hash.should == {}
+    end
+
+    it "should contain added fields" do
+      @fields.to_hash.should include("name" => @name_field)
+      @fields.to_hash.should include("phone" => @phone_field)
+    end
+  end
+
+  describe "#attribute_names" do
+    before do
+      @name_field = MassiveRecord::ORM::Schema::Field.new(:name => :name)
+      @phone_field = MassiveRecord::ORM::Schema::Field.new(:name => :phone)
+      @fields << @name_field << @phone_field
+    end
+
+    it "should return nil if no fields are added" do
+      @fields.clear
+      @fields.attribute_names.should == []
+    end
+
+    it "should contain added fields" do
+      @fields.attribute_names.should include("name", "phone")
+    end
+  end
+
+  describe "#attribute_name_taken?" do
+    before do
+      @name_field = MassiveRecord::ORM::Schema::Field.new(:name => :name)
+      @phone_field = MassiveRecord::ORM::Schema::Field.new(:name => :phone)
+      @fields << @name_field << @phone_field
+    end
+
+    describe "with no contained_in" do
+      it "should return true if name is taken" do
+        @fields.attribute_name_taken?("phone").should be_true
+      end
+
+      it "should accept and return true if name, given as a symbol, is taken" do
+        @fields.attribute_name_taken?(:phone).should be_true
+      end
+
+      it "should return false if name is not taken" do
+        @fields.attribute_name_taken?("not_taken").should be_false
+      end
+    end
+
+    describe "with contained_in set" do
+      before do
+        @fields.contained_in = MassiveRecord::ORM::Schema::ColumnFamily.new :name => "Family"
+      end
+
+      it "should ask object it is contained in for the truth about if attribute name is taken" do
+        @fields.contained_in.should_receive(:attribute_name_taken?).and_return true
+        @fields.attribute_name_taken?(:foo).should be_true
+      end
+
+      it "should not ask object it is contained in if asked not to" do
+        @fields.contained_in.should_not_receive(:attribute_name_taken?)
+        @fields.attribute_name_taken?(:foo, true).should be_false
+      end
+    end
+  end
+
+  describe "#field_by_name" do
+    before do
+      @name_field = MassiveRecord::ORM::Schema::Field.new(:name => :name)
+      @phone_field = MassiveRecord::ORM::Schema::Field.new(:name => :phone)
+      @fields << @name_field << @phone_field
+    end
+
+    it "should return nil if nothing is found" do
+      @fields.field_by_name("unkown").should be_nil
+    end
+
+    it "should return found field" do
+      @fields.field_by_name("name").should == @name_field
+    end
+
+    it "should return found field given as symbol" do
+      @fields.field_by_name(:name).should == @name_field
+    end
+  end
+end

data/spec/orm/schema/table_interface_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+class TestInterface
+  include MassiveRecord::ORM::Schema::TableInterface
+end
+
+class TestInterfaceSubClass < TestInterface
+end
+
+describe MassiveRecord::ORM::Schema::TableInterface do
+  after do
+    TestInterface.column_families = nil
+    TestInterfaceSubClass.column_families = nil
+  end
+
+
+  it "should respond_to column_family" do
+    TestInterface.should respond_to :column_family
+  end
+
+  it "should respond_to column_families" do
+    TestInterface.should respond_to :column_families
+  end
+
+  it "should be possible to add column familiy through DSL" do
+    class TestInterface
+      column_family :misc do; end
+    end
+
+    TestInterface.column_families.collect(&:name).should include("misc")
+  end
+
+  it "should be possible to add fields to a column families" do
+    class TestInterface
+      column_family :info do
+        field :name
+      end
+    end
+
+    TestInterface.known_attribute_names.should == ["name"]
+  end
+
+  it "should return attributes schema based on DSL" do
+    class TestInterface
+      column_family :info do
+        field :name
+        field :age, :integer, :default => 1
+      end
+    end
+
+    TestInterface.attributes_schema["name"].type.should == :string
+    TestInterface.attributes_schema["age"].type.should == :integer
+    TestInterface.attributes_schema["age"].default.should == 1
+  end
+
+  it "should raise an error if you try to add same field name twice" do
+    lambda { 
+      class TestInterface
+        column_family :info do
+          field :name
+          field :name
+        end
+      end
+    }.should raise_error MassiveRecord::ORM::Schema::InvalidField
+  end
+
+  it "should give us default attributes from schema" do
+    class TestInterface
+      column_family :info do
+        field :name
+        field :age, :integer, :default => 1
+      end
+    end
+
+    defaults = TestInterface.default_attributes_from_schema
+    defaults["name"].should be_nil
+    defaults["age"].should == 1
+  end
+
+  it "should make attributes_schema readable from instances" do
+    class TestInterface
+      column_family :info do
+        field :name
+      end
+    end
+
+    TestInterface.new.attributes_schema["name"].type.should == :string
+  end
+
+  it "should not be shared amonb subclasses" do
+    class TestInterface
+      column_family :info do
+        autoload_fields
+      end
+    end
+
+    TestInterface.column_families.should_not be_nil
+    TestInterfaceSubClass.column_families.should be_nil
+  end
+
+
+  describe "dynamically adding a field" do
+    it "should be possible to dynamically add a field" do
+      TestInterface.add_field_to_column_family :info, :name, :default => "NA"
+
+      TestInterface.should have(1).column_families
+
+      family = TestInterface.column_families.first
+      family.name.should == "info"
+
+      family.fields.first.name.should == "name"
+      family.fields.first.default.should == "NA"
+    end
+
+    it "should be possible to set field's type just like the DSL" do
+      TestInterface.add_field_to_column_family :info, :age, :integer, :default => 0
+
+      TestInterface.column_families.first.fields.first.name.should == "age"
+      TestInterface.column_families.first.fields.first.type.should == :integer
+      TestInterface.column_families.first.fields.first.default.should == 0
+    end
+
+    it "should call class' undefine_attribute_methods to make sure it regenerates for newly added" do
+      TestInterface.should_receive(:undefine_attribute_methods)
+      TestInterface.add_field_to_column_family :info, :name, :default => "NA"
+    end
+
+    it "should return the new field" do
+      field = TestInterface.add_field_to_column_family :info, :age, :integer, :default => 0
+      field.should == TestInterface.column_families.first.fields.first
+    end
+
+    it "should insert the new field's default value right away" do
+      test_interface = TestInterface.new
+      test_interface.should_receive("age=").with(1)
+      test_interface.add_field_to_column_family :info, :age, :integer, :default => 1
+    end
+  end
+
+
+
+  describe "autoload_column_families_and_fields_with" do
+    before do
+      class TestInterface
+        column_family :info do
+          autoload_fields
+        end
+
+        column_family :misc do
+          field :text
+        end
+      end
+
+      @column_names = %w(info:name misc:other)
+    end
+
+    it "should not add fields to misc" do
+      TestInterface.column_families.family_by_name("misc").should_not_receive(:add?)
+      TestInterface.autoload_column_families_and_fields_with(@column_names)
+    end
+
+    it "should add fields to info" do
+      TestInterface.column_families.family_by_name("info").should_receive(:add?)
+      TestInterface.autoload_column_families_and_fields_with(@column_names)
+    end
+
+    it "should be possible to run twice" do
+      2.times { TestInterface.autoload_column_families_and_fields_with(@column_names) }
+    end
+  end
+end