coupler 0.0.1-java

data/test/unit/models/test_scenario.rb

@@ -0,0 +1,199 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestScenario < Coupler::Test::UnitTest
+      def setup
+        super
+        @project = stub('project', :pk => 1, :id => 1, :associations => {})
+        @resource_1 = stub('resource 1', :pk => 123, :id => 123, :associations => {}, :status => "ok")
+        @resource_2 = stub('resource 2', :pk => 456, :id => 456, :associations => {}, :status => "ok")
+        @matcher = stub('matcher', :cross_match? => false, :associations => {})
+      end
+
+      def new_scenario(attribs = {})
+        values = {
+          :name => 'Foo bar',
+          :project => @project,
+          :resource_1 => @resource_1,
+          :matcher => @matcher
+        }.update(attribs)
+        matcher = values.delete(:matcher)
+        s = Scenario.new(values)
+        if values[:project]
+          s.stubs(:project_dataset).returns(stub({:all => [values[:project]]}))
+        end
+        if values[:resource_1]
+          s.stubs(:resource_1_dataset).returns(stub({:all => [values[:resource_1]]}))
+        end
+        if values[:resource_2]
+          s.stubs(:resource_2_dataset).returns(stub({:all => [values[:resource_2]]}))
+        end
+        if matcher
+          s.stubs(:matcher_dataset).returns(stub({:all => [matcher]}))
+        end
+        s
+      end
+
+      test "sequel model" do
+        assert_equal ::Sequel::Model, Scenario.superclass
+        assert_equal :scenarios, Scenario.table_name
+      end
+
+      test "many to one project" do
+        assert_respond_to Scenario.new, :project
+      end
+
+      test "many to one resource 1" do
+        assert_respond_to Scenario.new, :resource_1
+      end
+
+      test "many to one resource 2" do
+        assert_respond_to Scenario.new, :resource_2
+      end
+
+      test "resources" do
+        scenario = Scenario.new(:resource_1 => @resource_1)
+        assert_equal [@resource_1], scenario.resources
+        scenario.resource_2 = @resource_2
+        assert_equal [@resource_1, @resource_2], scenario.resources
+      end
+
+      test "one to one matcher" do
+        assert_respond_to Scenario.new, :matcher
+      end
+
+      test "one to many jobs" do
+        assert_respond_to Scenario.new, :jobs
+      end
+
+      test "one to many results" do
+        assert_respond_to Scenario.new, :results
+      end
+
+      test "requires name" do
+        scenario = new_scenario(:name => nil)
+        scenario.expects(:validates_presence).with(:name).returns(false)
+        scenario.valid?
+      end
+
+      test "requires unique name across projects" do
+        scenario = new_scenario
+        scenario.expects(:validates_unique).with([:name, :project_id]).returns(false)
+        scenario.valid?
+      end
+
+      test "requires at least one resource" do
+        scenario = new_scenario(:resource_1 => nil)
+        assert !scenario.valid?
+      end
+
+      test "sets slug from name" do
+        scenario = new_scenario.save!
+        assert_equal "foo_bar", scenario.slug
+      end
+
+      test "setting one resource with resource_ids=" do
+        scenario = new_scenario(:resource_1 => nil, :resource_ids => [123])
+        resource_1 = @resource_1  # so mocha can resolve it
+        @project.expects(:resources_dataset).returns(mock {
+          expects(:filter).with(:id => [123]).returns(self)
+          expects(:all).returns([resource_1])
+        })
+        scenario.save!
+        assert_equal 123, scenario.resource_1_id
+      end
+
+      test "setting two resources with resource ids=" do
+        scenario = new_scenario(:resource_1 => nil, :resource_ids => [123, 456])
+        resource_1 = @resource_1  # so mocha can resolve it
+        resource_2 = @resource_2
+        @project.expects(:resources_dataset).returns(mock {
+          expects(:filter).with(:id => [123, 456]).returns(self)
+          expects(:all).returns([resource_1, resource_2])
+        })
+        scenario.save!
+        assert_equal 123, scenario.resource_1_id
+        assert_equal 456, scenario.resource_2_id
+      end
+
+      test "doesn't run when there is no matcher" do
+        scenario = new_scenario(:matcher => nil).save!
+        assert_raises(Scenario::NoMatcherError) { scenario.run! }
+      end
+
+      test "doesn't run when resources are out of date" do
+        scenario = new_scenario.save!
+        @resource_1.expects(:status).returns("out_of_date")
+        assert_raises(Scenario::ResourcesOutOfDateError) { scenario.run! }
+      end
+
+      test "status with no matcher" do
+        scenario = new_scenario(:matcher => nil).save!
+        assert_equal "no_matcher", scenario.status
+      end
+
+      test "status with matcher" do
+        scenario = new_scenario.save!
+        assert_equal "ok", scenario.status
+      end
+
+      test "status with outdated resources" do
+        scenario = new_scenario.save!
+        @resource_1.expects(:status).returns("out_of_date")
+        assert_equal "resources_out_of_date", scenario.status
+      end
+
+      test "linkage type with one resource" do
+        scenario = new_scenario.save!
+        assert_equal "self-linkage", scenario.linkage_type
+      end
+
+      test "linkage type with two resources" do
+        scenario = new_scenario(:resource_2 => @resource_2).save!
+        assert_equal "dual-linkage", scenario.linkage_type
+      end
+
+      test "matcher with cross match makes cross-linkage" do
+        scenario = new_scenario.save!
+        @matcher.stubs(:cross_match?).returns(true)
+        scenario.set_linkage_type
+        assert_equal "cross-linkage", scenario.linkage_type
+      end
+
+      test "jobified" do
+        assert Scenario.ancestors.include?(Jobify)
+      end
+
+      #def test_destroying
+        #pend
+      #end
+
+      test "local database" do
+        scenario = new_scenario.save!
+        Base.expects(:connection_string).with("scenario_#{scenario.id}").returns("foo")
+        db = mock('scenario db')
+        Sequel.expects(:connect).with('foo', instance_of(Hash)).returns(db)
+        assert_equal db, scenario.local_database
+      end
+
+      #def test_deletes_local_database_after_destroy
+        #pend
+      #end
+
+      #def test_freezes_models_on_run
+        #flunk
+      #end
+
+      test "count by project" do
+        ds = mock('dataset') do
+          expects(:naked).returns(self)
+          expects(:group_and_count).with(:project_id).returns(self)
+          expects(:to_hash).with(:project_id, :count).returns({ 1 => 1 })
+        end
+        Scenario.expects(:dataset).returns(ds)
+        assert_equal({1 => 1}, Scenario.count_by_project)
+      end
+    end
+  end
+end

