coupler 0.0.1-java

data/test/unit/models/test_connection.rb

@@ -0,0 +1,115 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestConnection < Coupler::Test::UnitTest
+      test "sequel model" do
+        assert_equal ::Sequel::Model, Connection.superclass
+        assert_equal :connections, Connection.table_name
+      end
+
+      test "one to many resources" do
+        assert_respond_to Connection.new, :resources
+      end
+
+      each_adapter do |adapter, _|
+        adapter_test(adapter, "requires name") do
+          connection = new_connection(adapter, :name => nil)
+          assert !connection.valid?
+
+          connection.name = ""
+          assert !connection.valid?
+        end
+
+        adapter_test(adapter, "requires unique name") do
+          connection_1 = new_connection(adapter, :name => 'foo')
+          connection_1.save!
+          connection_2 = new_connection(adapter, :name => 'foo')
+          assert !connection_2.valid?
+        end
+
+        adapter_test(adapter, "requires unique name on update") do
+          connection_1 = new_connection(adapter, :name => 'foo')
+          connection_1.save!
+          connection_2 = new_connection(adapter, :name => 'bar')
+          connection_2.save!
+          connection_1.name = "bar"
+          assert !connection_1.valid?, "Connection wasn't invalid"
+        end
+
+        adapter_test(adapter, "sets slug from name") do
+          connection = new_connection(adapter, :name => 'Foo bar')
+          connection.save!
+          assert_equal "foo_bar", connection.slug
+        end
+
+        adapter_test(adapter, "requires unique slug") do
+          connection_1 = new_connection(adapter, :name => 'bar', :slug => 'bar')
+          connection_1.save!
+          connection_2 = new_connection(adapter, :name => 'foo', :slug => 'bar')
+          assert !connection_2.valid?
+
+          connection_2.slug = "baz"
+          assert connection_2.valid?
+          connection_2.save!
+
+          connection_2.slug = "bar"
+          assert !connection_2.valid?
+        end
+
+        adapter_test(adapter, 'database method') do
+          connection = new_connection(adapter, :name => 'test')
+          connection.save!
+          connection.database do |database|
+            assert_kind_of Sequel::JDBC::Database, database
+            assert database.test_connection
+          end
+        end
+      end
+
+      adapter_test('h2', 'requires valid connection') do
+        connection = new_connection('h2', :path => '/path/i/cant/create/foo/bar')
+        assert !connection.valid?, "Connection wasn't invalid"
+      end
+
+      adapter_test('mysql', 'requires valid connection') do
+        connection = new_connection('mysql', :password => 'incorrect_password')
+        assert !connection.valid?, "Connection wasn't invalid"
+      end
+
+      test "deletable if unused" do
+        connection = new_connection('h2', :name => 'foo')
+        connection.save!
+        connection.expects(:resources_dataset).returns(stub(:count => 0))
+        assert connection.deletable?
+      end
+
+      test "not deletable if associated with resources" do
+        connection = new_connection('h2', :name => 'foo')
+        connection.save!
+        connection.expects(:resources_dataset).returns(stub(:count => 1))
+        assert !connection.deletable?
+      end
+
+      test "deleting unused connection" do
+        connection = new_connection('h2', :name => 'foo')
+        connection.save!
+        connection.expects(:resources_dataset).returns(stub(:count => 0))
+        assert connection.destroy
+        assert_nil Connection[connection.id]
+      end
+
+      test "prevent deleting connection in use" do
+        connection = new_connection('h2', :name => 'foo')
+        connection.save!
+        connection.expects(:resources_dataset).returns(stub(:count => 1))
+        assert !connection.destroy
+        assert_not_nil Connection[connection.id]
+      end
+
+      #def test_connection_limit
+        #pend
+      #end
+    end
+  end
+end

data/test/unit/models/test_field.rb

