coupler 0.0.7-java → 0.0.8-java

data/lib/coupler/models/result.rb

@@ -1,4 +1,3 @@
-pp caller
 module Coupler
   module Models
     class Result < Sequel::Model

data/lib/coupler/models/scenario.rb

@@ -1,4 +1,3 @@
-pp caller
 module Coupler
   module Models
     class Scenario < Sequel::Model

data/lib/coupler/models/transformation.rb

@@ -1,4 +1,3 @@
-pp caller
 module Coupler
   module Models
     class Transformation < Sequel::Model
@@ -93,7 +92,7 @@ module Coupler
 
         def after_save
           super
-          resource.refresh_fields!
+          resource.transformations_updated!
         end
 
         def before_destroy
@@ -111,7 +110,7 @@ module Coupler
           if result_field && result_field.is_generated && self.class.filter(:result_field_id => result_field.id).count == 0
             result_field.destroy
           end
-          resource.refresh_fields!  if resource
+          resource.transformations_updated!  if resource
         end
     end
   end

data/lib/coupler/models/transformer.rb

@@ -1,4 +1,3 @@
-pp caller
 module Coupler
   module Models
     class Transformer < Sequel::Model

data/lib/coupler/scheduler.rb

@@ -23,6 +23,14 @@ module Coupler
       })
     end
 
+    def schedule_import_job(import)
+      Models::Job.create({
+        :name => "import",
+        :import => import,
+        :status => "scheduled"
+      })
+    end
+
     def run_jobs
       @mutex.synchronize do
         count = Models::Job.filter(:status => 'running').count

data/tasks/db.rake

@@ -16,7 +16,7 @@ namespace :db do
   desc "Run migrations"
   task :migrate => :environment do
     version = ENV['VERSION']
-    Coupler::Database.instance.migrate!(version ? version.to_i : nil)
+    Coupler::Database.migrate!(version ? version.to_i : nil)
   end
 
   namespace :migrate do
@@ -26,7 +26,7 @@ namespace :db do
 
   desc "Roll the database back a version"
   task :rollback => [:start, :environment] do
-    Coupler::Database.instance.rollback!
+    Coupler::Database.rollback!
   end
 
   desc "Reset and bootstrap the database"

data/test/functional/test_imports.rb

@@ -33,12 +33,16 @@ module CouplerFunctionalTests
       find('label[for="resource-type-csv"]').click
       attach_file('data', fixture_path('people.csv'))
 
+      job_count = Job.count
+      resource_count = Resource.count
       click_button('Begin Importing')
