mode 0.0.17 → 0.0.18

data/spec/api/request_spec.rb

@@ -15,7 +15,7 @@ describe Mode::API::Request do
       }
     })
   end
-  
+
   before do
     initialize_logger
   end
@@ -46,7 +46,7 @@ describe Mode::API::Request do
       'test'        => 'test',
       'development' => 'localhost',
       'staging'     => 'staging.modeanalytics.com',
-      'production'  => 'stealth.modeanalytics.com'
+      'production'  => 'modeanalytics.com'
     }
 
     hosts.each do |env, host|
@@ -98,7 +98,7 @@ describe Mode::API::Request do
   end
 
   it 'return log error and return raw response on request errors' do
-    response = double(:get, { 
+    response = double(:get, {
       :status => 500,
       :success? => false,
       :body => '{"error": "failed"}'

data/spec/commands/connect_spec.rb

@@ -6,7 +6,7 @@ describe Mode::Commands::Connect do
   let(:daemon) { double(:daemon) }
 
   let(:data_source) {
-    Mode::Connector::DataSource.new('testdb', {
+    Mode::Connector::DataSources::Base.new('testdb', {
       'adapter' => 'postgres',
       'host' => 'localhost',
       'username' => 'postgres',
@@ -26,14 +26,6 @@ describe Mode::Commands::Connect do
       connect.command.should == 'start'
       connect.concurrency.should == 4
     end
-
-    it "registers connector" do
-      connect.should_receive(:configuration).and_return(config)
-
-      registrar = double(:registrar, :perform! => true)
-      Mode::Connector::Registrar.should_receive(:new).and_return(registrar)
-      connect.send(:register!)
-    end
   end
 
   describe "controlling the daemon" do
@@ -71,7 +63,6 @@ describe Mode::Commands::Connect do
   it 'executes the connector' do
     connect = Mode::Commands::Connect.new('start')
 
-    connect.should_receive(:register!)
     connect.should_receive(:run_command!)
     connect.should_receive(:validate_config!)
 

data/spec/config_spec.rb

@@ -28,7 +28,7 @@ describe Mode::Config do
 
   it "should initialize with data sources" do
     config = Mode::Config.init(tmpdir)
-    config.data_sources << Mode::Connector::DataSource.new('test', {})
+    config.data_sources << Mode::Connector::DataSources::Base.new('test', {})
     config.save
 
     config = Mode::Config.new(tmpdir)

data/spec/connector/commands/select_report_run_dataset_spec.rb

@@ -0,0 +1,96 @@
+require 'tempfile'
+require 'spec_helper'
+
+describe Mode::Connector::Commands::SelectReportRunDataset do
+  let(:data_sources) {
+    [
+      Mode::Connector::DataSources::Base.new('testdb', {
+        'adapter' => 'postgres',
+        'host' => 'localhost',
+        'username' => 'postgres',
+        'database' => 'warehouse',
+        'password' => nil
+      })
+    ]
+  }
+
+  let(:command) {
+    Mode::API::Resource.new({
+      'type' => 'query',
+      'query' => 'SELECT 1',
+      '_embedded' => {
+        'data_source' => {
+          'name' => 'testdb'
+        }
+      },
+      '_links' => {
+        'execution' => {
+          'href' => '/reports/5/runs/10'
+        }
+      }
+    })
+  }
+  
+  before do
+    initialize_logger
+  end
+
+  it "initializes with command and data sources" do
+    processor = Mode::Connector::Commands::SelectReportRunDataset.new(command, data_sources)
+
+    processor.command.should_not == nil
+    processor.data_sources.should_not == nil
+  end
+
+  it "selects a dataset" do
+    processor = Mode::Connector::Commands::SelectReportRunDataset.new(command, data_sources)
+
+    selector = double(:selector, :perform! => true)
+    Mode::Connector::Selector.should_receive(:new).with(
+      command.query, data_sources.first).and_return(selector)
+
+    processor.send(:dataset)
+  end
+
+  it "uploads a dataset" do
+    processor = Mode::Connector::Commands::SelectReportRunDataset.new(command, data_sources)
+
+    form = double(:form)
+    form.should_receive(:submit!).and_return(true)
+    command.should_receive(:forms).and_return(form)
+
+    file = Tempfile.new('foo')
+
+    dataset = double(:dataset,
+      :path => file.path,
+      :count => 1,
+      :column_types => [{:field => :type}])
+
+    processor.send(:upload, dataset)
+  end
+
+  it "sends an error" do
+    processor = Mode::Connector::Commands::SelectReportRunDataset.new(command, data_sources)
+
+    form = double(:form)
+    form.should_receive(:submit!).and_return(true)
+    command.should_receive(:forms).and_return(form)
+
+    processor.send(:error, "command", "details")
+  end
+
+  it "performs a send" do
+    processor = Mode::Connector::Commands::SelectReportRunDataset.new(command, data_sources)
+    processor.should_receive(:dataset).and_return(true)
+    processor.should_receive(:upload).and_return(true)
+    processor.perform!
+  end
+
+  it "performs an error" do
+    processor = Mode::Connector::Commands::SelectReportRunDataset.new(command, data_sources)
+    processor.should_receive(:dataset).and_raise(StandardError.new("BREAK!"))
+    processor.should_receive(:error).and_return(true)
+
+    processor.perform!
+  end
+end

data/spec/connector/commands/select_table_metadata_spec.rb

@@ -0,0 +1,115 @@
+require 'tempfile'
+require 'spec_helper'
+
+describe Mode::Connector::Commands::SelectTableMetadata do
+  let(:data_sources) {
+    [
+      Mode::Connector::DataSources::Base.new('testdb', {
+        'adapter' => 'postgres',
+        'host' => 'localhost',
+        'username' => 'postgres',
+        'database' => 'warehouse',
+        'password' => nil
+      })
+    ]
+  }
+
+  let(:command) {
+    Mode::API::Resource.new({
+      'command' => {
+        'name' => 'select:table:metadata'
+      },
+
+      '_embedded' => {
+        'data_source' => {
+          'name' => 'testdb'
+        },
+
+        'table' => {
+          'name' => 'testdb',
+          'schema' => 'public',
+
+          '_forms' => {
+            'method' => 'put',
+            'action' => 'tables/5',
+
+            'edit' => {
+              'input' => {
+                # should I test this here?
+              }
+            }
+          }
+        }
+      },
+
+      '_forms' => {
+        'edit' => {
+          'method' => 'put',
+          'action' => '/executions/5',
+
+          'input' => {
+            'execution' => {
+              'error' => {
+                'message' => {
+                  'type' => 'text'
+                },
+                'detail' => {
+                  'type' => 'text'
+                }
+              }
+            }
+          }
+        },
+
+        'succeed' => {
+          'method' => 'put',
+          'action' => '/executions/5'
+        }
+      }
+    })
+  }
+  
+  before do
+    initialize_logger
+  end
+
+  it "initializes with command and data sources" do
+    commander = Mode::Connector::Commands::SelectTableMetadata.new(command, data_sources)
+
+    commander.command.should_not == nil
+    commander.data_sources.should_not == nil
+
+    # accessors
+    commander.send(:table).should_not == nil
+  end
+
+  it "PUTs table metadata" do
+    commander = Mode::Connector::Commands::SelectTableMetadata.new(command, data_sources)
+
+    file = Tempfile.new('foo')
+
+    table = double(:table,
+      :columns   => :columns,
+      :row_count => :row_count,
+      :preview   => double(:preview,
+        :count => 10,
+        :path => file.path,
+        :column_types => {'field' => 'string'},
+      )
+    )
+
+    commander.should_receive(:table).and_return(table)
+
+    Mode::API::Request.should_receive(:put).and_return(true)
+
+    commander.perform!
+  end
+
+  it "PUTs success on completion" do
+    commander = Mode::Connector::Commands::SelectTableMetadata.new(command, data_sources)
+
+    Mode::API::Request.should_receive(:put).and_return(:success)
+
+    commander.send(:succeed).should == :success
+  end
+end

data/spec/connector/{data_source_spec.rb → data_sources/base_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Mode::Connector::DataSource do
+describe Mode::Connector::DataSources::Base do
   let(:props) {
     {
       'adapter' => 'postgres',
@@ -24,11 +24,11 @@ describe Mode::Connector::DataSource do
   let(:conn) { double(:conn, :extension => true) }
 
   it "initializes with props" do
-    source = Mode::Connector::DataSource.new('dev', props)
+    source = Mode::Connector::DataSources::Base.new('dev', props)
     source.adapter.should == 'postgres'
     source.host.should == 'localhost'
     source.username.should == 'postgres'
-    source.database.should == 'warehouse'
+    source.database_name.should == 'warehouse'
     source.password.should == nil
   end
   
@@ -37,29 +37,29 @@ describe Mode::Connector::DataSource do
   end
 
   it "has a connection url" do
-    source = Mode::Connector::DataSource.new('dev', props)
+    source = Mode::Connector::DataSources::Base.new('dev', props)
     source.send(:connection_url).should == "postgres://postgres@localhost/warehouse"
   end
 
   it 'has a jdbc connection url' do
-    source = Mode::Connector::DataSource.new('dev', props.merge('adapter' => 'jdbc:redshift'))
+    source = Mode::Connector::DataSources::Base.new('dev', props.merge('adapter' => 'jdbc:redshift'))
     source.send(:connection_url).should == "jdbc:postgresql://localhost/warehouse?user=postgres"
   end
 
   it "has a connection" do
-    source = Mode::Connector::DataSource.new('dev', props)
+    source = Mode::Connector::DataSources::Base.new('dev', props)
     Sequel.should_receive(:connect).and_return(conn)
     source.connection.should == conn
   end
 
   it 'has a connection for redshift' do
-    source = Mode::Connector::DataSource.new('dev', redprops)
+    source = Mode::Connector::DataSources::Base.new('dev', redprops)
     Sequel.should_receive(:connect).and_return(conn)
     source.connection.should == conn
   end
 
   it "fetches results from dataset" do
-    source = Mode::Connector::DataSource.new('dev', props)
+    source = Mode::Connector::DataSources::Base.new('dev', props)
 
     dataset = double(:dataset)
     connection = double(:conn, :dataset => dataset)

data/spec/connector/databases/rdbms_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Mode::Connector::Tables::RDBMS do
+  let(:tmpdir) { Dir.mktmpdir }
+  let(:config) { Mode::Config.init(tmpdir) }
+
+  let(:data_source) {
+    Mode::Connector::DataSources::Base.new('testdb', {
+      'adapter' => 'postgres',
+      'host' => 'localhost',
+      'username' => 'postgres',
+      'database' => 'warehouse',
+      'password' => nil
+    })
+  }
+
+  before do
+    initialize_logger
+  end
+
+  it "initializes" do
+    database = Mode::Connector::Databases::RDBMS.new(data_source, 'warehouse')
+
+    database.data_source.should == data_source
+    database.database_name.should == 'warehouse'
+  end
+
+  it "queries and returns columns" do
+    column = { :table_name => 'atable' }
+    data_source.should_receive(:select).and_yield(column)
+
+    database = Mode::Connector::Databases::RDBMS.new(data_source, 'warehouse')
+
+    database.columns.should == [column]
+  end
+
+  it "returns a table object" do
+    Mode::Connector::Tables::RDBMS.should_receive(:new).and_return(:table)
+    database = Mode::Connector::Databases::RDBMS.new(data_source, 'warehouse')
+
+    database.tables('public', 'accounts').should == :table
+  end
+end

data/spec/connector/dispatcher_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Mode::Connector::Dispatcher do
+  let(:data_sources) { double(:data_sources) }  
+
+  let(:select_table_metadata) {
+    Mode::API::Resource.new({
+      'command' => {
+        'name' => 'select:table:metadata'
+      }
+    })
+  }
+
+  let(:select_report_run_dataset) {
+    Mode::API::Resource.new({
+      'command' => {
+        'name' => 'select:report_run:dataset'
+      }
+    })
+  }
+
+  before do
+    initialize_logger
+  end
+
+  it "initializes" do
+    dispatcher = Mode::Connector::Dispatcher.new(select_table_metadata, data_sources)
+  end
+
+  it "dispatches a select report run dataset command" do
+    dispatcher = Mode::Connector::Dispatcher.new(select_report_run_dataset, data_sources)
+
+    commando = double(:commando, :perform! => true)
+    Mode::Connector::Commands::SelectReportRunDataset.should_receive(:new).and_return(commando)
+
+    dispatcher.perform!
+  end
+
+  it "dispatches a select table metadata command" do
+    dispatcher = Mode::Connector::Dispatcher.new(select_table_metadata, data_sources)
+
+    commando = double(:commando, :perform! => true)
+    Mode::Connector::Commands::SelectTableMetadata.should_receive(:new).and_return(commando)
+
+    dispatcher.perform!
+  end
+end

data/spec/connector/poller_spec.rb

@@ -17,11 +17,12 @@ describe Mode::Connector::Poller do
         'messages' => [{}, {}]
       }
     })
+    
     Mode::API::Request.should_receive(:get).with(path,
       {:num_messages => 5}).and_return(resource)
     
     poller.perform!(:num_messages => 5) do |message|
-      message.should be_instance_of(Mode::Connector::Message)
+      message.should be_instance_of(Mode::API::Resource)
     end
   end
 end

data/spec/connector/registrar_spec.rb

@@ -1,51 +1,136 @@
 require 'spec_helper'
 
 describe Mode::Connector::Registrar do
-  let(:tmpdir) { Dir.mktmpdir }
 
-  let(:username) { 'besquared' }
-  let(:password) { 'token_password '}
-  let(:config) { Mode::Config.init(tmpdir) }
-  let(:path) { Mode::API::Request.data_source_connection_path }
-
-  let(:props) {
+  let(:edit_form) {
     {
-      'adapter' => 'postgres',
-      'host' => 'localhost',
-      'username' => 'postgres',
-      'database' => 'warehouse',
-      'password' => nil
+      'method' => 'put',
+      'action' => '/path',
+
+      'input' => {
+        'data_source' => {
+          'tables[]' => {
+            'name' => {
+              'type' => 'text'
+            },
+
+            'schema' => {
+              'type' => 'text'
+            },
+
+            'columns[]' => {
+              'name' => {
+                'type' => 'text'
+              },
+
+              'data_type' => {
+                'type' => 'text'
+              },
+
+              'is_nullable' => {
+                'type' => 'select',
+                'options' => [true, false],
+                'value' => true
+              },
+
+              'primary_key' => {
+                'type' => 'select',
+                'options' => [true, false],
+                'value' => false
+              }
+            }
+          }
+        }
+      }
     }
   }
 
-  before do
-    initialize_logger
+  let(:connection) {
+    Mode::API::Resource.new({
+      '_embedded' => {
+        'data_sources' => [{
+          'name' => 'double',
 
-    Mode::API::Request.configure('test', {
-      'credentials' => {
-        'username' => username,
-        'password' => password
+          '_forms' => {
+            'edit' => edit_form
+          }
+        }]
       }
     })
+  }
+
+  let(:database) {
+    double(:warehouse,
+      :columns => [{
+        :table_schema => 'public',
+        :table_name   => 'accounts',
+        :column_name  => 'account_id',
+        :data_type    => 'character varying',
+        :is_nullable  => false,
+        :primary_key  => true
+      }]
+    )
+  }
 
-    config.data_sources << Mode::Connector::DataSource.new('dev', props)
+  let(:data_sources) {
+    [double(:data_source,
+      :name                    => 'double',
+      :adapter                 => 'jdbc:postgresql',
+      :host                    => 'localhost',
+      :username                => 'postgres',
+      :database_name           => 'warehouse',
+      :database                => database,
+      :connect                 => true,
+      :extension               => true,
+      :has_information_schema? => true)]
+  }
+
+  before do
+    initialize_logger
   end
 
   it "initializes with config" do
-    registration = Mode::Connector::Registrar.new(config)
+    registration = Mode::Connector::Registrar.new(data_sources)
   end
 
-  it 'performs registration request' do
-    registration = Mode::Connector::Registrar.new(config)
+  it 'should register a connection' do
+    registration = Mode::Connector::Registrar.new(data_sources)
 
-    Mode::API::Request.should_receive(:put).with(path, {
+    Mode::API::Request.should_receive(:put).with(
+      :data_source_connection, {
       :data_source_connection => {
         :data_sources => [{
-          :name => "dev",
-          :adapter => "postgres"
+          :name => "double",
+          :adapter => "jdbc:postgresql"
         }]
       }
-    })
+    }).and_return(connection)
+
+    registration.should_receive(:register_data_sources).and_return(true)
+
+    registration.perform!
+  end
+
+  it 'should register connection data sources' do
+    registration = Mode::Connector::Registrar.new(data_sources)
+
+    registration.should_receive(:register_connection).and_return(connection)
+
+    Mode::API::Request.should_receive(:put).with(
+      '/path', {
+      'data_source' => {
+        'tables' => [{
+          'schema'  => 'public',
+          'name'    => 'accounts',
+          'columns' => [{
+            'name'        => 'account_id',
+            'data_type'   => 'character varying',
+            'is_nullable' => false,
+            'primary_key' => true
+          }]
+        }]
+      }
+    }, {}).and_return(true)
 
     registration.perform!
   end