@@ -0,0 +1,99 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestField < Coupler::Test::UnitTest
+      def new_field(attrs = {})
+        f = Field.new({
+          :name => 'foo',
+          :type => 'string',
+          :db_type => 'varchar(255)',
+          :is_primary_key => false,
+          :is_selected => true,
+          :resource => @resource
+        }.merge(attrs))
+      end
+
+      def setup
+        super
+        @resource = stub("resource", :id => 123, :pk => 123, :associations => {})
+      end
+
+      test "sequel model" do
+        assert_equal ::Sequel::Model, Field.superclass
+        assert_equal :fields, Field.table_name
+      end
+
+      test "many to one resource" do
+        assert_respond_to Field.new, :resource
+      end
+
+      test "one to many transformations" do
+        assert_respond_to Field.new, :transformations
+      end
+
+      test "requires unique name across resources" do
+        field = new_field
+        field.expects(:validates_unique).with([:name, :resource_id])
+        field.valid?
+      end
+
+      test "force selected on primary key fields" do
+        field_1 = new_field(:name => 'field_1', :is_primary_key => false, :is_selected => false).save!
+        assert !field_1.is_selected
+
+        field_2 = new_field(:name => 'field_2', :is_primary_key => true, :is_selected => false).save!
+        assert field_2.is_selected
+      end
+
+      test "original_column_options" do
+        field = new_field({
+          :local_type => 'integer',
+          :local_db_type => 'int(11)',
+        })
+        assert_equal({
+          :name => 'foo', :type => 'varchar(255)',
+          :primary_key => false
+        }, field.original_column_options)
+      end
+
+      test "local_column_options" do
+        field_1 = new_field({
+          :type => 'integer', :db_type => 'int(11)',
+          :local_type => 'string', :local_db_type => 'varchar(255)',
+          :is_primary_key => false
+        })
+        field_2 = new_field({
+          :type => 'integer', :db_type => 'int(11)',
+          :is_primary_key => false
+        })
+
+        assert_equal({
+          :name => 'foo', :type => 'varchar(255)',
+          :primary_key => false
+        }, field_1.local_column_options)
+        assert_equal({
+          :name => 'foo', :type => 'int(11)',
+          :primary_key => false
+        }, field_2.local_column_options)
+      end
+
+      test "final_type and final_db_type uses local if exists" do
+        field_1 = new_field({
+          :name => 'foo', :type => 'integer', :db_type => 'int(11)',
+          :local_type => 'string', :local_db_type => 'varchar(255)',
+          :is_primary_key => false
+        })
+        field_2 = new_field({
+          :name => 'foo', :type => 'integer', :db_type => 'int(11)',
+          :local_type => nil, :local_db_type => nil,
+          :is_primary_key => false
+        })
+        assert_equal 'string', field_1.final_type
+        assert_equal 'varchar(255)', field_1.final_db_type
+        assert_equal 'integer', field_2.final_type
+        assert_equal 'int(11)', field_2.final_db_type
+      end
+    end
+  end
+end

data/test/unit/models/test_import.rb

