chicagowarehouse 0.3.1

data/spec/schema/fact_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Chicago::Schema::Fact do
+  it_behaves_like "a named schema element"
+
+  it "has a table name" do
+    described_class.new("foo").table_name.should == :facts_foo
+  end
+  
+  it "has no dimensions by default" do
+    described_class.new("foo").dimensions.should be_empty
+  end
+
+  it "has no degenerate dimensions by default" do
+    described_class.new("foo").degenerate_dimensions.should be_empty
+  end
+
+  it "has no measures by default" do
+    described_class.new("foo").degenerate_dimensions.should be_empty
+  end
+
+  it "can have a description" do
+    described_class.new(:foo, :description => "bar").description.should == "bar"
+  end
+  
+  it "can have dimensions" do
+    dimension = stub(:dimension)
+    described_class.new("foo", :dimensions => [dimension]).
+      dimensions.should == [dimension]
+  end
+
+  it "has degenerate dimensions" do
+    column = stub(:column)
+    described_class.new("foo", :degenerate_dimensions => [column]).
+      degenerate_dimensions.should == [column]
+  end
+
+  it "has measures" do
+    column = stub(:column)
+    described_class.new("foo", :measures => [column]).
+      measures.should == [column]
+  end
+
+  it "has columns defined as dimensions, degenerate dimensions & measures" do
+
+    dimension = stub(:dimension)
+    column = stub(:column)
+    column_2 = stub(:column_2)
+    fact = described_class.new("foo",
+                             :dimensions => [dimension],
+                             :degenerate_dimensions => [column],
+                             :measures => [column_2])
+    fact.columns.should == [dimension, column, column_2]
+  end
+
+  it "can qualify a column" do
+    described_class.new(:foo).qualify(stub(:column, :name => :bar)).
+      should == :bar.qualify(:facts_foo)
+  end
+
+  it "provides a hash-like accessor syntax for columns" do
+    measure = stub(:column, :name => :bar)
+    fact = described_class.new(:foo, :measures => [measure])
+    fact[:bar].should == measure
+  end
+
+  it "is factless if it has no measures" do
+    described_class.new(:foo, :measures => [stub()]).should_not be_factless
+    described_class.new(:foo).should be_factless    
+  end
+
+  it "can define a natural key" do
+    described_class.new(:f, :natural_key => [:foo, :bar]).
+      natural_key.should == [:foo, :bar]
+  end
+
+  it "is visitable" do
+    visitor = mock(:visitor)
+    fact = described_class.new(:foo)
+    visitor.should_receive(:visit_fact).with(fact)
+    fact.visit(visitor)
+  end
+end

data/spec/schema/measure_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Chicago::Schema::Measure do
+  subject { described_class.new(:user_name, :string) }
+
+  it_behaves_like "a column"
+
+  it "should not be semi_additive by default" do
+    described_class.new(:rate, :integer).should_not be_semi_additive
+  end
+  
+  it "can be defined as semi_additive" do
+    described_class.new(:rate, :integer, :semi_additive => true).
+      should be_semi_additive
+  end
+
+  it "is not indexed" do
+    described_class.new(:rate, :integer).should_not be_indexed
+  end
+  
+  it "is visitable" do
+    visitor = mock(:visitor)
+    measure = described_class.new(:foo, :integer)
+    visitor.should_receive(:visit_measure).with(measure)
+    measure.visit(visitor)
+  end
+end

