mode 0.0.17 → 0.0.18

data/lib/mode/connector/message.rb

@@ -1,31 +0,0 @@
-module Mode
-  module Connector
-    class Message
-      attr_reader :resource
-
-      def initialize(resource)
-        @resource = resource
-      end
-
-      def type
-        resource.content['type']
-      end
-
-      def name
-        resource.content['name']
-      end
-
-      def query
-        resource.content['query']
-      end
-
-      def data_source
-        resource.embedded('data_source')
-      end
-
-      def execution_path
-        resource.links('execution').href
-      end
-    end
-  end
-end

data/lib/mode/connector/processor.rb

@@ -1,58 +0,0 @@
-require 'date'
-require 'time'
-require 'tmpdir'
-
-module Mode
-  module Connector
-    class Processor
-      attr_reader :message
-      attr_reader :data_sources
-
-      def initialize(message, data_sources)
-        @message = message
-        @data_sources = data_sources
-      end
-
-      def perform!
-        if data_source
-          send!(select!)
-        else
-          raise "Data source not found #{message.data_source.name}"
-        end
-      rescue => err
-        error!(err.message, err.backtrace.join("\n"))
-        
-        Mode::Logger.instance.error(
-          "Connector::Processor", err.message, err.backtrace)
-      end
-
-      private
-
-      def select!
-        Mode::Connector::Selector.new(query, data_source).perform!
-      end
-
-      def send!(dataset)
-        Mode::Connector::Uploader.new(upload_path, dataset).perform!
-      end
-
-      def error!(message, detail = nil)
-        Mode::Connector::Uploader.error!(upload_path, message, detail)
-      end
-
-      def query
-        message.query
-      end
-
-      def upload_path
-        message.execution_path
-      end
-
-      def data_source
-        data_sources.find do |ds|
-          ds.name == message.data_source.name
-        end
-      end
-    end
-  end
-end

data/lib/mode/connector/uploader.rb

@@ -1,54 +0,0 @@
-module Mode
-  module Connector
-    class Uploader
-      attr_reader :path
-      attr_reader :dataset
-
-      def initialize(path, dataset)
-        @path = path
-        @dataset = dataset
-      end
-
-      def perform!
-        Mode::API::Request.put(path,
-          :report_run => {
-            :dataset => {
-              :count   => count,
-              :content => content,
-              :columns => JSON.generate(columns)
-            }
-          }
-        )
-      end
-
-      class << self
-        def error!(path, message, detail = nil)
-          Mode::API::Request.put(path,
-            :report_run => {
-              :error => {
-                :detail => detail,
-                :message => message
-              }
-            }
-          )
-        end
-      end
-
-      private
-
-      def count
-        dataset.count
-      end
-
-      def columns
-        dataset.column_types.map do |name, type|
-          {:name => name, :type => type}
-        end
-      end
-
-      def content
-        Faraday::UploadIO.new(dataset.path, 'applicaton/octet-stream')
-      end
-    end
-  end
-end

data/spec/connector/message_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Mode::Connector::Message do
-  let(:resource) {
-    Mode::API::Resource.new({
-      'type' => 'query',
-      'name' => 'fake',
-      'query' => 'query'
-    })
-  }
-  
-  before do
-    initialize_logger
-  end
-
-  it "initializes with resource" do
-    message = Mode::Connector::Message.new(resource)
-    message.type.should == 'query'
-    message.name.should == 'fake'
-    message.query.should == 'query'
-  end  
-end

data/spec/connector/processor_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-describe Mode::Connector::Processor do
-  let(:data_sources) {
-    [
-      Mode::Connector::DataSource.new('testdb', {
-        'adapter' => 'postgres',
-        'host' => 'localhost',
-        'username' => 'postgres',
-        'database' => 'warehouse',
-        'password' => nil
-      })
-    ]
-  }
-
-  let(:execution_path) { '/execution' }
-
-  let(:resource) {
-    Mode::API::Resource.new({
-      'type' => 'query',
-      'query' => 'SELECT 1',
-      '_embedded' => {
-        'data_source' => {
-          'name' => 'testdb'
-        }
-      },
-      '_links' => {
-        'execution' => {
-          'href' => execution_path
-        }
-      }
-    })
-  }
-
-  let(:message) {
-    Mode::Connector::Message.new(resource)
-  }
-  
-  before do
-    initialize_logger
-  end
-
-  it "initializes with message and data sources" do
-    processor = Mode::Connector::Processor.new(message, data_sources)
-
-    processor.message.should_not == nil
-    processor.data_sources.should_not == nil
-  end
-
-  it "selects a dataset" do
-    processor = Mode::Connector::Processor.new(message, data_sources)
-
-    selector = double(:selector, :perform! => true)
-    Mode::Connector::Selector.should_receive(:new).with(
-      message.query, data_sources.first).and_return(selector)
-
-    processor.send(:select!)
-  end
-
-  it "sends a dataset" do
-    processor = Mode::Connector::Processor.new(message, data_sources)
-
-    dataset = double(:dataset)
-    uploader = double(:uploader, :perform! => true)
-    Mode::Connector::Uploader.should_receive(:new).with(execution_path, dataset).and_return(uploader)
-
-    processor.send(:send!, dataset)
-  end
-
-  it "sends an error" do
-    processor = Mode::Connector::Processor.new(message, data_sources)
-
-    Mode::Connector::Uploader.should_receive(:error!).with(
-      execution_path, "message", "details").and_return(true)
-
-    processor.send(:error!, "message", "details")
-  end
-
-  it "performs a send" do
-    processor = Mode::Connector::Processor.new(message, data_sources)
-    processor.should_receive(:select!).and_return(true)
-    processor.should_receive(:send!).and_return(true)
-    processor.perform!
-  end
-
-  it "performs an error" do
-    processor = Mode::Connector::Processor.new(message, data_sources)
-    processor.should_receive(:select!).and_raise(StandardError.new("BREAK!"))
-    processor.should_receive(:error!).and_return(true)
-
-    processor.perform!
-  end
-end

data/spec/connector/uploader_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe Mode::Connector::Uploader do
-  let(:tmpdir) { Dir.mktmpdir }
-  let(:outpath) { File.join(tmpdir, 'data.csv') }
-  let(:runs_path) { Mode::API::Request.data_source_connection_path }
-
-  let(:dataset) {
-    double(:dataset,
-      :path => outpath,
-      :count => 0,
-      :column_types => {
-        'int' => :integer,
-        'float' => :number
-      }
-    )
-  }
-
-  before do
-    initialize_logger
-    FileUtils.touch(outpath)
-  end
-
-  it "initializes with a dataset" do
-    uploader = Mode::Connector::Uploader.new(runs_path, dataset)
-    uploader.dataset.should_not == nil
-  end
-
-  it "sends a dataset and columns" do
-    uploader = Mode::Connector::Uploader.new(runs_path, dataset)
-
-    Mode::API::Request.should_receive(:put).with(runs_path,
-      :report_run => {
-        :dataset => {
-          :count => 0,
-          :columns => an_instance_of(String), 
-          :content => an_instance_of(Faraday::UploadIO)
-        }
-      }
-    )
-
-    uploader.send(:perform!)
-  end
-
-  it "sends error message and detail" do
-    Mode::API::Request.should_receive(:put).with(runs_path,
-      :report_run => {
-        :error => {
-          :message => "message", 
-          :detail => "detailed"
-        }
-      }
-    )
-
-    Mode::Connector::Uploader.send(:error!, runs_path, "message", "detailed")
-  end
-end