data/test/unit/models/test_transformation.rb

@@ -0,0 +1,193 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestTransformation < Coupler::Test::UnitTest
+      def new_transformation(attribs = {})
+        values = {
+          :transformer => @transformer,
+          :resource => @resource,
+          :source_field => @source_field
+        }.update(attribs)
+        t = Transformation.new(values)
+        if values[:transformer]
+          t.stubs(:transformer_dataset).returns(stub({:all => [values[:transformer]]}))
+        end
+        if values[:source_field]
+          t.stubs(:source_field_dataset).returns(stub({:all => [values[:source_field]]}))
+          if values[:resource]
+            values[:resource].stubs(:fields_dataset).returns(stub('fields dataset') {
+              stubs(:[]).with(:id => values[:source_field].id).returns(values[:source_field])
+            })
+          end
+        end
+        if values[:result_field]
+          t.stubs(:result_field_dataset).returns(stub({:all => [values[:result_field]]}))
+        end
+        if values[:resource]
+          t.stubs(:resource_dataset).returns(stub({:all => [values[:resource]]}))
+          values[:resource].stubs(:fields_dataset).returns(stub('fields dataset') {
+            stubs(:[]).returns(nil)
+            if values[:source_field]
+              stubs(:[]).with(:id => values[:source_field].id).returns(values[:source_field])
+            end
+            if values[:result_field]
+              stubs(:[]).with(:id => values[:result_field].id).returns(values[:result_field])
+            end
+          })
+        end
+        t
+      end
+
+      def setup
+        super
+        @resource = stub('resource', :pk => 3, :id => 3, :associations => {}, :refresh_fields! => nil)
+        @transformer = stub('transformer', {
+          :pk => 1, :id => 1, :associations => {},
+          :allowed_types => %w{string}, :name => "foobar"
+        })
+        @source_field = stub('source_field', {
+          :pk => 7, :id => 7, :associations => {},
+          :final_type => 'string', :name => 'first_name'
+        })
+        @result_field = stub('result_field', {
+          :pk => 8, :id => 8, :associations => {},
+          :final_type => 'string', :name => 'new_first_name'
+        })
+      end
+
+      test "sequel model" do
+        assert_equal ::Sequel::Model, Transformation.superclass
+        assert_equal :transformations, Transformation.table_name
+      end
+
+      test "many to one resource" do
+        assert_respond_to Transformation.new, :resource
+      end
+
+      test "many to one source field" do
+        assert_respond_to Transformation.new, :source_field
+      end
+
+      test "many to one result field" do
+        assert_respond_to Transformation.new, :result_field
+      end
+
+      test "requires resource id" do
+        transformation = new_transformation(:resource => nil)
+        assert !transformation.valid?
+      end
+
+      test "requires existing transformer or nested attributes" do
+        transformation = new_transformation(:transformer => nil)
+        assert !transformation.valid?
+      end
+
+      test "requires correct field type" do
+        @source_field.stubs(:final_type).returns('integer')
+        transformation = new_transformation
+        assert !transformation.valid?
+      end
+
+      test "requires existing source field" do
+        transformation = new_transformation(:source_field => nil, :source_field_id => 1337)
+        assert !transformation.valid?
+      end
+
+      test "result field same as source field by default" do
+        transformation = new_transformation.save!
+        assert_equal transformation.result_field_id, @source_field.id
+      end
+
+      test "requires existing result field or nested attributes" do
+        transformation = new_transformation(:result_field_id => 1337)
+        assert !transformation.valid?
+      end
+
+      test "accepts nested attributes for transformer" do
+        assert_respond_to Transformation.new, :transformer_attributes=
+      end
+
+      test "transform with same source and result field" do
+        transformation = new_transformation(:result_field => @source_field).save!
+
+        data = {:id => 1, :first_name => "Peter"}
+        expected = stub("result")
+        @transformer.expects(:transform).with(data, { :in => :first_name, :out => :first_name }).returns(expected)
+
+        assert_equal expected, transformation.transform(data)
+      end
+
+      test "transform with differing source and result field" do
+        transformation = new_transformation(:result_field => @result_field)
+
+        data = {:id => 1, :first_name => "Peter"}
+        expected = stub("result")
+        transformation.transformer.expects(:transform).with(data, { :in => :first_name, :out => :new_first_name }).returns(expected)
+
+        assert_equal expected, transformation.transform(data)
+      end
+
+      test "field changes" do
+        transformation = new_transformation.save!
+        result = stub('result')
+        @transformer.expects(:field_changes).with(@source_field).returns(result)
+        assert_equal result, transformation.field_changes
+      end
+
+      test "updates resource fields on save" do
+        transformation = new_transformation
+        @resource.expects(:refresh_fields!)
+        transformation.save!
+      end
+
+      #def test_updates_resource_fields_on_destroy
+        #pend
+      #end
+
+      test "deletes orphaned result field on destroy" do
+        @result_field.stubs(:is_generated).returns(true)
+        @result_field.stubs(:scenarios_dataset).returns(stub(:count => 0))
+        transformation = new_transformation(:result_field => @result_field).save!
+        Transformation.expects(:filter).with(:result_field_id => 8).returns(mock(:count => 0))
+        @result_field.expects(:destroy)
+        transformation.destroy
+      end
+
+      test "does not delete result field in use by other transformation" do
+        @result_field.stubs(:is_generated).returns(true)
+        @result_field.stubs(:scenarios_dataset).returns(stub(:count => 0))
+        transformation = new_transformation(:result_field => @result_field).save!
+        Transformation.expects(:filter).with(:result_field_id => 8).returns(mock(:count => 1))
+        @result_field.expects(:destroy).never
+        transformation.destroy
+      end
+
+      test "prevents deletion if result field is in use by scenario" do
+        @result_field.stubs(:is_generated).returns(true)
+        @result_field.stubs(:scenarios_dataset).returns(stub(:count => 1))
+        transformation = new_transformation(:result_field => @result_field).save!
+        assert !transformation.destroy
+      end
+
+      test "prevents deletion unless in last position" do
+        transformation_1 = new_transformation(:position => 1).save!
+        transformation_2 = new_transformation(:position => 2).save!
+        assert !transformation_1.destroy
+        assert_not_nil Transformation[:id => transformation_1.id]
+      end
+
+      test "sets position by resource" do
+        resource_1 = stub('resource', :pk => 1, :id => 1, :associations => {}, :refresh_fields! => nil)
+        resource_2 = stub('resource', :pk => 2, :id => 2, :associations => {}, :refresh_fields! => nil)
+
+        xformation_1 = new_transformation(:resource => resource_1).save!
+        xformation_2 = new_transformation(:resource => resource_1).save!
+        xformation_3 = new_transformation(:resource => resource_2).save!
+        assert_equal 1, xformation_1.position
+        assert_equal 2, xformation_2.position
+        assert_equal 1, xformation_3.position
+      end
+    end
+  end
+end

