chicagowarehouse 0.3.1

data/spec/schema/column_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+
+describe Chicago::Schema::Column do
+  subject { described_class.new(:user_name, :string) }
+
+  it_behaves_like "a column"
+  
+  it "should be equal to another column definition with the same attributes" do
+    described_class.new(:username, :string).should == described_class.new(:username, :string)
+  end
+
+  it "should not be equal to another column definition with the different attributes" do
+    described_class.new(:username, :string).should_not == described_class.new(:username, :integer)
+  end
+
+  it "should have a #min method" do
+    described_class.new(:username, :string, :min => 0).min.should == 0
+  end
+
+  it "should have a min of 0 by default for money columns" do
+    described_class.new(:username, :money).min.should == 0
+  end
+
+  it "should have a #max method" do
+    described_class.new(:username, :string, :max => 10).max.should == 10
+  end
+
+  it "should set min and max from an enumerable object's min and max" do
+    column = described_class.new(:username, :string, :range => 1..5)
+    column.min.should == 1
+    column.max.should == 5
+  end
+
+  it "should forbid null values by default" do
+    described_class.new(:username, :string).should_not be_null
+  end
+
+  it "should allow you to accept non-null values" do
+    described_class.new(:username, :string, :null => true).should be_null
+  end
+
+  it "should allow null values by default for date, datetime or timestamp columns" do
+    described_class.new(:username, :timestamp).should be_null
+    described_class.new(:username, :date).should be_null
+    described_class.new(:username, :datetime).should be_null
+  end
+
+  it "can define a set of valid elements" do
+    described_class.new(:username, :string, :elements => ['A', 'B']).elements.should == ['A', 'B']
+  end
+
+  it "can have a default value" do
+    described_class.new(:username, :string, :default => 'A').default.should == 'A'
+  end
+
+  it "should have a default value of false for booleans that don't allow null" do
+    described_class.new(:username, :boolean).default_value.should == false
+  end
+
+  it "should have a default value of 0 for numbers that don't allow null" do
+    described_class.new(:username, :integer).default_value.should == 0
+  end
+
+  it "should have a default value of '' for strings that don't allow null" do
+    described_class.new(:username, :string).default_value.should == ''
+  end
+
+  it "should have a descriptive? method, false by default" do
+    described_class.new(:username, :string).should_not be_descriptive
+  end
+
+  it "should be definable as descriptive" do
+    described_class.new(:username, :string, :descriptive => true).should be_descriptive
+  end
+
+  it "is indexed by default" do
+    described_class.new(:rate, :integer).should be_indexed
+  end
+
+  it "should not be indexed if descriptive" do
+    described_class.new(:username, :string, :descriptive => true).should_not be_indexed
+  end
+
+  it "should be numeric if an integer" do
+    described_class.new(:username, :integer).should be_numeric
+  end
+
+  it "should be numeric if a money" do
+    described_class.new(:username, :money).should be_numeric
+  end
+
+  it "should be numeric if a float" do
+    described_class.new(:username, :float).should be_numeric
+  end
+
+  it "should be numeric if a decimal" do
+    described_class.new(:username, :decimal).should be_numeric
+  end
+
+  it "should be numeric if a percentage" do
+    described_class.new(:username, :percent).should be_numeric
+  end
+
+  it "should not be numeric if a string" do
+    described_class.new(:username, :string).should_not be_numeric
+  end
+
+  it "should be textual if a string" do
+    described_class.new(:username, :string).should be_textual
+  end
+
+  it "should be textual if a text" do
+    described_class.new(:username, :text).should be_textual
+  end
+
+  it "should not be textual if an integer" do
+    described_class.new(:username, :integer).should_not be_textual
+  end
+
+  it "can be countable" do
+    col = described_class.new(:username, :string, :countable => true)
+    col.should be_countable
+  end
+
+  it "can have a specific label when counted" do
+    col = described_class.new(:username, :string, :countable => "No. of users")
+    col.should be_countable
+    col.countable_label.should == "No. of users"
+  end
+
+  it "can be internal, i.e. for internal use only, and not to be displayed in an interface" do
+    described_class.new(:random_ref, :string, :internal => true).
+      should be_internal
+  end
+
+  it "can be qualified by a table" do
+    described_class.new(:foo, :string).qualify_by(:bar).should == :foo.qualify(:bar)
+  end
+
+  it "is optional by default if it allows null values" do
+    described_class.new(:foo, :string, :null => false).should_not be_optional
+    described_class.new(:foo, :string, :null => true).should be_optional
+  end
+
+  it "is optional by default if it allows null values" do
+    described_class.new(:foo, :string, :null => false, :optional => true).
+      should be_optional
+    described_class.new(:foo, :string, :null => true, :optional => false).
+      should_not be_optional
+  end
+  
+  it "is visitable" do
+    visitor = mock(:visitor)
+    column = described_class.new(:foo, :integer)
+    visitor.should_receive(:visit_column).with(column)
+    column.visit(visitor)
+  end
+end
+
+describe "Chicago::Schema::Column#hash" do
+  it "should have a :name entry" do
+    Chicago::Schema::Column.new(:username, :string, :max => 8).to_hash[:name].should == :username
+  end
+
+  it "should have a :column_type entry" do
+    Chicago::Schema::Column.new(:username, :string, :max => 8).to_hash[:column_type].should == :string
+  end
+
+  it "should not have a :default entry by default" do
+    Chicago::Schema::Column.new(:username, :string).to_hash.keys.should_not include(:default)
+  end
+
+  it "should have a :default entry if specified" do
+    Chicago::Schema::Column.new(:username, :string, :default => 'A').to_hash[:default].should == 'A'
+  end
+
+  it "should have an :unsigned entry if relevant" do
+    Chicago::Schema::Column.new(:id, :integer, :min => 0).to_hash[:unsigned].should be_true
+  end
+
+  it "should have an :entries entry if relevant" do
+    Chicago::Schema::Column.new(:username, :string, :elements => ['A']).to_hash[:elements].should == ['A']
+  end
+
+  it "should not have an :entries entry if relevant" do
+    Chicago::Schema::Column.new(:username, :string).to_hash.keys.should_not include(:elements)
+  end
+
+  it "should have a :size entry if max is present and type is string" do
+    Chicago::Schema::Column.new(:username, :string, :max => 8).to_hash[:size].should == 8
+  end
+
+  it "should have a default :size of [12,2] for money types" do
+    Chicago::Schema::Column.new(:some_value, :money).to_hash[:size].should == [12,2]
+  end
+
+  it "should be unsigned by default if a percentage" do
+    Chicago::Schema::Column.new(:some_value, :percent).to_hash[:unsigned].should be_true
+  end
+
+  it "should have a default :size of [6,3] for percent types" do
+    Chicago::Schema::Column.new(:rate, :percent).to_hash[:size].should == [6,3]
+  end
+
+  it "should have a :size that is set explictly" do
+    Chicago::Schema::Column.new(:username, :money, :size => 'huge').to_hash[:size].should == 'huge'
+  end
+
+  it "should explicitly set the default to nil for timestamp columns" do
+    Chicago::Schema::Column.new(:username, :timestamp).to_hash.has_key?(:default).should be_true
+    Chicago::Schema::Column.new(:username, :timestamp).to_hash[:default].should be_nil
+  end
+end