-      assert_match %r{^/projects/#{@project[:id]}/resources/\d+$}, page.current_path
+      assert_match %r{^/projects/#{@project[:id]}/resources$}, page.current_path
+      assert_equal resource_count + 1, Resource.count
+      assert_equal job_count + 1, Job.count
     end
 
     attribute(:javascript, true)
-    test "create with invalid import" do
+    test "create with invalid import, fix, and continue" do
       visit "/projects/#{@project.id}/resources/new"
       find('label[for="resource-type-csv"]').click
       attach_file('data', fixture_path('people.csv'))
@@ -47,30 +51,34 @@ module CouplerFunctionalTests
       click_button('Begin Importing')
 
       assert page.has_selector?("div.errors")
+
+      fill_in('name', :with => 'Foo Bar')
+      click_button('Begin Importing')
+      assert_match %r{^/projects/#{@project[:id]}/resources$}, page.current_path
     end
 
     attribute(:javascript, true)
-    test "create with duplicate keys redirects to edit" do
-      visit "/projects/#{@project.id}/resources/new"
-      find('label[for="resource-type-csv"]').click
-      attach_file('data', fixture_path('duplicate-keys.csv'))
-      click_button('Begin Importing')
+    test "editing import with duplicate keys" do
+      import = Import.create(:data => fixture_file_upload("duplicate-keys.csv"), :project => @project)
+      import.import!
 
+      visit "/projects/#{@project.id}/imports/#{import.id}/edit"
       assert find("h2").has_content?("Duplicate Keys")
-      assert_match %r{^/projects/#{@project.id}/imports/\d+/edit$}, page.current_path
     end
 
     attribute(:javascript, true)
     test "update import with duplicate keys" do
-      visit "/projects/#{@project.id}/resources/new"
-      find('label[for="resource-type-csv"]').click
-      attach_file('data', fixture_path('duplicate-keys.csv'))
-      click_button('Begin Importing')
+      import = Import.create(:data => fixture_file_upload("duplicate-keys.csv"), :project => @project)
+      resource = Resource.create(:name => import.name, :project => @project, :status => 'pending', :import => import)
+      import.import!
 
+      visit "/projects/#{@project.id}/imports/#{import.id}/edit"
       find('input[name="delete[2][]"][value="1"]').click
       click_button('Submit')
 
-      assert_match %r{^/projects/#{@project[:id]}/resources/\d+$}, page.current_path
+      resource.refresh
+      assert_equal "ok", resource.status
+      assert_match %r{^/projects/#{@project[:id]}/resources/#{resource.id}$}, page.current_path
     end
   end
 end

data/test/functional/test_notifications.rb

@@ -0,0 +1,38 @@
+require 'helper'
+
+module CouplerFunctionalTests
+  class TestNotifications < Coupler::Test::FunctionalTest
+
+    test "empty index" do
+      visit "/notifications"
+      assert_equal 200, page.status_code
+    end
+
+    test "index" do
+      n1 = Notification.create(:message => "Test!")
+      n2 = Notification.create(:message => "Another Test!", :url => "/projects")
+      n3 = Notification.create(:message => "Foo", :seen => true)
+      n4 = Notification.create(:message => "Bar", :url => "/connections", :seen => true)
+      visit "/notifications"
+      assert_equal 200, page.status_code
+    end
+
+    test "flags notifications as seen when url is visited" do
+      n = Notification.create(:message => "Foo bar", :url => "/connections")
+      visit "/connections"
+      n.reload
+      assert n.seen
+    end
+
+    test "unseen json" do
+      now = DateTime.now
+      Timecop.freeze(now) do
+        n1 = Notification.create(:message => "Foo bar", :url => "/connections")
+        n2 = Notification.create(:message => "Seen foo bar", :url => "/projects", :seen => true)
+      end
+      page.driver.get "/notifications/unseen.json"
+      result = JSON.parse(page.driver.response.body)
+      assert_equal([{'id' => n1.id, 'message' => 'Foo bar', 'url' => '/connections', 'created_at' => now.to_s}], result)
+    end
+  end
+end

data/test/integration/test_import.rb

@@ -5,7 +5,13 @@ class TestImport < Coupler::Test::IntegrationTest
   test "import!" do
     project = Project.create(:name => "foo")
     import = Import.create(:data => fixture_file_upload("people.csv"), :project => project)
-    import.import!
+
+    total = import.data.file.size
+    completed = 0
+    import.import! do |pos|
+      assert pos > completed
+      completed = pos
+    end
     assert_not_nil import.occurred_at
 
     project.local_database do |db|
@@ -22,6 +28,24 @@ class TestImport < Coupler::Test::IntegrationTest
     end
   end
 
+  test "import job" do
+    project = Project.create(:name => "foo")
+
+    tempfile = Tempfile.new('coupler-import')
+    tempfile.write("id,foo,bar\n1,2,3\n4,5,6\n7,8,9\n2,3,4\n5,6,7\n8,9,0\n")
+    tempfile.close
+    import = Import.create(:data => file_upload(tempfile.path), :project => project)
+    resource = Resource.create(:name => 'foo', :status => 'pending', :project => project, :import => import)
+
+    job = Job.create(:name => 'import', :import => import, :status => "scheduled")
+    job.execute
+
+    project.local_database do |db|
+      name = :"import_#{import.id}"
+      assert db.tables.include?(name)
+    end
+  end
+
   test "flags duplicate primary keys" do
     tempfile = Tempfile.new('coupler-import')
     tempfile.write("id,foo,bar\n1,abc,def\n2,ghi,jkl\n2,mno,pqr")

data/test/unit/models/test_field.rb

@@ -46,17 +46,6 @@ module CouplerUnitTests
         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)',
@@ -69,11 +58,11 @@ module CouplerUnitTests
         })
 
         assert_equal({
-          :name => 'foo', :type => 'varchar(255)',
+          :name => 'foo', :type => String, :size => 255,
           :primary_key => false
         }, field_1.local_column_options)
         assert_equal({
-          :name => 'foo', :type => 'int(11)',
+          :name => 'foo', :type => Integer,
           :primary_key => false
         }, field_2.local_column_options)
       end

data/test/unit/models/test_import.rb

@@ -31,6 +31,10 @@ module CouplerUnitTests
         assert_respond_to Models::Import.new, :project
       end
 
+      test "one to one resource" do
+        assert_respond_to Models::Import.new, :resource
+      end
+
       test "gets name from original filename" do
         import = new_import
         assert_equal "People", import.name

data/test/unit/models/test_job.rb

@@ -11,13 +11,20 @@ module CouplerUnitTests
         if attribs[:scenario]
           j.stubs(:scenario_dataset).returns(stub({:all => [attribs[:scenario]]}))
         end
+        if attribs[:import]
+          j.stubs(:import_dataset).returns(stub({:all => [attribs[:import]]}))
+        end
         j
       end
 
       def setup
         super
+        @project = stub('project', :pk => 1, :id => 1, :associations => {})
         @resource = stub('resource', :pk => 456, :id => 456, :associations => {})
         @scenario = stub('scenario', :pk => 456, :id => 456, :associations => {})
+        @import = stub('import', :pk => 123, :id => 123, :associations => {}, :project_id => 1, :project => @project, :name => 'foo')
+        @notification = stub('notification', :pk => 222, :id => 222, :associations => {})
+        Coupler::Models::Notification.stubs(:create).returns(@notification)
       end
 
       test "sequel model" do
@@ -33,6 +40,14 @@ module CouplerUnitTests
         assert_respond_to Job.new, :scenario
       end
 
+      test "belongs to import" do
+        assert_respond_to Job.new, :import
+      end
+
+      test "belongs to notification" do
+        assert_respond_to Job.new, :notification
+      end
+
       test "percent completed" do
         job = new_job(:name => 'transform', :resource => @resource, :total => 200, :completed => 54)
         assert_equal 27, job.percent_completed
@@ -48,7 +63,9 @@ module CouplerUnitTests
         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)
+        job.expects(:status=).with('done').in_sequence(seq)
+        job.expects(:completed_at=).with(now).in_sequence(seq)
+        job.expects(:save).in_sequence(seq)
         Timecop.freeze(now) { job.execute }
       end
 
@@ -60,8 +77,9 @@ module CouplerUnitTests
         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)
+        exception = fake_exception_klass.new("someone set us up the bomb")
+        @resource.expects(:transform!).raises(exception).in_sequence(seq)
+        job.expects(:update).with(has_entries(:status => 'failed', :completed_at => now, :error_msg => kind_of(String))).in_sequence(seq)
 
         Timecop.freeze(now) do
           begin
@@ -78,7 +96,9 @@ module CouplerUnitTests
         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)