data/test/unit/models/test_transformer.rb

@@ -0,0 +1,188 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestTransformer < Coupler::Test::UnitTest
+      def new_transformer(attribs = {})
+        values = {
+          :name => "foo",
+          :code => "value",
+          :allowed_types => %w{string integer datetime},
+          :result_type => 'same'
+        }.update(attribs)
+        Transformer.new(values)
+      end
+
+      test "sequel model" do
+        assert_equal ::Sequel::Model, Transformer.superclass
+        assert_equal :transformers, Transformer.table_name
+      end
+
+      test "requires name" do
+        xformer = new_transformer(:name => nil)
+        assert !xformer.valid?
+      end
+
+      test "requires unique name" do
+        new_transformer(:name => "foobar").save!
+        xformer = new_transformer(:name => "foobar")
+        assert !xformer.valid?
+      end
+
+      test "serializes allowed types" do
+        new_transformer.save!
+        xformer = Transformer[:name => "foo"]
+        assert_equal %w{string integer datetime}, xformer.allowed_types
+      end
+
+      test "requires allowed types" do
+        xformer = new_transformer(:allowed_types => nil)
+        assert !xformer.valid?
+      end
+
+      test "requires valid allowed types" do
+        xformer = new_transformer(:allowed_types => %w{blah})
+        assert !xformer.valid?
+      end
+
+      test "requires result type" do
+        xformer = new_transformer(:result_type => nil)
+        assert !xformer.valid?
+      end
+
+      test "requires valid result type" do
+        xformer = new_transformer(:result_type => "blah")
+        assert !xformer.valid?
+      end
+
+      test "special result type" do
+        xformer = new_transformer(:result_type => "same")
+        assert xformer.valid?
+      end
+
+      test "requires code" do
+        xformer = new_transformer(:code => nil)
+        assert !xformer.valid?
+      end
+
+      test "requires parseable code" do
+        xformer = new_transformer(:code => "foo(")
+        assert !xformer.valid?
+      end
+
+      test "no-op transform" do
+        xformer = new_transformer.save!
+        original = {:id => 1, :first_name => "Golan", :last_name => "Trevize"}
+        expected = original.dup
+        result = xformer.transform(original, { :in => :first_name, :out => :first_name })
+        assert_equal expected, result
+      end
+
+      test "transform new field" do
+        xformer = new_transformer(:code => "value.downcase", :allowed_types => %w{string}).save!
+        original = {:id => 1, :first_name => "Golan", :last_name => "Trevize"}
+        expected = original.merge(:first_name_small => "golan")
+        result = xformer.transform(original.dup, { :in => :first_name, :out => :first_name_small })
+        assert_equal expected, result
+      end
+
+      test "preview downcaser" do
+        xformer = new_transformer({
+          :name => "downcaser", :code => "value.to_s.downcase",
+          :allowed_types => %w{integer string datetime},
+          :result_type => "string"
+        })
+        now = Time.now
+        Timecop.freeze(now) do
+          expected = {
+            'integer'  => {:in => 123, :out => "123"},
+            'string'   => {:in => "Test", :out => "test"},
+            'datetime' => {:in => now, :out => now.to_s.downcase},
+            'success'  => true
+          }
+          assert_equal expected, xformer.preview
+        end
+      end
+
+      test "preview fails if invalid" do
+        assert_nil Transformer.new.preview
+      end
+
+      test "preview code error returns exception" do
+        xformer = new_transformer({
+          :name => "downcaser", :code => "value.downcase",
+          :allowed_types => %w{integer string datetime},
+          :result_type => "string"
+        })
+        now = Time.now
+        Timecop.freeze(now) do
+          expected = {
+            'integer'  => {:in => 123, :out => Exception},
+            'string'   => {:in => "Test", :out => "test"},
+            'datetime' => {:in => now, :out => Exception},
+            'success'  => false
+          }
+          assert expected === xformer.preview
+        end
+      end
+
+      test "requires successful preview" do
+        xformer = new_transformer({
+          :name => "downcaser", :code => "value.downcase",
+          :allowed_types => %w{integer string datetime},
+          :result_type => "string"
+        })
+        assert !xformer.valid?
+      end
+
+      test "requires correct result type" do
+        xformer = new_transformer({
+          :name => "stringify", :code => "value.to_i",
+          :allowed_types => %w{integer string datetime},
+          :result_type => "string"
+        })
+        assert !xformer.valid?
+      end
+
+      test "requires same result type" do
+        xformer = new_transformer({
+          :name => "stringify", :code => "value.to_i",
+          :allowed_types => %w{integer string datetime},
+          :result_type => "same"
+        })
+        assert !xformer.valid?
+      end
+
+      test "allows nil return value" do
+        xformer = new_transformer({
+          :name => "nullify", :code => "nil",
+          :allowed_types => %w{integer string datetime},
+          :result_type => "same"
+        })
+        assert xformer.valid?
+      end
+
+      test "field changes with no type changes" do
+        field = stub('field', :id => 1)
+        transformer = new_transformer({
+          :allowed_types => %w{integer datetime string},
+          :result_type => 'same', :code => 'value'
+        }).save!
+        assert_equal({ field.id => { } }, transformer.field_changes(field))
+      end
+
+      test "field changes to integer" do
+        field = stub('field', :id => 1)
+        transformer = new_transformer({
+          :allowed_types => %w{integer datetime string},
+          :result_type => 'integer', :code => 'value.to_i'
+        }).save!
+        assert_equal({ field.id => { :db_type => "int(11)", :type => :integer } }, transformer.field_changes(field))
+      end
+
+      #def test_should_handle_empty_values
+        #pend
+      #end
+    end
+  end
+end