@@ -0,0 +1,130 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestImport < Coupler::Test::UnitTest
+      def new_import(attribs = {})
+        values = {
+          :data => fixture_file_upload('people.csv'),
+          :project => @project
+        }.update(attribs)
+        r = Import.new(values)
+        r.stubs(:project_dataset).returns(stub({:all => [values[:project]]}))
+        r
+      end
+
+      def setup
+        super
+        @project = stub('project', :pk => 456, :id => 456, :associations => {})
+        @project.stubs(:resources_dataset).returns(stub {
+          stubs(:filter).returns(self)
+          stubs(:count).returns(0)
+        })
+      end
+
+      test "sequel model" do
+        assert_equal ::Sequel::Model, Models::Import.superclass
+        assert_equal :imports, Import.table_name
+      end
+
+      test "many to one project" do
+        assert_respond_to Models::Import.new, :project
+      end
+
+      test "gets name from original filename" do
+        import = new_import
+        assert_equal "People", import.name
+      end
+
+      test "preview with headers" do
+        import = new_import
+        preview = import.preview
+        assert_kind_of Array, preview
+        assert_equal 50, preview.length
+        assert_kind_of Array, preview[0]
+        assert_not_equal %w{id first_name last_name age}, preview[0]
+      end
+
+      test "discovers field names and types" do
+        import = new_import
+        expected_types = %w{integer string string integer}
+        expected_names = %w{id first_name last_name age}
+        assert_equal expected_names, import.field_names
+        assert_equal expected_types, import.field_types
+        assert_equal "id", import.primary_key_name
+        assert import.has_headers
+      end
+
+      test "discover for csv with no headers" do
+        tempfile = Tempfile.new('coupler-import')
+        tempfile.write("foo,bar,1,2,3\njunk,blah,4,5,6")
+        tempfile.close
+        import = new_import(:data => file_upload(tempfile.path))
+        expected_types = %w{string string integer integer integer}
+        assert_equal expected_types, import.field_types
+        assert_nil import.field_names
+        assert_nil import.primary_key_name
+        assert !import.has_headers
+      end
+
+      test "requires field names" do
+        import = new_import(:data => fixture_file_upload('no-headers.csv'))
+        assert_nil import.field_names
+        assert !import.valid?
+      end
+
+      test "requires primary key name" do
+        import = new_import(:data => fixture_file_upload('no-headers.csv'))
+        import.field_names = %w{id first_name last_name age}
+        assert !import.valid?
+      end
+
+      test "requires valid primary key name" do
+        import = new_import(:data => fixture_file_upload('no-headers.csv'))
+        import.field_names = %w{id first_name last_name age}
+        import.primary_key_name = "foo"
+        assert !import.valid?
+      end
+
+      test "requires unique field names" do
+        tempfile = Tempfile.new('coupler-import')
+        tempfile.write("id,foo,foo\n1,abc,def\n2,ghi,jkl\n3,mno,pqr")
+        tempfile.close
+
+        import = new_import(:data => file_upload(tempfile.path))
+        assert !import.valid?
+      end
+
+      test "requires unused resource name" do
+        import = new_import
+        @project.resources_dataset.stubs(:count).returns(1)
+        assert !import.valid?
+      end
+
+      test "dataset" do
+        import = new_import.save!
+        expected = mock('dataset')
+        @project.expects(:local_database).yields(mock {
+          expects(:[]).with(:"import_#{import.id}").returns(expected)
+        })
+        import.dataset do |actual|
+          assert_equal expected, actual
+        end
+      end
+
+      test "discover fields for csv with headers and varying number of fields" do
+        tempfile = Tempfile.new('coupler-import')
+        tempfile.write("id,foo,bar\n1,2,3\n1,4,5\n1,6,7,\n123,456,789,,\n")
+        tempfile.close
+
+        import = new_import(:data => file_upload(tempfile.path))
+        expected_types = %w{integer integer integer string string}
+        expected_names = %w{id foo bar}
+        assert_equal expected_names, import.field_names
+        assert_equal expected_types, import.field_types
+        assert_equal "id", import.primary_key_name
+        assert import.has_headers
+      end
+    end
+  end
+end

data/test/unit/models/test_job.rb

