cranium 0.2.0

data/spec/cranium/transformation/index_spec.rb

@@ -0,0 +1,178 @@
+require_relative '../../spec_helper'
+
+describe Cranium::Transformation::Index do
+
+  let(:index) { Cranium::Transformation::Index.new }
+  let(:connection) { double "Greenplum connection" }
+  let(:dimension_manager) { double "DimensionManager" }
+
+  before(:each) do
+    allow(Cranium::Database).to receive(:connection).and_return(connection)
+  end
+
+
+
+  def stub_cache_query(table_name, key_fields, value_field, result)
+    allow(dimension_manager).to receive(:create_cache_for_field).with(value_field).and_return(result)
+    allow(Cranium::DimensionManager).to receive(:for).with(table_name, key_fields).and_return(dimension_manager)
+  end
+
+
+
+  describe "#lookup" do
+    context "the first time it's called" do
+      it "should query the requested key value from the database" do
+        stub_cache_query :dim_contact, [:customer_id], :contact_key, {[1234] => "contact 1",
+                                                                      [2345] => "contact 2",
+                                                                      [3456] => "contact 3"}
+
+        expect(index.lookup(:contact_key, from_table: :dim_contact, match_column: :customer_id, to_value: 2345)).to eq("contact 2")
+      end
+
+      it "should query the requested multi-key value from the database" do
+        stub_cache_query :dim_contact, [:key_1, :key_2], :contact_key, {[12, 34] => "contact 1",
+                                                                        [23, 45] => "contact 2",
+                                                                        [34, 56] => "contact 3"}
+
+        expect(index.lookup(:contact_key, from_table: :dim_contact, match: {key_1: 23, key_2: 45})).to eq("contact 2")
+      end
+    end
+
+
+    context "on subsequent calls" do
+      it "should look up the requested value from an internal cache" do
+        stub_cache_query :dim_contact, [:customer_id], :contact_key, {[1234] => "contact 1"}
+        index.lookup(:contact_key, from_table: :dim_contact, match_column: :customer_id, to_value: 1234)
+
+        stub_cache_query :dim_contact, [:customer_id], :contact_key, {[1234] => "contact 2"}
+        expect(index.lookup(:contact_key, from_table: :dim_contact, match_column: :customer_id, to_value: 1234)).to eq("contact 1")
+      end
+    end
+
+
+    it "should return :not_found if the key value was not found" do
+      stub_cache_query :dim_contact, [:customer_id], :contact_key, {[1234] => "contact 2"}
+
+      expect(index.lookup(:contact_key, from_table: :dim_contact, match_column: :customer_id, to_value: 2345)).to eq(:not_found)
+    end
+
+
+    it "should raise an error if both :if_not_found_then_insert and :if_not_found_then are specified" do
+      expect do
+        index.lookup(:contact_key, if_not_found_then: -1, if_not_found_then_insert: {})
+      end.to raise_error ArgumentError, "Cannot specify both :if_not_found_then and :if_not_found_then_insert options"
+    end
+
+
+    context "when :if_not_found_then is specified" do
+      it "should return the specified value if the lookup failed" do
+        stub_cache_query :dim_contact, [:customer_id], :contact_key, {[1234] => "contact"}
+
+        expect(index.lookup(:contact_key,
+                            from_table: :dim_contact,
+                            match_column: :customer_id,
+                            to_value: 2345,
+                            if_not_found_then: -1)).to eq(-1)
+      end
+
+      context "when the specified value is a lamba expression" do
+        it "should evaluate the expression and return its value if the lookup failed" do
+          stub_cache_query :dim_contact, [:customer_id], :contact_key, {[1234] => "contact"}
+
+          expect(index.lookup(:contact_key,
+                              from_table: :dim_contact,
+                              match_column: :customer_id,
+                              to_value: 2345,
+                              if_not_found_then: -> { -1 })).to eq(-1)
+        end
+      end
+    end
+
+
+    context "when :if_not_found_then_insert is specified" do
+
+      before(:each) do
+        stub_cache_query :dim_contact, [:customer_id], :contact_key, {[1234] => "contact"}
+      end
+
+      context "when a single key is used" do
+        it "should insert a new record into the specified table" do
+          expect(dimension_manager).to receive(:insert).with(:contact_key, {contact_key: 1, customer_id: 2345})
+
+          index.lookup :contact_key,
+                       from_table: :dim_contact,
+                       match_column: :customer_id,
+                       to_value: 2345,
+                       if_not_found_then_insert: {contact_key: 1, customer_id: 2345}
+        end
+      end
+
+      context "when multiple keys are used" do
+        it "should insert a new record into the specified table" do
+          stub_cache_query :dim_contact, [:key_1, :key_2], :contact_key, {[12, 34] => "contact"}
+
+          expect(dimension_manager).to receive(:insert).with(:contact_key, contact_key: 1, key_1: 23, key_2: 45)
+
+          index.lookup :contact_key,
+                       from_table: :dim_contact,
+                       match: {key_1: 23, key_2: 45},
+                       if_not_found_then_insert: {contact_key: 1, key_1: 23, key_2: 45}
+        end
+      end
+
+      it "should fill out the new record's lookup key automatically" do
+        expect(dimension_manager).to receive(:insert).with(:contact_key, name: "new contact", customer_id: 2345)
+
+        index.lookup :contact_key,
+                     from_table: :dim_contact,
+                     match_column: :customer_id,
+                     to_value: 2345,
+                     if_not_found_then_insert: {name: "new contact"}
+      end
+
+      it "should overwrite the new record's lookup key if specified" do
+        expect(dimension_manager).to receive(:insert).with(:contact_key, customer_id: 2345)
+
+        index.lookup :contact_key,
+                     from_table: :dim_contact,
+                     match_column: :customer_id,
+                     to_value: 2345,
+                     if_not_found_then_insert: {customer_id: 4567}
+      end
+
+      it "should return the new record's lookup value" do
+        allow(dimension_manager).to receive_messages insert: 98765
+
+        expect(index.lookup(:contact_key,
+                            from_table: :dim_contact,
+                            match_column: :customer_id,
+                            to_value: 2345,
+                            if_not_found_then_insert: {contact_key: 98765})).to eq(98765)
+      end
+    end
+  end
+
+
+  describe "#insert" do
+    before(:each) do
+      stub_cache_query :dim_contact, [:contact_key], :contact_key, {[1234] => "contact"}
+    end
+
+    it "should insert a new record into the specified table" do
+      expect(dimension_manager).to receive(:insert).with(:contact_key, {contact_key: 1, customer_id: 2345})
+
+      index.insert :contact_key,
+                   table: :dim_contact,
+                   record: {contact_key: 1, customer_id: 2345}
+    end
+
+    it "should return the new record's lookup value" do
+      allow(dimension_manager).to receive_messages insert: 98765
+
+      expect(index.insert :contact_key,
+                          table: :dim_contact,
+                          record: {contact_key: 98765}).to eq(98765)
+    end
+  end
+
+end