data/test/unit/test_base.rb

@@ -0,0 +1,60 @@
+require 'helper'
+
+module Coupler
+  class TestBase < Coupler::Test::UnitTest
+    def test_subclasses_sinatra_base
+      assert_equal Sinatra::Base, Coupler::Base.superclass
+    end
+
+    def test_index_when_no_projects
+      get "/"
+      assert last_response.ok?
+      assert_match /Getting Started/, last_response.body
+    end
+
+    def test_redirect_when_projects_exist
+      project = Factory(:project)
+      get "/"
+      assert last_response.redirect?
+      assert_equal "http://example.org/projects", last_response['location']
+    end
+
+    def test_db_path
+      env = Base.settings.environment
+      begin
+        Base.set :environment, :production
+        expected = File.join(Base.settings.data_path, 'db', 'production', 'ponies')
+        assert_equal expected, Base.db_path("ponies")
+      ensure
+        Base.set :environment, env
+      end
+    end
+
+    def test_connection_string
+      env = Base.settings.environment
+      begin
+        Base.set :environment, :production
+        expected = "jdbc:h2:#{File.join(Base.settings.data_path, 'db', 'production', 'ponies')};IGNORECASE=TRUE"
+        assert_equal expected, Base.connection_string("ponies")
+      ensure
+        Base.set :environment, env
+      end
+    end
+
+    def test_upload_path
+      env = Base.settings.environment
+      begin
+        Base.set :environment, :production
+        expected = File.join(Base.settings.data_path, 'uploads', 'production')
+        assert_equal expected, Base.upload_path
+      ensure
+        Base.set :environment, env
+      end
+    end
+
+    def test_log_path
+      expected = File.join(Base.settings.data_path, 'log')
+      assert_equal expected, Base.log_path
+    end
+  end
+end