+        job.expects(:status=).with('done').in_sequence(seq)
+        job.expects(:completed_at=).with(now).in_sequence(seq)
+        job.expects(:save).in_sequence(seq)
 
         Timecop.freeze(now) { job.execute }
       end
@@ -90,8 +110,9 @@ module CouplerUnitTests
         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)
+        exception = fake_exception_klass.new("someone set us up the bomb")
+        @scenario.expects(:run!).raises(exception).in_sequence(seq)
+        job.expects(:update).with(has_entries(:status => 'failed', :completed_at => now, :error_msg => kind_of(String))).in_sequence(seq)
 
         Timecop.freeze(now) do
           begin
@@ -110,6 +131,38 @@ module CouplerUnitTests
         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
+
+      test "import job" do
+        job = new_job(:name => 'import', :import => @import).save!
+
+        now = Time.now
+        seq = sequence("update")
+        @import.expects(:data).returns(mock(:file => mock(:size => 12345)))
+        job.expects(:update).with(:status => 'running', :total => 12345, :started_at => now).in_sequence(seq)
+        @import.expects(:import!).returns(true).in_sequence(seq)
+        @import.expects(:resource).returns(mock({:id => 456, :activate! => nil})).in_sequence(seq)
+        Notification.expects(:create).with(:message => "Import finished successfully", :url => "/projects/1/resources/456").returns(@notification).in_sequence(seq)
+        job.expects(:notification=).with(@notification).in_sequence(seq)
+        job.expects(:status=).with('done').in_sequence(seq)
+        job.expects(:completed_at=).with(now).in_sequence(seq)
+        job.expects(:save).in_sequence(seq)
+        Timecop.freeze(now) { job.execute }
+      end
+
+      test "import job with more interaction needed" do
+        job = new_job(:name => 'import', :import => @import).save!
+
+        now = Time.now
+        seq = sequence("update")
+        @import.expects(:data).returns(mock(:file => mock(:size => 12345)))
+        job.expects(:update).with(:status => 'running', :total => 12345, :started_at => now).in_sequence(seq)
+        @import.expects(:import!).returns(false).in_sequence(seq)
+        Notification.expects(:create).with(:message => "Import finished, but with errors", :url => "/projects/1/imports/123/edit").returns(@notification)
+        job.expects(:status=).with('done').in_sequence(seq)
+        job.expects(:completed_at=).with(now).in_sequence(seq)
+        job.expects(:save).in_sequence(seq)
+        Timecop.freeze(now) { job.execute }
+      end
     end
   end
 end

