coupler 0.0.1-java

data/test/unit/models/test_resource.rb

@@ -0,0 +1,564 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestResource < Coupler::Test::UnitTest
+      def setup
+        super
+        @local_database = stub('project database')
+        @project = stub_project
+        @project.stubs(:local_database).yields(@local_database)
+
+        @source_database = stub('source database', {
+          :tables => [:foo],
+          :schema => [
+            [:id,  {:primary_key => true,  :type => :integer, :db_type => "BIGINT"}],
+            [:foo, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}],
+            [:bar, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}]
+          ]
+        })
+        @connection = stub('connection', :pk => 456, :id => 456, :associations => {})
+        @connection.stubs(:database).yields(@source_database)
+      end
+
+      def new_resource(attribs = {})
+        values = {
+          :name => 'Foo bar',
+          :table_name => 'foo',
+          :project => @project,
+          :connection => @connection
+        }.update(attribs)
+        r = Resource.new(values)
+        r.stubs(:project_dataset).returns(stub({:all => [values[:project]]}))
+        r.stubs(:connection_dataset).returns(stub({:all => [values[:connection]]}))
+        r
+      end
+
+      def stub_project(id = 123, methods = {})
+        stub('project', {:pk => id, :id => id, :associations => {}}.update(methods))
+      end
+
+      test "sequel model" do
+        assert_equal Sequel::Model, Resource.superclass
+        assert_equal :resources, Resource.table_name
+      end
+
+      test "many to one connection" do
+        assert_respond_to Resource.new, :connection
+      end
+
+      test "many to one project" do
+        assert_respond_to Resource.new, :project
+      end
+
+      test "one to many transformations" do
+        assert_respond_to Resource.new, :transformations
+      end
+
+      test "one to many jobs" do
+        assert_respond_to Resource.new, :jobs
+      end
+
+      test "one to many fields" do
+        assert_respond_to Resource.new, :fields
+      end
+
+      test "one to many selected fields" do
+        assert_respond_to Resource.new, :selected_fields
+      end
+
+      test "many to one import" do
+        assert_respond_to Resource.new, :import
+      end
+
+      test "one to many running_jobs" do
+        assert_respond_to Resource.new, :running_jobs
+      end
+
+      test "one to many scheduled_jobs" do
+        assert_respond_to Resource.new, :scheduled_jobs
+      end
+
+      test "nested attributes for connection" do
+        assert_respond_to Resource.new, :connection_attributes=
+      end
+
+      #test "invalid nested attributes for connection" do
+        #connection_count = Connection.count
+        #resource_count = Resource.count
+
+        #resource = Factory.build(:resource, :connection => nil)
+        #resource.connection_attributes = Factory.attributes_for(:connection, :name => nil, :host => nil)
+        #resource.save
+
+        #assert_equal resource_count, Resource.count
+        #assert_equal connection_count, Connection.count
+      #end
+
+      test "nested attributes for fields" do
+        assert_respond_to Resource.new, :fields_attributes=
+      end
+
+      test "rejects new fields for nested attributes" do
+        resource = new_resource
+        resource.save!
+        resource.fields_attributes = [{:is_selected => 0}]
+        resource.expects(:add_field).times(0)
+        resource.save!
+      end
+
+      test "requires project" do
+        resource = new_resource
+        args = []
+        resource.expects(:validates_presence).at_least(1).with { |*a| args << a; true }
+        resource.save
+        args.flatten!
+        assert args.include?(:project_id)
+      end
+
+      test "requires name" do
+        resource = new_resource
+        args = []
+        resource.expects(:validates_presence).at_least(1).with { |*a| args << a; true }
+        resource.save
+        args.flatten!
+        assert args.include?(:name)
+      end
+
+      test "requires unique name across projects" do
+        resource = new_resource
+        resource.expects(:validates_unique).with do |*args|
+          args.include?([:name, :project_id])
+        end
+        resource.save
+      end
+
+      test "requires non empty table_name" do
+        resource = new_resource
+        args = []
+        resource.expects(:validates_presence).at_least(1).with { |*a| args << a; true }
+        resource.save
+        args.flatten!
+        assert args.include?(:table_name)
+      end
+
+      test "requires valid table_name" do
+        @source_database.stubs(:tables).returns([])
+        resource = new_resource
+        assert !resource.valid?, "Resource wasn't invalid"
+      end
+
+      test "sets slug from name" do
+        resource = new_resource(:name => 'Foo bar')
+        assert_equal "foo_bar", resource.slug
+      end
+
+      test "requires unique slug across projects" do
+        resource = new_resource
+        resource.expects(:validates_unique).with do |*args|
+          args.include?([:slug, :project_id])
+        end
+        resource.save
+      end
+
+      test "requires table with primary key" do
+        @source_database.stubs(:schema).returns([
+          [:id,  {:primary_key => false,  :type => :integer, :db_type => "BIGINT"}],
+          [:foo, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}],
+          [:bar, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}]
+        ])
+        resource = new_resource
+        assert !resource.valid?
+      end
+
+      test "requires single primary key" do
+        @source_database.stubs(:schema).returns([
+          [:id,  {:primary_key => true, :type => :integer, :db_type => "BIGINT"}],
+          [:foo, {:primary_key => true, :type => :string, :db_type => "VARCHAR"}],
+          [:bar, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}]
+        ])
+        resource = new_resource
+        assert !resource.valid?
+      end
+
+      test "does not requires integer primary key" do
+        @source_database.stubs(:schema).returns([
+          [:id,  {:primary_key => false, :type => :integer, :db_type => "BIGINT"}],
+          [:foo, {:primary_key => true, :type => :string, :db_type => "VARCHAR"}],
+          [:bar, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}]
+        ])
+        resource = new_resource
+        assert resource.valid?
+      end
+
+      test "sets primary_key_name" do
+        @source_database.stubs(:schema).returns([
+          [:my_id,  {:primary_key => true, :type => :integer, :db_type => "BIGINT"}],
+          [:foo, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}],
+          [:bar, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}]
+        ])
+        resource = new_resource.save!
+        assert_equal 'my_id', resource.primary_key_name
+      end
+
+      test "sets primary_key_type" do
+        @source_database.stubs(:schema).returns([
+          [:my_id,  {:primary_key => true, :type => :integer, :db_type => "BIGINT"}],
+          [:foo, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}],
+          [:bar, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}]
+        ])
+        resource = new_resource.save!
+        assert_equal 'integer', resource.primary_key_type
+      end
+
+      test "creates fields" do
+        @source_database.stubs(:schema).returns([
+          [:id, {:allow_null=>false, :default=>nil, :primary_key=>true, :db_type=>"int(11)", :type=>:integer, :ruby_default=>nil}],
+          [:first_name, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :ruby_default=>nil}],
+          [:last_name, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :ruby_default=>nil}]
+        ])
+
+        resource = new_resource
+        resource.expects(:add_field).with do |h|
+          h[:name] == :id && h[:type] == :integer &&
+            h[:db_type] == 'int(11)' && h[:is_primary_key]
+        end
+        resource.expects(:add_field).with do |h|
+          h[:name] == :first_name && h[:type] == :string &&
+            h[:db_type] == 'varchar(255)' && !h[:is_primary_key]
+        end
+        resource.expects(:add_field).with do |h|
+          h[:name] == :last_name && h[:type] == :string &&
+            h[:db_type] == 'varchar(255)' && !h[:is_primary_key]
+        end
+        resource.save!
+      end
+
+      test "source_database with block" do
+        resource = new_resource.save!
+        @connection.expects(:database).yields(@source_database)
+        resource.source_database do |db|
+          assert_equal @source_database, db
+        end
+      end
+
+      test "source_database without block" do
+        resource = new_resource.save!
+        @connection.expects(:database).returns(@source_database)
+        assert_equal @source_database, resource.source_database
+      end
+
+      test "source_dataset" do
+        resource = new_resource.save!
+
+        # ghetto mock!
+        fd = [stub(:name => 'id'), stub(:name => 'foo'), stub(:name => 'bar')]
+        fd.expects(:filter).with(:is_selected => true, :is_generated => false).returns(fd)
+        resource.stubs(:fields_dataset).returns(fd)
+
+        dataset = mock('dataset')
+        dataset.expects(:select).with(:id, :foo, :bar).returns(dataset)
+        @source_database.expects(:[]).with(:foo).returns(dataset)
+
+        # with block
+        resource.source_dataset do |rdataset|
+          assert_equal dataset, rdataset
+        end
+      end
+
+      test "source_dataset without block" do
+        resource = new_resource.save!
+
+        # ghetto mock!
+        fd = [stub(:name => 'id'), stub(:name => 'foo'), stub(:name => 'bar')]
+        fd.expects(:filter).with(:is_selected => true, :is_generated => false).returns(fd)
+        resource.stubs(:fields_dataset).returns(fd)
+
+        dataset = mock('dataset')
+        dataset.expects(:select).with(:id, :foo, :bar).returns(dataset)
+        @connection.expects(:database).returns(@source_database)
+        @source_database.expects(:[]).with(:foo).returns(dataset)
+
+        assert_equal dataset, resource.source_dataset
+      end
+
+      test "source_schema" do
+        resource = new_resource.save!
+        schema = stub('schema')
+        @source_database.expects(:schema).with(:foo).returns(schema)
+        assert_equal schema, resource.source_schema
+      end
+
+      test "local_dataset" do
+        resource = new_resource.save!
+        dataset = mock('dataset')
+        @local_database.expects(:[]).with(:"resource_#{resource.id}").returns(dataset)
+        resource.local_dataset do |ds|
+          assert_equal dataset, ds
+        end
+      end
+
+      test "local dataset without block" do
+        resource = new_resource.save!
+
+        @project.expects(:local_database).returns(@local_database)
+        dataset = stub('dataset')
+        @local_database.expects(:[]).with(:"resource_#{resource.id}").returns(dataset)
+        assert_equal dataset, resource.local_dataset
+      end
+
+      test "refresh fields" do
+        resource = new_resource.save!
+        field_1 = stub("id field", :id => 1)
+        field_2 = stub("first_name field", :id => 2)
+        field_3 = stub("last_name field", :id => 3)
+
+        transformation_1 = stub("transformation 1", {
+          :source_field_id => 2, :result_field_id => 2,
+          :field_changes => {2 => {:type => :integer, :db_type => 'int(11)'}},
+          :source_field => field_2
+        })
+        transformation_2 = stub("transformation 2", {
+          :source_field_id => 3, :result_field_id => 3,
+          :field_changes => {3 => {:type => :integer, :db_type => 'int(11)'}},
+          :source_field => field_3
+        })
+        transformation_3 = stub("transformation 3", {
+          :source_field_id => 3, :result_field_id => 3,
+          :field_changes => {3 => {:type => :datetime, :db_type => 'datetime'}},
+          :source_field => field_3
+        })
+
+        resource.stubs(:fields_dataset).returns(stub(:update => nil))
+        td = [transformation_1, transformation_2, transformation_3]
+        td.expects(:order).with(:position).returns(td)
+        resource.expects(:transformations_dataset).returns(td)
+
+        seq = sequence("update")
+        field_2.expects(:update).with({
+          :local_type => :integer, :local_db_type => 'int(11)'
+        }).in_sequence(seq)
+        field_3.expects(:update).with({
+          :local_type => :integer, :local_db_type => 'int(11)'
+        }).in_sequence(seq)
+        field_3.expects(:update).with({
+          :local_type => :datetime, :local_db_type => 'datetime'
+        }).in_sequence(seq)
+
+        resource.refresh_fields!
+      end
+
+      test "refresh_fields does not change newly created result field" do
+        resource = new_resource.save!
+        field_1 = stub("id field", :id => 1)
+        field_2 = stub("first_name field", :id => 2)
+        field_3 = stub("last_name field", :id => 3)
+        new_field = stub("new field", :id => 4)
+
+        transformation = stub("transformation 1", {
+          :source_field_id => 2, :result_field_id => 4,
+          :field_changes => {2 => {:type => :integer, :db_type => 'int(11)'}},
+          :source_field => field_2
+        })
+
+        resource.stubs(:fields_dataset).returns(stub(:update => nil))
+        td = [transformation]
+        td.expects(:order).with(:position).returns(td)
+        resource.expects(:transformations_dataset).returns(td)
+
+        field_2.expects(:update).never
+        new_field.expects(:update).never
+
+        resource.refresh_fields!
+      end
+
+      test "refresh_fields resets local_type and local_db_type" do
+        resource = new_resource.save!
+
+        resource.expects(:fields_dataset).returns(mock {
+          expects(:update).with(:local_type => nil, :local_db_type => nil)
+        })
+        td = []
+        td.expects(:order).with(:position).returns(td)
+        resource.expects(:transformations_dataset).returns(td)
+
+        resource.refresh_fields!
+      end
+
+      test "initial status" do
+        resource = new_resource.save!
+        assert_equal "ok", resource.status
+      end
+
+      test "status after adding first transformation" do
+        resource = new_resource.save!
+        resource.stubs(:transformation_ids).returns([1])
+        assert_equal "out_of_date", resource.status
+      end
+
+      test "status when new transformation is created since transforming" do
+        resource = new_resource(:transformed_with => "1").save!
+        resource.stubs(:transformation_ids).returns([1,2])
+        assert_equal "out_of_date", resource.status
+      end
+
+      test "status when transformation is updated since transforming" do
+        now = Time.now
+        resource = new_resource(:transformed_with => "1", :transformed_at => now - 20).save!
+        resource.stubs(:transformation_ids).returns([1])
+        resource.stubs(:transformations_dataset).returns(stub {
+          stubs(:filter).with('updated_at > ?', now - 20).returns(self)
+          stubs(:count).returns(1)
+        })
+        assert_equal "out_of_date", resource.status
+      end
+
+      test "status when transformation is removed since transforming" do
+        now = Time.now
+        resource = new_resource(:transformed_at => now - 5, :transformed_with => "1").save!
+        resource.stubs(:transformation_ids).returns([])
+        assert_equal "out_of_date", resource.status
+      end
+
+      test "status when new transformation is removed before transforming" do
+        resource = new_resource.save!
+        resource.stubs(:transformation_ids).returns([1])
+        assert_equal "out_of_date", resource.status
+        resource.stubs(:transformation_ids).returns([])
+        assert_equal "ok", resource.status
+      end
+
+      test "final_database is source_database without transformations" do
+        resource = new_resource.save!
+        resource.stubs(:transformations_dataset).returns(stub(:count => 0))
+        db = stub('db')
+        resource.expects(:source_database).returns(db)
+        assert_equal db, resource.final_database
+      end
+
+      test "final_database is local_database with transformations" do
+        resource = new_resource.save!
+        resource.stubs(:transformations_dataset).returns(stub(:count => 1))
+        db = stub('db')
+        @project.expects(:local_database).returns(db)
+        assert_equal db, resource.final_database
+      end
+
+      test "final_dataset is source_dataset without transformations" do
+        resource = new_resource.save!
+        resource.stubs(:transformations_dataset).returns(stub(:count => 0))
+        ds = stub('dataset')
+        resource.expects(:source_dataset).returns(ds)
+        assert_equal ds, resource.final_dataset
+      end
+
+      test "final_dataset is local_dataset with transformations" do
+        resource = new_resource.save!
+        resource.stubs(:transformations_dataset).returns(stub(:count => 1))
+        ds = stub('dataset')
+        resource.expects(:local_dataset).returns(ds)
+        assert_equal ds, resource.final_dataset
+      end
+
+      test "scenarios" do
+        resource = new_resource.save!
+        scenario = stub('scenario')
+        Scenario.expects(:filter).with(['resource_1_id = ? OR resource_2_id = ?', resource.id, resource.id]).returns(stub(:all => [scenario]))
+        assert_equal [scenario], resource.scenarios
+      end
+
+      test "deletes dependencies after destroy" do
+        resource = new_resource.save!
+
+        resource.expects(:fields_dataset).returns([
+          mock('field 1', :destroy => nil) { expects(:delete_versions_on_destroy=).with { |arg| !arg } },
+          mock('field 2', :destroy => nil) { expects(:delete_versions_on_destroy=).with { |arg| !arg } },
+          mock('field 3', :destroy => nil) { expects(:delete_versions_on_destroy=).with { |arg| !arg } }
+        ])
+        resource.expects(:transformations_dataset).returns([
+          mock('transformation 1', :destroy => nil) { expects(:delete_versions_on_destroy=).with { |arg| !arg } },
+          mock('transformation 2', :destroy => nil) { expects(:delete_versions_on_destroy=).with { |arg| !arg } },
+          mock('transformation 3', :destroy => nil) { expects(:delete_versions_on_destroy=).with { |arg| !arg } }
+        ])
+        resource.destroy
+      end
+
+      test "deletes local dataset after destroy" do
+        resource = new_resource(:transformed_at => Time.now).save!
+        resource.expects(:transformations_dataset).returns([stub_everything('transformation')])
+        @local_database.expects(:drop_table).with(:"resource_#{resource.id}")
+        resource.destroy
+      end
+
+      test "forceably deletes versions after destroy" do
+        resource = new_resource.save!
+        resource.delete_versions_on_destroy = true
+        resource.expects(:fields_dataset).returns([
+          mock('field 1', :destroy => nil) { expects(:delete_versions_on_destroy=).with(true) },
+          mock('field 2', :destroy => nil) { expects(:delete_versions_on_destroy=).with(true) },
+          mock('field 3', :destroy => nil) { expects(:delete_versions_on_destroy=).with(true) }
+        ])
+        resource.expects(:transformations_dataset).returns([
+          mock('transformation 1', :destroy => nil) { expects(:delete_versions_on_destroy=).with(true) },
+          mock('transformation 2', :destroy => nil) { expects(:delete_versions_on_destroy=).with(true) },
+          mock('transformation 3', :destroy => nil) { expects(:delete_versions_on_destroy=).with(true) }
+        ])
+
+        resource.destroy
+      end
+
+      test "creating resource via import" do
+        import = stub("import", {
+          :id => 123, :pk => 123, :project => @project,
+          :name => "People"
+        })
+        resource = Resource.new(:import => import)
+        assert_equal "People", resource.name
+        assert_equal @project, resource.project
+        assert_equal "import_123", resource.table_name
+        assert resource.valid?
+
+        # import.import! would happen here
+        @local_database.stubs({
+          :tables => [:import_123],
+          :schema => [
+            [:id,  {:primary_key => true,  :type => :integer, :db_type => "BIGINT"}],
+            [:foo, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}],
+            [:bar, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}]
+          ]
+        })
+        resource.save!
+        assert_equal "id", resource.primary_key_name
+        assert_equal "integer", resource.primary_key_type
+      end
+
+      test "source_dataset count" do
+        resource = new_resource.save!
+        dataset = mock('dataset', :count => 12345)
+        resource.expects(:source_dataset).yields(dataset)
+        assert_equal resource.source_dataset_count, 12345
+      end
+
+      #def test_unselecting_a_generated_field_before_transformation
+        #pend
+      #end
+
+      #def test_connection_limit_on_source_database
+        #pend
+      #end
+
+      #def test_connection_limit_on_local_database
+        #pend
+      #end
+
+      test "count by project" do
+        Resource.expects(:dataset).returns(mock {
+          expects(:naked).returns(self)
+          expects(:group_and_count).returns(self)
+          expects(:to_hash).with(:project_id, :count).returns({1 => 123})
+        })
+        assert_equal({1 => 123}, Resource.count_by_project)
+      end
+    end
+  end
+end