data/spec/cranium/transformation/join_spec.rb

@@ -0,0 +1,43 @@
+require_relative '../../spec_helper'
+
+describe Cranium::Transformation::Join do
+
+  let(:join) { Cranium::Transformation::Join.new }
+
+  describe "#execute" do
+    context "when validating its parameters" do
+      before(:each) do
+        join.source_left = "left source"
+        join.source_right = "right source"
+        join.target = "target source"
+        join.match_fields = { field1: :field2 }
+      end
+
+      it "should raise an error if :source_left isn't set" do
+        join.source_left = nil
+        expect { join.execute }.to raise_error "Missing left source for join transformation"
+      end
+
+      it "should raise an error if :source_right isn't set" do
+        join.source_right = nil
+        expect { join.execute }.to raise_error "Missing right source for join transformation"
+      end
+
+      it "should raise an error if :target isn't set" do
+        join.target = nil
+        expect { join.execute }.to raise_error "Missing target for join transformation"
+      end
+
+      it "should raise an error if :match_fields is set but isn't a Hash" do
+        join.match_fields = :field
+        expect { join.execute }.to raise_error "Invalid match fields for join transformation"
+      end
+
+      it "should raise an error if :type is not supported" do
+        join.type = :cross
+        expect { join.execute }.to raise_error "Invalid type for join transformation"
+      end
+    end
+  end
+
+end

data/spec/cranium/transformation/sequence_spec.rb

@@ -0,0 +1,83 @@
+require_relative '../../spec_helper'
+
+describe Cranium::Transformation::Sequence do
+
+  def stub_next_value(value)
+    dataset = double "dataset"
+    allow(dataset).to receive_messages first: { next_value: value }
+    allow(Cranium::Database).to receive_message_chain(:connection, :[]).with("SELECT nextval('id_seq') AS next_value").and_return(dataset)
+  end
+
+
+
+  let(:sequence) { Cranium::Transformation::Sequence.new :id_seq }
+
+  describe ".by_name" do
+    before(:each) { Cranium::Transformation::Sequence.instance_variable_set :@sequences, nil }
+
+    it "should return a sequence with the specified name" do
+      sequence = Cranium::Transformation::Sequence.by_name(:id_seq)
+
+      expect(sequence).to be_a Cranium::Transformation::Sequence
+      expect(sequence.name).to eq(:id_seq)
+    end
+
+    it "should schedule a newly created sequence's flush method as an after_import hook" do
+      expect(Cranium.application).to receive(:after_import).once
+
+      Cranium::Transformation::Sequence.by_name(:id_seq)
+      Cranium::Transformation::Sequence.by_name(:id_seq)
+    end
+
+    it "should memoize previously created instances" do
+      expect(Cranium::Transformation::Sequence.by_name(:id_seq)).to equal Cranium::Transformation::Sequence.by_name(:id_seq)
+    end
+  end
+
+
+  describe "#next_value" do
+    before(:each) do
+      stub_next_value 123
+    end
+
+    context "the first time it's called" do
+      it "should return the named sequence's next value read from the database" do
+        expect(sequence.next_value).to eq(123)
+      end
+    end
+
+    context "on subsequent calls" do
+      it "should increment its counter internally without querying the database" do
+        expect(sequence.next_value).to eq(123)
+
+        expect(Cranium::Database).not_to receive :connection
+
+        expect(sequence.next_value).to eq(124)
+        expect(sequence.next_value).to eq(125)
+      end
+    end
+  end
+
+
+  describe "#flush" do
+    let(:sequence) { Cranium::Transformation::Sequence.new :id_seq }
+
+    it "should not use the database if no value was ever requested from the sequence" do
+      expect(Cranium::Database).not_to receive :connection
+
+      sequence.flush
+    end
+
+    it "should set the database sequence's value to the last value returned" do
+      stub_next_value 123
+      sequence.next_value
+
+      connection = double "connection"
+      allow(Cranium::Database).to receive_messages connection: connection
+      expect(connection).to receive(:run).with("SELECT setval('id_seq', 123)")
+
+      sequence.flush
+    end
+  end
+
+end