@@ -0,0 +1,115 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestJob < Coupler::Test::UnitTest
+      def new_job(attribs = {})
+        j = Job.new(attribs)
+        if attribs[:resource]
+          j.stubs(:resource_dataset).returns(stub({:all => [attribs[:resource]]}))
+        end
+        if attribs[:scenario]
+          j.stubs(:scenario_dataset).returns(stub({:all => [attribs[:scenario]]}))
+        end
+        j
+      end
+
+      def setup
+        super
+        @resource = stub('resource', :pk => 456, :id => 456, :associations => {})
+        @scenario = stub('scenario', :pk => 456, :id => 456, :associations => {})
+      end
+
+      test "sequel model" do
+        assert_equal ::Sequel::Model, Job.superclass
+        assert_equal :jobs, Job.table_name
+      end
+
+      test "belongs to resource" do
+        assert_respond_to Job.new, :resource
+      end
+
+      test "belongs to scenario" do
+        assert_respond_to Job.new, :scenario
+      end
+
+      test "percent completed" do
+        job = new_job(:name => 'transform', :resource => @resource, :total => 200, :completed => 54)
+        assert_equal 27, job.percent_completed
+        job.total = 0
+        assert_equal 0, job.percent_completed
+      end
+
+      test "execute transform" do
+        job = new_job(:name => 'transform', :resource => @resource).save!
+
+        now = Time.now
+        @resource.expects(:source_dataset_count).returns(12345)
+        seq = sequence("update")
+        job.expects(:update).with(:status => 'running', :total => 12345, :started_at => now).in_sequence(seq)
+        @resource.expects(:transform!).in_sequence(seq)
+        job.expects(:update).with(:status => 'done', :completed_at => now).in_sequence(seq)
+        Timecop.freeze(now) { job.execute }
+      end
+
+      test "failed transform sets failed status" do
+        job = new_job(:name => 'transform', :resource => @resource).save!
+
+        now = Time.now
+        @resource.stubs(:source_dataset_count).returns(12345)
+        seq = sequence("update")
+        job.expects(:update).with(:status => 'running', :total => 12345, :started_at => now).in_sequence(seq)
+        fake_exception_klass = Class.new(Exception)
+        @resource.expects(:transform!).raises(fake_exception_klass.new).in_sequence(seq)
+        job.expects(:update).with(:status => 'failed', :completed_at => now).in_sequence(seq)
+
+        Timecop.freeze(now) do
+          begin
+            job.execute
+          rescue fake_exception_klass
+          end
+        end
+      end
+
+      test "execute run scenario" do
+        job = new_job(:name => 'run_scenario', :scenario => @scenario).save!
+
+        now = Time.now
+        seq = sequence("update")
+        job.expects(:update).with(:status => 'running', :started_at => now).in_sequence(seq)
+        @scenario.expects(:run!).in_sequence(seq)
+        job.expects(:update).with(:status => 'done', :completed_at => now).in_sequence(seq)
+
+        Timecop.freeze(now) { job.execute }
+      end
+
+      test "failed run scenario sets failed status" do
+        job = new_job(:name => 'run_scenario', :scenario => @scenario).save!
+
+        now = Time.now
+        seq = sequence("update")
+        job.expects(:update).with(:status => 'running', :started_at => now).in_sequence(seq)
+        fake_exception_klass = Class.new(Exception)
+        @scenario.expects(:run!).raises(fake_exception_klass.new).in_sequence(seq)
+        job.expects(:update).with(:status => 'failed', :completed_at => now).in_sequence(seq)
+
+        Timecop.freeze(now) do
+          begin
+            job.execute
+          rescue fake_exception_klass
+          end
+        end
+      end
+
+      test "recently accessed" do
+        now = Time.now
+        job_1 = job_2 = job_3 = job_4 = nil
+        Timecop.freeze(now - 3) { job_1 = new_job(:name => "run_scenario", :scenario => @scenario).save! }
+        Timecop.freeze(now - 2) { job_2 = new_job(:name => "run_scenario", :scenario => @scenario).save! }
+        Timecop.freeze(now - 1) { job_3 = new_job(:name => "run_scenario", :scenario => @scenario).save! }
+        Timecop.freeze(now    ) { job_4 = new_job(:name => "run_scenario", :scenario => @scenario).save! }
+        assert_equal [job_4, job_3, job_2], Job.recently_accessed
+      end
+    end
+  end
+end

data/test/unit/models/test_matcher.rb

@@ -0,0 +1,82 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestMatcher < Coupler::Test::UnitTest
+      def new_matcher(attribs = {})
+        values = {
+          :scenario => @scenario,
+          :comparisons_attributes => [{
+            :lhs_type => 'field', :raw_lhs_value => 1,
+            :rhs_type => 'field', :raw_rhs_value => 2,
+            :operator => 'equals'
+          }]
+        }.update(attribs)
+        m = Matcher.new(values)
+        m.stubs(:scenario_dataset).returns(stub({:all => [values[:scenario]]}))
+        m
+      end
+
+      def setup
+        super
+        @scenario = stub('scenario', :pk => 456, :id => 456, :associations => {})
+        @field_1 = stub('field 1', :pk => 1, :id => 1, :associations => {})
+        @field_2 = stub('field 2', :pk => 2, :id => 2, :associations => {})
+      end
+
+      test "sequel model" do
+        assert_equal ::Sequel::Model, Matcher.superclass
+        assert_equal :matchers, Matcher.table_name
+      end
+
+      test "many to one scenario" do
+        assert_respond_to Matcher.new, :scenario
+      end
+
+      test "one to many comparisons" do
+        assert_respond_to Matcher.new, :comparisons
+      end
+
+      test "nested attributes for comparisons" do
+        assert_respond_to Matcher.new, :comparisons_attributes=
+      end
+
+      #test "deletes comparisons via nested attributes" do
+        #matcher = new_matcher({
+          #:comparisons_attributes => [
+            #{
+              #'lhs_type' => 'field', 'raw_lhs_value' => fields[1].id.to_s,
+              #'rhs_type' => 'field', 'raw_rhs_value' => fields[2].id.to_s,
+              #'operator' => 'equals'
+            #},
+            #{
+              #'lhs_type' => 'integer', 'raw_lhs_value' => 1,
+              #'rhs_type' => 'integer', 'raw_rhs_value' => 1,
+              #'operator' => 'equals'
+            #}
+          #]
+        #})
+        #assert_equal 2, matcher.comparisons_dataset.count
+
+        #comparison = matcher.comparisons_dataset.first
+        #matcher.update({
+          #:updated_at => Time.now,
+          #:comparisons_attributes => [{:id => comparison.id, :_delete => true}]
+        #})
+        #assert_equal 1, matcher.comparisons_dataset.count
+      #end
+
+      test "requires at least one field to field comparison" do
+        matcher = new_matcher
+        matcher.expects(:comparisons).returns([stub(:rhs_type => "integer", :lhs_type => "integer")])
+        assert !matcher.valid?
+      end
+
+      test "cross_match is true when a comparison is a cross match" do
+        matcher = new_matcher
+        matcher.expects(:comparisons).returns([mock(:cross_match? => true)])
+        assert matcher.cross_match?
+      end
+    end
+  end
+end