data/test/unit/models/test_result.rb

@@ -0,0 +1,90 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestResult < Coupler::Test::UnitTest
+      def new_result(attribs = {})
+        values = {
+          :scenario => @scenario
+        }.update(attribs)
+        r = Result.new(values)
+        r.stubs(:scenario_dataset).returns(stub({:all => [values[:scenario]]}))
+        r
+      end
+
+      def setup
+        super
+        @scenario = stub('scenario', :id => 100, :pk => 100, :associations => {}, :version => 42)
+      end
+
+      test "sequel model" do
+        assert_equal ::Sequel::Model, Result.superclass
+        assert_equal :results, Result.table_name
+      end
+
+      test "many to one scenario" do
+        assert_respond_to Result.new, :scenario
+      end
+
+      test "sets scenario version" do
+        result = new_result.save!
+        assert_equal 42, result.scenario_version
+      end
+
+      test "snapshot gets originating models" do
+        time = Time.now - 50
+        @scenario.stubs({
+          :updated_at => time, :project_id => 123,
+          :resource_1_id => 456, :resource_2_id => 789
+        })
+        result = new_result.save!
+
+        project = stub('project')
+        resource_1 = stub('resource 1')
+        resource_2 = stub('resource 2')
+        Scenario.expects(:as_of_version).with(100, 42).returns(@scenario)
+        Project.expects(:as_of_time).with(123, time).returns(project)
+        Resource.expects(:as_of_time).with(456, time).returns(resource_1)
+        Resource.expects(:as_of_time).with(789, time).returns(resource_2)
+
+        expected = {
+          :project => project, :scenario => @scenario,
+          :resource_1 => resource_1, :resource_2 => resource_2
+        }
+        assert_equal expected, result.snapshot
+      end
+
+      test "groups dataset" do
+        result = new_result(:run_number => 5).save!
+        ds = mock('dataset')
+        @scenario.expects(:local_database).yields(mock('database') {
+          expects(:[]).with(:groups_5).returns(ds)
+        })
+        result.groups_dataset do |actual|
+          assert_equal ds, actual
+        end
+      end
+
+      test "groups records dataset" do
+        result = new_result(:run_number => 5).save!
+        ds = mock('dataset')
+        @scenario.expects(:local_database).yields(mock('database') {
+          expects(:[]).with(:groups_records_5).returns(ds)
+        })
+        result.groups_records_dataset do |actual|
+          assert_equal ds, actual
+        end
+      end
+
+      test "groups table name" do
+        result = new_result(:run_number => 5).save!
+        assert_equal :groups_5, result.groups_table_name
+      end
+
+      test "groups records table name" do
+        result = new_result(:run_number => 5).save!
+        assert_equal :groups_records_5, result.groups_records_table_name
+      end
+    end
+  end
+end