data/spec/schema/dimension_builder_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Chicago::Schema::Builders::DimensionBuilder do
+  before :each do
+    @builder = described_class.new(stub())
+  end
+
+  it "builds a dimension" do
+    @builder.build("foo").should be_kind_of(Chicago::Schema::Dimension)
+  end
+  
+  it "builds a dimension with a name" do
+    @builder.build("foo").name.should == :foo
+  end
+
+  it "can have a column builder specified" do    
+    @builder.column_builder = Class.new do
+      def initialize(klass)
+      end
+      
+      def build
+        [:column] if block_given?
+      end
+    end
+
+    @builder.build(:foo) do
+      columns do
+        # No op
+      end
+    end.columns.should == [:column]
+  end
+end

data/spec/schema/dimension_reference_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Chicago::Schema::DimensionReference do
+  before :each do
+    @dimension = Chicago::Schema::Dimension.new(:bar)
+  end
+
+  it "returns columns from the dimension" do
+    @dimension.should_receive(:columns).and_return(:result)
+    described_class.new(:foo, @dimension).columns.should == :result
+  end
+
+  it "returns columns via column_definitions [DEPRECTAED]" do
+    @dimension.should_receive(:column_definitions).and_return(:result)
+    described_class.new(:foo, @dimension).column_definitions.
+      should == :result
+  end
+
+  it "returns identifiers from the dimension" do
+    @dimension.should_receive(:identifiers).and_return(:result)
+    described_class.new(:foo, @dimension).identifiers.should == :result
+  end
+
+  it "returns main identifier from the dimension" do
+    @dimension.should_receive(:main_identifier).and_return(:result)
+    described_class.new(:foo, @dimension).main_identifier.should == :result
+  end
+
+  it "returns identifiable? from the dimension" do
+    @dimension.should_receive(:identifiable?).and_return(true)
+    described_class.new(:foo, @dimension).should be_identifiable
+  end
+
+  it "returns original_key from the dimension" do
+    @dimension.should_receive(:original_key).and_return(:result)
+    described_class.new(:foo, @dimension).original_key.should == :result
+  end
+
+  it "returns natural_key from the dimension" do
+    @dimension.should_receive(:natural_key).and_return(:result)
+    described_class.new(:foo, @dimension).natural_key.should == :result
+  end
+
+  it "returns [] from the dimension" do
+    @dimension.should_receive(:[]).with(:bar).and_return(:result)
+    described_class.new(:foo, @dimension)[:bar].should == :result
+  end
+
+  it "has a table name from the dimension" do
+    @dimension.should_receive(:table_name).and_return(:result)
+    described_class.new(:foo, @dimension).table_name.should == :result
+  end
+
+  it "has a minimum of 0" do
+    described_class.new(:foo, @dimension).min.should == 0
+  end
+
+  it "should have a column_type of integer" do
+    described_class.new(:foo, @dimension).column_type.should == :integer
+  end
+
+  it "should have a key name" do
+    described_class.new(:foo, @dimension).key_name.should == :foo_dimension_id
+  end
+
+  it "qualfies a column based on the column name" do
+    column = stub(:column, :name => :baz)
+    column.should_receive(:qualify_by).with(:dimension_foo)
+    described_class.new(:foo, @dimension).qualify(column)
+  end
+
+  it "can be qualified, and qualifies the key name" do
+    described_class.new(:foo, @dimension).qualify_by(:facts_bar).should == :foo_dimension_id.qualify(:facts_bar)
+  end
+
+  it "should be considered a kind of dimension" do
+    described_class.new(:foo, @dimension).should be_kind_of(Chicago::Schema::Dimension)
+  end
+
+  it "can override the key selected as the reference" do
+    described_class.new(:foo, @dimension, :key_name => :baz_dimension_id).key_name.should ==:baz_dimension_id
+  end
+  
+  it "is visitable" do
+    visitor = mock(:visitor)
+    column = described_class.new(:foo, @dimension)
+    visitor.should_receive(:visit_dimension_reference).with(column)
+    column.visit(visitor)
+  end
+end