data/spec/cranium/transformation_record_spec.rb

@@ -0,0 +1,78 @@
+require_relative '../spec_helper'
+
+describe Cranium::TransformationRecord do
+
+  let(:record) { Cranium::TransformationRecord.new [:field1, :field2, :field3], [:field1, :field2, :field3] }
+
+  describe "#input_data=" do
+    it "should set the input data row" do
+      record.input_data = ["one", "three", "five"]
+      expect(record.data).to eq({ :field1 => "one", :field2 => "three", :field3 => "five" })
+    end
+  end
+
+
+  describe "#[]" do
+    it "should access the fields of the record as if it were a Hash" do
+      record.input_data = ["one", "two", "three"]
+      expect(record[:field2]).to eq("two")
+    end
+  end
+
+
+  describe "#[]=" do
+    it "should set the fields of the record as if it were a Hash" do
+      record.input_data = ["one", "two", "three"]
+      record[:field2] = "four"
+      expect(record[:field2]).to eq("four")
+    end
+  end
+
+
+  describe "#split_field" do
+
+    let(:record) { Cranium::TransformationRecord.new [:source_field], [:target_field1, :target_field2] }
+
+    it "should store values into respective fields and drop extra values" do
+      record.input_data = ["first|second|third"]
+      record.split_field :source_field, into: [:target_field1, :target_field2], by: "|"
+      expect(record[:target_field1]).to eq("first")
+      expect(record[:target_field2]).to eq("second")
+    end
+
+    context "when default value is not set" do
+      it "should repeat last value when there are not enough values" do
+        record.input_data = ["first"]
+        record.split_field :source_field, into: [:target_field1, :target_field2], by: "|"
+        expect(record[:target_field1]).to eq("first")
+        expect(record[:target_field2]).to eq("first")
+      end
+    end
+
+    context "when default value is specified" do
+      it "should use default value when there are not enough values" do
+        record.input_data = ["first"]
+        record.split_field :source_field, into: [:target_field1, :target_field2], by: "|", default_value: "--"
+        expect(record[:target_field1]).to eq("first")
+        expect(record[:target_field2]).to eq("--")
+      end
+    end
+
+  end
+
+
+  describe "#has_key?" do
+    it "should return true if the record contains data for the specified key" do
+      record.input_data = ["one", "two", "three"]
+
+      expect(record.has_key?(:field1)).to be_truthy
+    end
+
+    it "should return false if the record doesn't contain data for the specified key" do
+      record.input_data = ["one", "two", "three"]
+
+      expect(record.has_key?(:field4)).to be_falsey
+    end
+  end
+
+end

data/spec/cranium_spec.rb

@@ -0,0 +1,53 @@
+require_relative 'spec_helper'
+
+describe Cranium do
+
+  describe ".application" do
+    it "should return an Application object" do
+      expect(Cranium.application).to be_a Cranium::Application
+    end
+
+    it "should return a singleton" do
+      expect(Cranium.application).to equal Cranium.application
+    end
+  end
+
+
+  describe ".configure" do
+    it "should set or modify the existing configuration" do
+      Cranium.configure do |config|
+        config.greenplum_connection_string = "greenplum connection"
+        config.mysql_connection_string = "mysql connection"
+      end
+
+      Cranium.configure do |config|
+        config.greenplum_connection_string = "new greenplum connection"
+      end
+
+      expect(Cranium.configuration.greenplum_connection_string).to eq("new greenplum connection")
+      expect(Cranium.configuration.mysql_connection_string).to eq("mysql connection")
+    end
+  end
+
+
+  describe ".configuration" do
+    it "should return the configuration" do
+      expect(Cranium.configuration).to be_a Cranium::Configuration
+    end
+
+    it "should not let the user modify the configuration" do
+      expect { Cranium.configuration.greenplum_connection_string = "constring" }.to raise_error(RuntimeError)
+    end
+  end
+
+
+  describe ".load_arguments" do
+    it "should return the load arguments of the application" do
+      app = double "application", load_arguments: "load_arguments"
+      allow(Cranium).to receive(:application).and_return(app)
+
+      expect(Cranium.load_arguments).to eq "load_arguments"
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/cranium'