data/spec/schema/named_element_collection_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Chicago::Schema::NamedElementCollection do
+  before :each do
+    @e = stub(:element, :name => :foo)
+  end
+  
+  it "supports adding an element via add" do
+    subject.add(@e)
+    subject.to_a.should == [@e]
+  end
+
+  it "supports adding an element via <<" do
+    subject << @e
+    subject.to_a.should == [@e]
+  end
+
+  it "returns the element just added" do
+    subject.add(@e).should == @e
+  end
+
+  it "can be iterated over" do
+    subject.add(@e)
+    subject.each {|element| element.should == @e }
+  end
+
+  it "is enumerable" do
+    subject.should be_kind_of(Enumerable)
+  end
+
+  it "supports access by name" do
+    subject.add @e
+    subject[:foo].should == @e
+  end
+
+  it "returns true from contains? if the collection contains the same-named element" do
+    subject.add @e
+    subject.contain?(stub(:element, :name => :foo)).should be_true
+    subject.contain?(stub(:element, :name => :bar)).should be_false    
+  end
+
+  it "returns the number of elements in a collection from size" do
+    subject.add @e
+    subject.size.should == 1
+  end
+
+  it "returns the number of elements in a collection from length" do
+    subject.add @e
+    subject.length.should == 1
+  end
+
+  it "responds to empty?" do
+    subject.should be_empty
+    subject.add @e
+    subject.should_not be_empty
+  end
+
+  it "can be constructed with a list of elements" do
+    described_class.new(@e).contain?(@e).should be_true
+  end
+
+  it "has elements that are unique by name" do
+    subject.add(@e)
+    subject.add(stub(:element, :name => :foo))
+    subject.size.should == 1
+  end
+end

data/spec/schema/pivoted_column_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Chicago::Schema::PivotedColumn do
+  before :each do
+    @column = stub(:column)
+    @pivot  = stub(:pivot)
+  end
+  
+  it "has a nil group name" do
+    described_class.new(@column, @pivot, 0, true).group_name.should be_nil
+  end
+
+  it "has a pair of labels as the label" do
+    @column.stub(:label => :foo)
+    described_class.new(@column, @pivot, 0, true).label.should == [:foo, true]
+  end
+end

data/spec/schema/query_column_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'chicago/schema/query_column'
+
+describe Chicago::Schema::QueryColumn do
+  describe "a standard column" do
+    let(:owner) { stub(:owner).as_null_object }
+    let(:column) { stub(:column).as_null_object }
+    subject { described_class.column(owner, column, "foo.bar") }
+    
+    it "should have a column alias" do
+      subject.column_alias.should == "foo.bar"
+    end
+
+    it "has an owner" do
+      subject.owner.should == owner
+    end
+
+    it "has a sequel qualified name for use in SELECT statements" do
+      owner.stub(:name).and_return(:foo)
+      column.stub(:name).and_return(:bar)
+      subject.select_name.should == :bar.qualify(:foo)
+    end
+
+    it "has a sequel qualified name for use in COUNT" do
+      owner.stub(:name).and_return(:foo)
+      column.stub(:name).and_return(:bar)
+      subject.count_name.should == :bar.qualify(:foo)
+    end
+
+    it "uses the alias in GROUP BY" do
+      subject.group_name.should == :"foo.bar"
+    end
+
+    it "delegates label to the decorated column" do
+      column.should_receive(:label).and_return("Bar")
+      subject.label.should == "Bar"
+    end
+  end
+
+  describe "a dimension column" do
+    let(:owner) { stub(:owner).as_null_object }
+    let(:column) { stub(:column).as_null_object }
+    subject { described_class.column(owner, column, "foo.bar") }
+
+    before :each do
+      column.stub(:main_identifier).and_return(:name)
+      column.stub(:original_key).and_return(stub(:name => :original_id))
+      column.stub(:kind_of?).with(Chicago::Schema::Dimension).and_return(true)
+    end
+    
+    it "should have a column alias" do
+      subject.column_alias.should == "foo.bar"
+    end
+
+    it "has an owner" do
+      subject.owner.should == owner
+    end
+
+    it "uses the main identifier in SELECT statements" do
+      column.stub(:name).and_return(:bar)
+      subject.select_name.should == :name.qualify(:bar)
+    end
+
+    it "uses the original id in COUNT" do
+      column.stub(:name).and_return(:bar)
+      subject.count_name.should == :original_id.qualify(:bar)
+    end
+
+    it "uses the original id in GROUP BY" do
+      column.stub(:name).and_return(:bar)
+      subject.group_name.should == :original_id.qualify(:bar)
+    end
+
+    it "delegates label to the decorated column" do
+      column.should_receive(:label).and_return("Bar")
+      subject.label.should == "Bar"
+    end
+  end
+
+  describe "a dimension identifier column" do
+    let(:owner) { stub(:owner).as_null_object }
+    let(:column) { stub(:column).as_null_object }
+    subject { described_class.column(owner, column, "foo.bar") }
+
+    before :each do
+      column.stub(:name).and_return(:bar)
+
+      owner.stub(:name).and_return(:foo)
+      owner.stub(:original_key).and_return(stub(:name => :original_id))
+      owner.stub(:kind_of?).with(Chicago::Schema::Dimension).and_return(true)
+      owner.stub(:identifiable?).and_return(true)
+      owner.stub(:identifiers).and_return([:bar])
+    end
+    
+    it "should have a column alias" do
+      subject.column_alias.should == "foo.bar"
+    end
+
+    it "has an owner" do
+      subject.owner.should == owner
+    end
+
+    it "uses the name in SELECT statements" do
+      subject.select_name.should == :bar.qualify(:foo)
+    end
+
+    it "uses the original id in COUNT" do
+      subject.count_name.should == :original_id.qualify(:foo)
+    end
+
+    it "uses the original id in GROUP BY" do
+      subject.group_name.should == :original_id.qualify(:foo)
+    end
+
+    it "delegates label to the decorated column" do
+      column.should_receive(:label).and_return("Bar")
+      subject.label.should == "Bar"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'chicago'
+require 'rspec'
+require 'yaml'
+require 'rspec/autorun'
+require 'timecop'
+
+include Chicago
+
+unless defined? TEST_DB
+  TEST_DB = Sequel.connect(YAML.load(File.read(File.dirname(__FILE__) + "/db_connections.yml")))
+end
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+end