data/test/unit/models/test_notification.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+module TestModels
+  class TestNotification < Coupler::Test::UnitTest
+    include Coupler::Models
+    Coupler::Models::Notification  # force load
+
+    test "sequel model" do
+      assert_equal ::Sequel::Model, Notification.superclass
+      assert_equal :notifications, Notification.table_name
+    end
+
+    test "common model" do
+      assert Notification.ancestors.include?(CommonModel)
+    end
+  end
+end

data/test/unit/models/test_resource.rb

@@ -29,8 +29,15 @@ module CouplerUnitTests
           :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]]}))
+        if values[:project]
+          r.stubs(:project_dataset).returns(stub({:all => [values[:project]]}))
+        end
+        if values[:connection]
+          r.stubs(:connection_dataset).returns(stub({:all => [values[:connection]]}))
+        end
+        if values[:import]
+          r.stubs(:import_dataset).returns(stub({:all => [values[:import]]}))
+        end
         r
       end
 
@@ -311,23 +318,27 @@ module CouplerUnitTests
         assert_equal dataset, resource.local_dataset
       end
 
-      test "refresh fields" do
+      test "transformations_updated!" 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)
 
+        now = Time.now
         transformation_1 = stub("transformation 1", {
+          :id => 1, :updated_at => now,
           :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", {
+          :id => 2, :updated_at => now,
           :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", {
+          :id => 3, :updated_at => now,
           :source_field_id => 3, :result_field_id => 3,
           :field_changes => {3 => {:type => :datetime, :db_type => 'datetime'}},
           :source_field => field_3
@@ -349,10 +360,10 @@ module CouplerUnitTests
           :local_type => :datetime, :local_db_type => 'datetime'
         }).in_sequence(seq)
 
-        resource.refresh_fields!
+        resource.transformations_updated!
       end
 