data/spec/schema/dimension_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Chicago::Schema::Dimension do
+  it_behaves_like "a named schema element"
+
+  it "has a table name" do
+    described_class.new(:foo).table_name.should == :dimension_foo
+  end
+
+  it "has a key table name" do
+    described_class.new(:foo).key_table_name.should == :keys_dimension_foo
+  end
+
+  it "can have a description" do
+    described_class.new(:foo, :description => "bar").description.should == "bar"
+  end
+  
+  it "has columns" do
+    column = stub(:column)
+    described_class.new(:foo, :columns => [column]).
+      columns.should == [column]
+  end
+
+  it "has no columns by default" do
+    described_class.new(:foo).columns.should be_empty
+  end
+
+  it "can qualify a column" do
+    described_class.new(:foo).qualify(stub(:column, :name => :bar)).
+      should == :bar.qualify(:dimension_foo)
+  end
+
+  it "provides a hash-like accessor syntax for columns" do
+    column = stub(:column, :name => :bar)
+    dimension = described_class.new(:foo, :columns => [column])
+    dimension[:bar].should == column
+  end
+
+  it "can have identifiers" do
+    identifiers = [stub(:i), stub(:j)]
+    described_class.new(:user, :identifiers => identifiers).
+      identifiers.should == identifiers
+  end
+  
+  it "can have a main identifier" do
+    identifiers = [stub(:i), stub(:j)]
+    described_class.new(:user, :identifiers => identifiers).
+      main_identifier.should == identifiers.first
+  end
+
+  it "can create null records in the database, replacing existing records" do
+    db = mock(:db)
+    db.stub(:[]).and_return(db)
+    db.stub(:table_exists?).with(:keys_dimension_user).and_return(true)
+    db.should_receive(:insert_replace).twice.and_return(db)
+    db.should_receive(:insert_multiple).with([{:id => 1, :foo => :bar}])
+    db.should_receive(:insert_multiple).with([{:dimension_id => 1}])
+    described_class.new(:user,
+                           :null_records => [{ :id => 1,
+                                               :foo => :bar}]).create_null_records(db)
+  end
+
+  it "doesn't attempt to create null rows in non-existent key table" do
+    db = mock(:db)
+    db.stub(:[]).and_return(db)
+    db.stub(:table_exists?).with(:keys_dimension_user).and_return(false)
+    db.should_receive(:insert_replace).and_return(db)
+    db.should_receive(:insert_multiple).with([{:id => 1, :foo => :bar}])
+    described_class.new(:user,
+                           :null_records => [{ :id => 1,
+                                               :foo => :bar}]).create_null_records(db)
+  end
+
+  it "should disallow null records without id fields" do
+    expect do
+      described_class.new(:user,
+                             :null_records => [{:foo => :bar}])
+    end.to raise_error(Chicago::UnsafeNullRecordError)
+  end
+
+  it "can define a natural key" do
+    described_class.new(:user, :natural_key => [:foo, :bar]).
+      natural_key.should == [:foo, :bar]
+  end
+
+  it "supports column_definitions [DEPRECATED]" do
+    dimension = described_class.new(:user, :natural_key => [:foo, :bar])
+    dimension.columns.should == dimension.column_definitions
+  end
+
+  it "supports original_key if it has an original_id column [DEPRECATED]" do
+    column = stub(:c, :name => :original_id)
+    described_class.new(:user, :columns => [column]).original_key.should == column
+  end
+
+  it "is considered identifiable if it has an original key [DEPRECATED]" do
+    column = stub(:c, :name => :original_id)
+    described_class.new(:user, :columns => [column]).should be_identifiable
+  end
+
+  it "can have predetermined values" do
+    described_class.new(:countries, :predetermined_values => true).should have_predetermined_values
+  end
+  
+  it "is visitable" do
+    visitor = mock(:visitor)
+    dimension = described_class.new(:foo)
+    visitor.should_receive(:visit_dimension).with(dimension)
+    dimension.visit(visitor)
+  end
+end