data/test/unit/test_data_uploader.rb

@@ -0,0 +1,27 @@
+require 'helper'
+
+module Coupler
+  class TestDataUploader < Coupler::Test::UnitTest
+    def test_carrierwave_subclass
+      assert_equal CarrierWave::Uploader::Base, DataUploader.superclass
+    end
+
+    def test_store_dir_same_as_upload_path
+      Base.expects(:upload_path).returns("/path/to/uploads")
+      uploader = DataUploader.new
+      assert_equal "/path/to/uploads", uploader.store_dir
+    end
+
+    def test_cache_dir_uses_upload_path
+      Base.expects(:upload_path).returns("/path/to/uploads")
+      uploader = DataUploader.new
+      assert_equal "/path/to/uploads/tmp", uploader.cache_dir
+    end
+
+    def test_filename_uniqueness
+      uploader = DataUploader.new
+      uploader.store!(fixture_file_upload('people.csv'))
+      assert_match /^people-[a-f0-9]+.csv$/, uploader.filename
+    end
+  end
+end

data/test/unit/test_database.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+module Coupler
+  class TestDatabase < Coupler::Test::UnitTest
+    def setup
+      super
+      @database = Coupler::Database.instance
+    end
+
+    def test_connection
+      assert_kind_of Sequel::JDBC::Database, @database.__getobj__
+
+      expected = Base.connection_string('coupler')
+      assert_equal expected, @database.uri
+    end
+
+    def test_migrate
+      dir = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "db", "migrate"))
+      Sequel::Migrator.expects(:apply).with(@database.__getobj__, dir)
+      @database.migrate!
+    end
+  end
+end