-      test "refresh_fields does not change newly created result field" do
+      test "transformations_updated 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)
@@ -360,6 +371,7 @@ module CouplerUnitTests
         new_field = stub("new field", :id => 4)
 
         transformation = stub("transformation 1", {
+          :id => 1, :updated_at => Time.now,
           :source_field_id => 2, :result_field_id => 4,
           :field_changes => {2 => {:type => :integer, :db_type => 'int(11)'}},
           :source_field => field_2
@@ -373,10 +385,10 @@ module CouplerUnitTests
         field_2.expects(:update).never
         new_field.expects(:update).never
 
-        resource.refresh_fields!
+        resource.transformations_updated!
       end
 
-      test "refresh_fields resets local_type and local_db_type" do
+      test "transformations_updated resets local_type and local_db_type" do
         resource = new_resource.save!
 
         resource.expects(:fields_dataset).returns(mock {
@@ -386,7 +398,7 @@ module CouplerUnitTests
         td.expects(:order).with(:position).returns(td)
         resource.expects(:transformations_dataset).returns(td)
 
-        resource.refresh_fields!
+        resource.transformations_updated!
       end
 
       test "initial status" do
@@ -396,39 +408,108 @@ module CouplerUnitTests
 
       test "status after adding first transformation" do
         resource = new_resource.save!
-        resource.stubs(:transformation_ids).returns([1])
+
+        field_1 = stub("id field", :id => 1, :update => nil)
+        transformation_1 = stub("transformation 1", {
+          :id => 1, :updated_at => Time.now,
+          :source_field_id => 1, :result_field_id => 1,
+          :field_changes => {1 => {:type => :integer, :db_type => 'int(11)'}},
+          :source_field => field_1
+        })
+        resource.stubs(:fields_dataset).returns(stub(:update => nil))
+        td = [transformation_1]
+        td.expects(:order).with(:position).returns(td)
+        resource.expects(:transformations_dataset).returns(td)
+
+        resource.transformations_updated!
         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])
+        now = Time.now
+        resource = new_resource(:transformed_with => "1", :transformed_at => now - 5).save!
+
+        field_1 = stub("id field", :id => 1, :update => nil)
+        transformation_1 = stub("transformation 1", {
+          :id => 1, :updated_at => now - 10,
+          :source_field_id => 1, :result_field_id => 1,
+          :field_changes => {1 => {:type => :integer, :db_type => 'int(11)'}},
+          :source_field => field_1
+        })
+        transformation_2 = stub("transformation 2", {
+          :id => 2, :updated_at => now,
+          :source_field_id => 1, :result_field_id => 1,
+          :field_changes => {1 => {:type => :integer, :db_type => 'int(11)'}},
+          :source_field => field_1
+        })
+        resource.stubs(:fields_dataset).returns(stub(:update => nil))
+        td = [transformation_1, transformation_2]
+        td.expects(:order).with(:position).returns(td)
+        resource.expects(:transformations_dataset).returns(td)
+
+        resource.transformations_updated!
         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)
+        resource = new_resource({
+          :transformed_with => "1",
+          :transformed_at => now - 20
+        }).save!
+        field_1 = stub("id field", :id => 1, :update => nil)
+
+        transformation_1 = stub("transformation 1", {
+          :id => 1, :updated_at => now,
+          :source_field_id => 1, :result_field_id => 1,
+          :field_changes => {1 => {:type => :integer, :db_type => 'int(11)'}},
+          :source_field => field_1
         })
+
+        resource.stubs(:fields_dataset).returns(stub(:update => nil))
+        td = [transformation_1]
+        td.expects(:order).with(:position).returns(td)
+        resource.expects(:transformations_dataset).returns(td)
+
+        resource.transformations_updated!
         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([])
+        resource = new_resource({
+          :transformed_with => "1",
+          :transformed_at => now - 20
+        }).save!
+        td = []
+        td.stubs(:order).returns(td)
+        resource.stubs(:transformations_dataset).returns(td)
+
+        resource.transformations_updated!
         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])
+
+        field_1 = stub("id field", :id => 1, :update => nil)
+        transformation_1 = stub("transformation 1", {
+          :id => 1, :updated_at => Time.now,
+          :source_field_id => 1, :result_field_id => 1,
+          :field_changes => {1 => {:type => :integer, :db_type => 'int(11)'}},
+          :source_field => field_1
+        })
+        resource.stubs(:fields_dataset).returns(stub(:update => nil))
+        td = [transformation_1]
+        td.expects(:order).with(:position).returns(td)
+        resource.expects(:transformations_dataset).returns(td)
+        resource.transformations_updated!
         assert_equal "out_of_date", resource.status
-        resource.stubs(:transformation_ids).returns([])
+
+        td = []
+        td.stubs(:order).returns(td)
+        resource.stubs(:transformations_dataset).returns(td)
+        resource.transformations_updated!
         assert_equal "ok", resource.status
       end
 
@@ -511,18 +592,21 @@ module CouplerUnitTests
         resource.destroy
       end
 
-      test "creating resource via import" do
+      test "creating pending resource" do
+        resource = Resource.new(:name => "People", :project => @project, :status => 'pending')
+        assert resource.valid?
+        resource.save!
+      end
+
+      test "activate pending resource" do
         import = stub("import", {
           :id => 123, :pk => 123, :project => @project,
-          :name => "People"
+          :name => "People", :project_id => @project.id,
+          :associations => {}
         })
-        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?
+        resource = new_resource(:name => 'People', :status => 'pending', :import => import)
+        resource.save!
 
-        # import.import! would happen here
         @local_database.stubs({
           :tables => [:import_123],
           :schema => [
@@ -531,9 +615,10 @@ module CouplerUnitTests
             [:bar, {:primary_key => false, :type => :string, :db_type => "VARCHAR"}]
           ]
         })
-        resource.save!
+        resource.activate!
         assert_equal "id", resource.primary_key_name
         assert_equal "integer", resource.primary_key_type
+        assert_equal "ok", resource.status
       end
 
       test "source_dataset count" do