data/spec/star_schema_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+describe Chicago::StarSchema do
+  before :each do
+    @schema = Chicago::StarSchema.new
+  end
+
+  describe "dimensions" do
+    specify "are not defined initially" do
+      @schema.dimensions.should be_empty
+    end
+
+    specify "can be defined" do
+      @schema.define_dimension(:user).should be_kind_of(Chicago::Schema::Dimension)
+      @schema.dimensions.should_not be_empty
+    end
+
+    specify "are unique by name within a schema" do
+      @schema.define_dimension(:user)
+      expect { @schema.define_dimension(:user) }.
+        to raise_error(Chicago::DuplicateTableError)
+    end
+
+    specify "can be defined with columns" do
+      dimension = @schema.define_dimension(:user) do
+        columns { string :email }
+      end      
+      dimension.should have_column_named(:email)
+    end
+
+    specify "can define columns in multiple blocks" do
+      dimension = @schema.define_dimension(:user) do
+        columns { string :email }
+        columns { string :name }        
+      end      
+      dimension.should have_column_named(:name)
+    end
+
+    specify "can have a natural key defined" do
+      dimension = @schema.define_dimension(:user) do
+        columns { string :email }
+
+        natural_key :email
+      end      
+
+      dimension.natural_key.should == [:email]
+    end
+
+    specify "can have a description defined" do
+      dimension = @schema.define_dimension(:user) do
+        description "Hello"
+      end
+      dimension.description.should == "Hello"
+    end
+    
+    specify "can have null records defined" do
+      dimension = @schema.define_dimension(:user) do
+        columns { string :email }
+
+        null_record :id => 1, :email => "Missing"
+        null_record :id => 2, :email => "Not Applicable"
+      end      
+
+      db = stub(:db, :table_exists? => true)
+      db.stub_chain(:[], :insert_replace).and_return(db)
+      db.should_receive(:insert_multiple).with([{:id => 1, :email => "Missing"},
+                                                {:id => 2, :email => "Not Applicable"}])
+      db.should_receive(:insert_multiple).with([{:dimension_id => 1},
+                                                {:dimension_id => 2}])
+      dimension.create_null_records(db)
+    end
+
+    specify "can be prebuilt and attached" do
+      d = Chicago::Schema::Dimension.new(:foo)
+      @schema.add(d)
+      @schema.dimensions.should include(d)
+    end
+  end
+
+  describe "shrunken dimensions" do
+    specify "can be defined" do
+      @schema.define_dimension(:date) do
+        columns do
+          integer :year
+          integer :month
+          integer :day
+        end
+      end
+
+      @schema.define_shrunken_dimension(:month, :date) do
+        columns :year, :month
+      end.columns.map(&:name).should == [:year, :month]
+    end
+
+    specify "must have a subset of columns from the base dimension" do
+      @schema.define_dimension(:date) do
+        columns { integer :year }
+      end
+
+      expect {
+        @schema.define_shrunken_dimension(:month, :date) do
+          columns :year, :month
+        end
+      }.to raise_error(Chicago::MissingDefinitionError)
+    end
+
+    specify "raises an error if the base dimension is not defined" do
+      expect {
+        @schema.define_shrunken_dimension(:month, :date)
+      }.to raise_error(Chicago::MissingDefinitionError)
+    end
+  end
+  
+  describe "facts" do
+    specify "are not defined initially" do
+      @schema.facts.should be_empty
+    end
+
+    specify "can be defined" do
+      @schema.define_fact(:user).should be_kind_of(Chicago::Schema::Fact)
+      @schema.facts.should_not be_empty
+    end
+
+    specify "are unique by name within a schema" do
+      @schema.define_fact(:user)
+      expect { @schema.define_fact(:user) }.
+        to raise_error(Chicago::DuplicateTableError)
+    end
+
+    specify "can be prebuilt and attached" do
+      f = Chicago::Schema::Fact.new(:foo)
+      @schema.add(f)
+      @schema.facts.should include(f)
+    end
+
+    specify "can be prebuilt and attached, but still must have unique names" do
+      f = Chicago::Schema::Fact.new(:foo)
+      f2 = Chicago::Schema::Fact.new(:foo)
+      @schema.add(f)
+      expect { @schema.add(f2) }.to raise_error(Chicago::DuplicateTableError)
+    end
+
+    specify "can have dimensions defined" do
+      dim  = @schema.define_dimension(:date)
+      fact = @schema.define_fact(:foo) do
+        dimensions :date
+      end
+      fact.dimensions.map(&:name).should include(:date)
+    end
+
+    specify "raises an error if unspecified dimension is referenced" do
+      expect { @schema.define_fact(:foo) { dimensions :date } }.
+        to raise_error(Chicago::MissingDefinitionError)
+    end
+
+    specify "can have roleplayed dimensions defined, using Sequel's aliasing" do
+      dim  = @schema.define_dimension(:date)
+      fact = @schema.define_fact(:foo) do
+        dimensions :date.as(:start_date)
+      end
+      fact.dimensions.map(&:name).should include(:start_date)
+    end
+
+    specify "can have degenerate dimensions defined" do
+      fact = @schema.define_fact(:foo) do
+        degenerate_dimensions do
+          integer :reference_number
+        end
+      end
+      fact.degenerate_dimensions.map(&:name).should include(:reference_number)
+    end
+
+    specify "can have measures defined" do
+      fact = @schema.define_fact(:foo) do
+        measures do
+          integer :amount
+        end
+      end
+      fact.measures.map(&:name).should include(:amount)
+    end
+
+    specify "allows defined measures to be null by default" do
+      fact = @schema.define_fact(:foo) do
+        measures { integer :amount }
+      end
+      fact.measures.first.should be_null
+    end
+
+    specify "can have a description defined" do
+      fact = @schema.define_fact(:foo) do
+        description "Hello"
+      end
+      fact.description.should == "Hello"
+    end
+    
+    specify "can have a natural key defined" do
+      dim  = @schema.define_dimension(:date)
+      fact = @schema.define_fact(:foo) do
+        dimensions :date
+
+        natural_key :date
+      end
+      
+      fact.natural_key.should == [:date]
+    end
+  end
+  
+  it "allows definition of a fact and a dimension with the same name" do
+    @schema.define_fact(:user)
+    expect { @schema.define_dimension(:user) }.
+      to_not raise_error(Chicago::DuplicateTableError)
+  end
+
+  it "returns all dimensions and facts from #tables" do
+    @schema.define_fact(:fact)
+    @schema.define_dimension(:dimension)
+    @schema.tables.map(&:name).should == [:dimension, :fact]
+  end
+end