coupler 0.0.4-java → 0.0.6-java

data/test/coupler/models/test_import.rb

@@ -1,221 +0,0 @@
-require File.dirname(__FILE__) + '/../../helper'
-
-module Coupler
-  module Models
-    class TestImport < Test::Unit::TestCase
-      def test_sequel_model
-        assert_equal ::Sequel::Model, Models::Import.superclass
-        assert_equal :imports, Import.table_name
-      end
-
-      def test_many_to_one_project
-        assert_respond_to Models::Import.new, :project
-      end
-
-      def test_gets_name_from_original_filename
-        import = Import.new(:data => fixture_file_upload('people.csv'))
-        assert_equal "People", import.name
-      end
-
-      def test_preview_with_headers
-        import = Factory.build(: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
-
-      def test_discovers_field_names_and_types
-        import = Factory.build(:import, :data => fixture_file_upload("people.csv"))
-        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
-
-      def test_discover_for_csv_with_no_headers
-        tempfile = Tempfile.new('coupler-import')
-        tempfile.write("foo,bar,1,2,3\njunk,blah,4,5,6")
-        tempfile.close
-        import = Factory.build(: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
-
-      def test_import!
-        project = Factory(:project)
-        import = Factory(:import, :data => fixture_file_upload("people.csv"), :project => project)
-        now = Time.now
-        Timecop.freeze(now) do
-          assert import.import!
-          assert_equal now, import.occurred_at
-        end
-
-        project.local_database do |db|
-          name = :"import_#{import.id}"
-          assert db.tables.include?(name)
-          schema = db.schema(name)
-          assert_equal [:integer, true], schema.assoc(:id)[1].values_at(:type, :primary_key)
-          assert_equal :string, schema.assoc(:first_name)[1][:type]
-          assert_equal :string, schema.assoc(:last_name)[1][:type]
-          assert_equal :integer, schema.assoc(:age)[1][:type]
-
-          ds = db[name]
-          assert_equal 50, ds.count
-        end
-      end
-
-      def test_requires_field_names
-        import = Factory.build(:import, :data => fixture_file_upload('no-headers.csv'))
-        assert_nil import.field_names
-        assert !import.valid?
-      end
-
-      def test_requires_primary_key_name
-        import = Factory.build(:import, :data => fixture_file_upload('no-headers.csv'))
-        import.field_names = %w{id first_name last_name age}
-        assert !import.valid?
-      end
-
-      def test_requires_valid_primary_key_name
-        import = Factory.build(: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
-
-      def test_flags_duplicate_primary_keys
-        tempfile = Tempfile.new('coupler-import')
-        tempfile.write("id,foo,bar\n1,abc,def\n2,ghi,jkl\n2,mno,pqr")
-        tempfile.close
-
-        project = Factory(:project)
-        import = Factory(:import, :data => file_upload(tempfile.path), :project => project)
-
-        now = Time.at(Time.now.to_i)  # dumb usecs
-        Timecop.freeze(now) do
-          assert !import.import!
-          assert import.has_duplicate_keys
-          assert_equal now, import.occurred_at, "now: %d-%d; occurred_at: %d-%d" % [now.to_i, now.usec, import.occurred_at.to_i, import.occurred_at.usec]
-        end
-
-        project.local_database do |db|
-          ds = db[:"import_#{import.id}"]
-          assert ds.filter(:id => 2).select_map(:dup_key_count).all?
-        end
-      end
-
-      def test_requires_unique_field_names
-        tempfile = Tempfile.new('coupler-import')
-        tempfile.write("id,foo,foo\n1,abc,def\n2,ghi,jkl\n3,mno,pqr")
-        tempfile.close
-
-        import = Factory.build(:import, :data => file_upload(tempfile.path))
-        assert !import.valid?
-      end
-
-      def test_requires_unused_resource_name
-        project = Factory(:project)
-        resource = Factory(:resource, :name => "Foo", :project => project)
-        import = Factory.build(:import, :data => fixture_file_upload('people.csv'), :name => "Foo", :project => project)
-        assert !import.valid?
-      end
-
-      def test_dataset
-        project = Factory(:project)
-        import = Factory(:import, :project => project)
-        import.import!
-        project.local_database do |db|
-          import.dataset do |ds|
-            expected = db[:"import_#{import.id}"]
-            assert_equal expected.first_source, ds.first_source
-            assert_equal db.uri, ds.db.uri
-          end
-        end
-      end
-
-      def test_filenames_dont_conflict
-        dir = make_tmpdir
-        filename = File.join(dir, "people.csv")
-        tempfile = File.open(filename, 'w')
-        tempfile.puts("id,foo,bar\n")
-        tempfile.puts("abc,def,ghi\n")
-        tempfile.close
-        import_1 = Factory(:import, :data => fixture_file_upload('people.csv'))
-        import_2 = Factory(:import, :data => file_upload(filename))
-        assert_not_equal import_1.data.store_path, import_2.data.store_path
-      end
-
-      def test_repair_duplicate_keys
-        project = Factory(:project)
-        import = Factory(:import, :data => fixture_file_upload('duplicate-keys.csv'), :project => project)
-        import.import!
-
-        import.repair_duplicate_keys!(nil)
-        import.dataset do |ds|
-          assert !ds.columns!.include?(:dup_key_count)
-          assert_equal 1, ds.filter(:id => 2).count
-          assert_equal 1, ds.filter(:id => 4).count
-        end
-        project.local_database do |db|
-          assert db.schema(:"import_#{import.id}").assoc(:id)[1][:primary_key]
-        end
-      end
-
-      def test_repair_duplicate_keys_with_deletions
-        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
-
-        project = Factory(:project)
-        #puts "Project: #{project.id}"
-        import = Factory(:import, :data => file_upload(tempfile.path), :project => project)
-        #puts "Import: #{import.id}"
-        import.import!
-
-        import.repair_duplicate_keys!({"1" => ["1"]})
-        import.dataset do |ds|
-          assert !ds.columns!.include?(:dup_key_count)
-          assert_equal 1, ds.filter(:id => 1).count
-          assert_equal 1, ds.filter(:id => 124).count
-          assert_equal 0, ds.filter(:id => 125).count
-        end
-        project.local_database do |db|
-          assert db.schema(:"import_#{import.id}").assoc(:id)[1][:primary_key]
-        end
-      end
-
-      def test_discover_fields_for_csv_with_headers_and_varying_number_of_fields
-        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 = Factory.build(: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
-
-      def test_importing_bad_integers
-        tempfile = Tempfile.new('coupler-import')
-        tempfile.write(%{id,foo,bar\n1,2,3\n2,4,5\n3,6,7\n4,456,""\n})
-        tempfile.close
-
-        project = Factory(:project)
-        import = Factory(:import, :data => file_upload(tempfile.path), :project => project)
-        assert_nothing_raised do
-          import.import!
-        end
-      end
-    end
-  end
-end

data/test/factories.rb

@@ -1,91 +0,0 @@
-require 'factory_girl'
-
-Factory.sequence(:connection_name) { |n| "Connection #{n}" }
-Factory.define :connection, :class => Coupler::Models::Connection do |c|
-  c.name { Factory.next(:connection_name) }
-  c.adapter "h2"
-end
-
-Factory.sequence(:resource_name) { |n| "Resource #{n}" }
-Factory.define :resource, :class => Coupler::Models::Resource do |r|
-  r.name { Factory.next(:resource_name) }
-  r.table_name "people"
-  r.association :connection
-  r.association :project
-end
-
-Factory.define :project, :class => Coupler::Models::Project do |d|
-  d.sequence(:name) { |n| "Project #{n}" }
-end
-
-Factory.define :transformation, :class => Coupler::Models::Transformation do |t|
-  t.association :transformer
-  t.association :resource
-  t.source_field do |record|
-    record.resource.fields_dataset.first rescue nil
-  end
-end
-
-Factory.define :scenario, :class => Coupler::Models::Scenario do |s|
-  s.sequence(:name) { |n| "Scenario #{n}" }
-  s.association :project
-  s.resource_1 { |x| x.project ? Factory(:resource, :project => x.project) : nil }
-end
-
-Factory.define :matcher, :class => Coupler::Models::Matcher do |m|
-  m.association :scenario
-  m.comparisons_attributes do |record|
-    resources = record.scenario.resources
-    [{
-      'lhs_type' => 'field', 'raw_lhs_value' => resources[0].fields_dataset.order('id DESC').last.id, 'lhs_which' => 1,
-      'rhs_type' => 'field', 'raw_rhs_value' => resources[-1].fields_dataset.order('id DESC').last.id, 'rhs_which' => 2,
-      'operator' => 'equals'
-    }]
-  end
-end
-
-Factory.define :result, :class => Coupler::Models::Result do |r|
-  r.association :scenario
-end
-
-Factory.define :resource_job, :class => Coupler::Models::Job do |j|
-  j.name 'transform'
-  j.status 'scheduled'
-  j.association :resource
-end
-
-Factory.define :scenario_job, :class => Coupler::Models::Job do |j|
-  j.name 'run_scenario'
-  j.status 'scheduled'
-  j.association :scenario
-end
-
-Factory.define :transformer, :class => Coupler::Models::Transformer do |t|
-  t.sequence(:name) { |n| "Transformer #{n}" }
-  t.code "value"
-  t.allowed_types { |x| %w{string integer datetime} }
-  t.result_type "same"
-end
-
-Factory.define :field, :class => Coupler::Models::Field do |f|
-  f.sequence(:name) { |n| "field_#{n}" }
-  f.add_attribute :type, "integer"
-  f.db_type "int(11)"
-  f.is_primary_key 0
-  f.is_selected 1
-  f.association :resource
-end
-
-Factory.define :comparison, :class => Coupler::Models::Comparison do |c|
-  c.association :matcher
-  c.lhs_type "integer"
-  c.raw_lhs_value 1
-  c.rhs_type "integer"
-  c.raw_rhs_value 1
-  c.operator "equals"
-end
-
-Factory.define :import, :class => Coupler::Models::Import do |i|
-  i.data { File.open(File.join(File.dirname(__FILE__), 'fixtures', 'people.csv')) }
-  i.association :project
-end

data/test/integration/extensions/test_connections.rb

@@ -1,80 +0,0 @@
-require 'helper'
-
-module TestExtensions
-  class TestConnections < Coupler::Test::IntegrationTest
-    def setup
-      super
-      @connections = []
-      @configs = {}
-      each_adapter do |adapter, config|
-        conn = new_connection(adapter, :name => "#{adapter} connection").save!
-        @connections << conn
-        @configs[adapter] = config
-      end
-    end
-
-    test "index" do
-      get "/connections"
-      assert last_response.ok?
-    end
-
-    test "new" do
-      get "/connections/new"
-      assert last_response.ok?
-
-      doc = Nokogiri::HTML(last_response.body)
-      assert_equal 1, doc.css("form[action='/connections']").length
-      assert_equal 1, doc.css("select[name='connection[adapter]']").length
-      %w{name host port username password}.each do |name|
-        assert_equal 1, doc.css("input[name='connection[#{name}]']").length
-      end
-    end
-
-    test "successfully creating connection" do
-      attributes = @configs['mysql'].merge(:name => 'foo', :adapter => 'mysql')
-      post "/connections", { 'connection' => attributes }
-      connection = Connection[:name => 'foo']
-      assert connection
-
-      assert last_response.redirect?, "Wasn't redirected"
-      assert_equal "http://example.org/connections", last_response['location']
-    end
-
-    test "successfully creating connection with return to" do
-      attributes = @configs['mysql'].merge(:name => 'foo', :adapter => 'mysql')
-      post "/connections", { 'connection' => attributes }, { 'rack.session' => { :return_to => '/foo' } }
-
-      assert last_response.redirect?, "Wasn't redirected"
-      assert_equal "http://example.org/foo", last_response['location']
-    end
-
-    test "successfully creating connection with first use" do
-      attributes = @configs['mysql'].merge(:name => 'foo', :adapter => 'mysql')
-      post "/connections", { 'connection' => attributes }, { 'rack.session' => { :first_use => true } }
-
-      assert last_response.redirect?, "Wasn't redirected"
-      assert_equal "http://example.org/projects/new", last_response['location']
-    end
-
-    test "failing to create connection" do
-      attributes = @configs['mysql'].merge(:name => nil, :adapter => 'mysql')
-      post "/connections", { 'connection' => attributes }
-      assert last_response.ok?
-      assert_match /Name is not present/, last_response.body
-    end
-
-    test "show" do
-      @connections.each do |conn|
-        get "/connections/#{conn.id}"
-        assert last_response.ok?
-      end
-    end
-
-    test "destroy" do
-      delete "/connections/#{@connections[0].id}"
-      assert_nil Models::Connection[@connections[0].id]
-      assert last_response.redirect?
-      assert_equal "http://example.org/connections", last_response['location']
-    end
-  end
-end

data/test/integration/extensions/test_imports.rb

@@ -1,94 +0,0 @@
-require 'helper'
-
-module TestExtensions
-  class TestImports < Coupler::Test::IntegrationTest
-    def setup
-      super
-      @project = Project.create(:name => 'foo')
-    end
-
-    test "upload saves file" do
-      post "/projects/#{@project.id}/imports/upload", :data => fixture_file_upload("people.csv")
-      assert last_response.ok?
-    end
-
-    test "upload with no headers" do
-      post "/projects/#{@project.id}/imports/upload", :data => fixture_file_upload("no-headers.csv")
-      assert last_response.ok?
-    end
-
-    test "create with no issues" do
-      cached_import = Import.new(:project => @project, :data => fixture_file_upload('people.csv'))
-
-      post("/projects/#{@project.id}/imports", {
-        :import => {
-          :name => cached_import.name,
-          :data_cache => cached_import.data_cache,
-          :primary_key_name => cached_import.primary_key_name,
-          :field_names => cached_import.field_names,
-          :field_types => cached_import.field_types,
-          :has_headers => true
-        }
-      })
-      assert last_response.redirect?, "Wasn't a redirect"
-      assert_match %r{^http://example.org/projects/#{@project[:id]}/resources/\d+$}, last_response['location']
-    end
-
-    test "create with invalid import" do
-      cached_import = Import.new(:project => @project, :data => fixture_file_upload('people.csv'))
-
-      post("/projects/#{@project.id}/imports", {
-        :import => {
-          :name => cached_import.name,
-          :data_cache => cached_import.data_cache,
-          :primary_key_name => cached_import.primary_key_name,
-          :field_names => nil,
-          :field_types => cached_import.field_types,
-          :has_headers => true
-        }
-      })
-      assert last_response.ok?
-    end
-
-    test "create with non existant project" do
-      post "/projects/8675309/imports"
-      assert last_response.redirect?
-      assert_equal "http://example.org/projects", last_response['location']
-      follow_redirect!
-      assert_match /The project you were looking for doesn't exist/, last_response.body
-    end
-
-    test "create with failed import" do
-      cached_import = Import.new(:project => @project, :data => fixture_file_upload('duplicate-keys.csv'))
-
-      post("/projects/#{@project.id}/imports", {
-        :import => {
-          :name => cached_import.name,
-          :data_cache => cached_import.data_cache,
-          :primary_key_name => cached_import.primary_key_name,
-          :field_names => cached_import.field_names,
-          :field_types => cached_import.field_types,
-          :has_headers => true
-        }
-      })
-      assert last_response.redirect?, "Wasn't redirected"
-      assert_match %r{http://example.org/projects/#{@project.id}/imports/\d+/edit}, last_response['location']
-    end
-
-    test "edit import with duplicate keys" do
-      import = Import.create(:project => @project, :data => fixture_file_upload('duplicate-keys.csv'))
-      import.import!
-      get "/projects/#{@project.id}/imports/#{import.id}/edit"
-      assert last_response.ok?
-    end
-
-    test "update import with duplicate keys" do
-      import = Import.create(:project => @project, :data => fixture_file_upload('duplicate-keys.csv'))
-      import.import!
-
-      put("/projects/#{@project[:id]}/imports/#{import.id}", { :delete => { "1" => ["1", "2"] }})
-      assert last_response.redirect?
-      assert_match %r{http://example.org/projects/#{@project[:id]}/resources/\d+}, last_response['location']
-    end
-  end
-end