data/test/unit/models/test_project.rb

@@ -0,0 +1,102 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestProject < Coupler::Test::UnitTest
+      test "sequel model" do
+        assert_equal ::Sequel::Model, Project.superclass
+        assert_equal :projects, Project.table_name
+      end
+
+      test "one to many resources" do
+        assert_respond_to Project.new, :resources
+      end
+
+      test "one to many scenarios" do
+        assert_respond_to Project.new, :scenarios
+      end
+
+      test "requires name" do
+        project = Project.new
+        assert !project.valid?
+
+        project.name = ""
+        assert !project.valid?
+      end
+
+      test "requires unique name" do
+        project_1 = Project.create(:name => "foo")
+        project_2 = Project.new(:name => "foo")
+        assert !project_2.valid?
+      end
+
+      test "sets slug from name" do
+        project = Project.create('name' => 'Foo bar')
+        assert_equal "foo_bar", project.slug
+      end
+
+      test "requires unique slug" do
+        project_1 = Project.create(:name => "foo", :slug => 'foo')
+        project_2 = Project.new(:name => 'bar', :slug => 'foo')
+        assert !project_2.valid?
+
+        project_2.slug = "bar"
+        assert project_2.valid?
+        project_2.save
+
+        project_2.slug = "foo"
+        assert !project_2.valid?
+      end
+
+      test "saves existing project" do
+        project = Project.create(:name => "foo")
+        project.description = "Foo"
+        assert project.valid?
+        project.save
+      end
+
+      test "local_database" do
+        project = Project.create(:name => "foo")
+        FileUtils.rm(Dir[Base.db_path("project_#{project.id}")+".*"])
+
+        project.local_database do |db|
+          assert_kind_of Sequel::JDBC::Database, db
+          assert_match /project_#{project.id}/, db.uri
+          assert db.test_connection
+        end
+      end
+
+      test "deletes dependencies after destroy, but not versions" do
+        project = Project.create(:name => "foo")
+        project.expects(:resources_dataset).returns([mock(:delete_versions_on_destroy= => nil, :destroy => nil)])
+        project.expects(:scenarios_dataset).returns([mock(:delete_versions_on_destroy= => nil, :destroy => nil)])
+        project.destroy
+      end
+
+      test "deletes local database after destroy" do
+        project = Project.create(:name => "foo")
+        project.local_database { |db| db.test_connection }  # force creation of database
+        project.destroy
+        files = Dir[Base.db_path("project_#{project.id}")+".*"]
+        assert files.empty?, files.inspect
+      end
+
+      test "deletes dependencies and versions after destroy" do
+        project = Project.create(:name => "foo")
+        project.delete_versions_on_destroy = true
+        project.expects(:resources_dataset).returns([mock(:destroy => nil) { 
+          expects(:delete_versions_on_destroy=).with(true)
+        }])
+        project.expects(:scenarios_dataset).returns([mock(:destroy => nil) { 
+          expects(:delete_versions_on_destroy=).with(true)
+        }])
+        project.destroy
+        assert_equal 0, Database.instance[:projects_versions].filter(:current_id => project.id).count
+      end
+
+      #def test_local_database_uses_connection_class
+        #pend
+      #end
+    end
+  end
+end